using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media.Imaging;
using InABox.Clients;
using InABox.Core;
using InABox.WPF;

namespace InABox.DynamicGrid;

public class DynamicProblemsColumn<TEntity> : DynamicImageColumn
    where TEntity : Entity, IRemotable, IPersistent, IProblems, new()
{
    private static readonly BitmapImage _warning = Wpf.Resources.warning.AsBitmapImage();
    private static readonly BitmapImage _graywarning = Wpf.Resources.warning.AsGrayScale().AsBitmapImage();

    private readonly IDynamicGrid _parent;

    public Func<IIssues[], FrameworkElement?>? CustomiseEditor { get; set; }
    
    public Action<IIssues[], FrameworkElement?>? IssuesUpdated { get; set; }

    public DynamicProblemsColumn(IDynamicGrid parent)
    {
        Image = IssuesImage;
        Filters = new[] { "Active Issues", "No Issues" };
        FilterRecord = DoFilterIssues;
        ContextMenu = CreateIssuesMenu;
        ToolTip = CreateIssuesToolTip;
        _parent = parent;
        Position = DynamicActionColumnPosition.Start;
    }
    
    private BitmapImage? IssuesImage(CoreRow? row)
    {
        if (row?.Get<TEntity,string[]>(x=>x.Problem.Notes)?.Any() != true)
            return null;
        return row?.Get<TEntity,DateTime>(x=>x.Problem.Resolved).IsEmpty() == true
            ? _warning
            : _graywarning;
    }

    private FrameworkElement? CreateIssuesToolTip(DynamicActionColumn column, CoreRow? row)
    {
        var text = row?.Get<TEntity, string[]>(x => x.Problem.Notes) ?? new string[] { };
        return TextToolTip(string.Join("\n==================================", text));
    }

    private bool DoFilterIssues(CoreRow row, string[] filter)
    {
        var noissues = row?.Get<TEntity, string[]>(x => x.Problem.Notes)?.Any() != true;
        if (filter.Contains("No Issues") && noissues)
            return true;
        if (filter.Contains("Active Issues") && !noissues)
            return true;
        return false;
    }

    private MenuItem CreateMenu(string caption, RoutedEventHandler click)
    {
        var item = new MenuItem();
        item.Header = caption;
        item.Click += click;
        return item;
    }

    private ContextMenu? CreateIssuesMenu(CoreRow[]? rows)
    {
        if (!Security.CanManageProblems<TEntity>())
            return null;

        var issues = rows?.FirstOrDefault()?.Get<TEntity, string[]>(x => x.Problem.Notes)?.Any() == true;
        var result = new ContextMenu();

        if (issues != true)
        {
            result.Items.Add(CreateMenu("Create Issue", (o, e) => EditIssues(rows)));
        }
        else
        {
            result.Items.Add(CreateMenu("Update Issues", (o, e) => EditIssues(rows)));
            if (Security.CanManageProblems<TEntity>())
            {
                result.Items.Add(new Separator());
                result.Items.Add(CreateMenu("Mark as Resolved", (o, e) => ResolveIssues(rows)));
            }
        }

        return result;
    }

    private void ResolveIssues(CoreRow[]? rows)
    {
        var row = rows?.FirstOrDefault();
        if (row == null)
            return;
        
        var entity = row.ToObject<TEntity>();
        entity.Problem.Resolved = DateTime.Now;
        using (new WaitCursor())
            Client.Save(entity, "Resolving Issues", (o, e) => { });
        
        // False here to prevent Refreshing and losing the selected row record
        _parent.UpdateRow<TEntity, DateTime>(row, x=>x.Problem.Resolved, entity.Problem.Resolved);
        
        // if (MessageBox.Show("This will clear the flagged issues for these items!\n\nAre you sure you wish to continue?", "Confirm",
        //         MessageBoxButton.YesNo) == MessageBoxResult.Yes)
        // {
        //     var _updates = LoadIssues(rows).ToArray();
        //     foreach (var update in _updates)
        //     {
        //         update.Issues = "";
        //     }
        //     using (new WaitCursor())
        //     {
        //         Client.Save(_updates, "Clearing Issues", (o, e) => { });
        //     }
        //
        //     // False here to prevent Refreshing and losing the selected row record
        //     foreach (var row in rows)
        //         _parent.UpdateRow(row, IssuesProperty, "");
        // }
    }

    private void EditIssues(CoreRow[]? rows)
    {
        
        var row = rows?.FirstOrDefault();
        if (row == null)
            return;
        
        var entity = row.ToObject<TEntity>();
        
        var _grid = DynamicGridUtils.CreateDynamicGrid(typeof(DynamicItemsListGrid<>), entity.Problem.GetType());
        if (_grid.EditItems(new object[] { entity.Problem }))
        {
            using (new WaitCursor())
                Client.Save(entity, "Resolving Issues", (o, e) => { });
            row.Table.FillRow(row, entity);
            _parent.InvalidateRow(row);
        }
    }
}