using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media.Imaging;
using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.Wpf;
using InABox.WPF;
using Microsoft.Office.Interop.Outlook;
using PRSDesktop.Panels.Requisitions;
using Syncfusion.Windows.Tools.Controls;
using Exception = System.Exception;

namespace PRSDesktop;

public class RequisitionItemGrid : DynamicDataGrid<RequisitionItem>
{
    //public int Boxes { get; set; }

    private static readonly BitmapImage tick = PRSDesktop.Resources.tick.AsBitmapImage();
    private static readonly BitmapImage plus = PRSDesktop.Resources.plus.AsBitmapImage();
    private static readonly BitmapImage minus = PRSDesktop.Resources.minus.AsBitmapImage();

    private Task<List<Product>> _products;
    
    public Requisition? Requisition { get; set; }
    
    public RequisitionItemGrid()
    {
        HiddenColumns.Add(x => x.Code);
        HiddenColumns.Add(x => x.BarCode);
        HiddenColumns.Add(x => x.RequisitionLink.ID);
        HiddenColumns.Add(x => x.RequisitionLink.JobLink.ID);
        HiddenColumns.Add(x => x.RequisitionLink.JobScope.ID);
        HiddenColumns.Add(x => x.RequisitionLink.Filled);
        HiddenColumns.Add(x => x.RequisitionLink.Archived);
        HiddenColumns.Add(x => x.Product.ID);
        HiddenColumns.Add(x => x.Product.DefaultInstance.Style.ID);

        HiddenColumns.Add(x => x.EditType);

        foreach(var column in new Columns<RequisitionItem>()
            .AddDimensionsColumns(x => x.Product.DefaultInstance.Dimensions, Dimensions.ColumnsType.Data)
            .GetColumns())
        {
            HiddenColumns.Add(column);
        }

        //HiddenColumns.Add(x => x.Product.Units.ID);
        HiddenColumns.Add(x => x.Product.NonStock);
        HiddenColumns.Add(x => x.Location.ID);
        HiddenColumns.Add(x => x.Location.Code);
        HiddenColumns.Add(x => x.Location.Description);
        HiddenColumns.Add(x => x.Style.ID);
        HiddenColumns.Add(x => x.Style.Code);
        HiddenColumns.Add(x => x.Done);
        
        HiddenColumns.Add(x => x.Image.ID);
        HiddenColumns.Add(x => x.Image.FileName);
        
        ActionColumns.Add(new DynamicImageManagerColumn<RequisitionItem>(this, x => x.Image, true) { Position = DynamicActionColumnPosition.Start });
        ActionColumns.Add(new DynamicImageColumn(Done_Image, Done_Click)
        {
            ToolTip = Done_Tooltip
        });
        
        //ActionColumns.Add(new DynamicImageColumn(r => GetImage(r,minus),r => UpdatePick(r,-1.0)));
        //ActionColumns.Add(new DynamicTextColumn(r => r.Get<RequisitionItem,double>(c=>c.ActualQuantity), UpdatePick) { Format = "F2", Width=50, HeaderText = "Pick"});
        //ActionColumns.Add(new DynamicImageColumn(plus,r => UpdatePick(r,1.0)));

        _products = Task.Run(() =>
        {
            return Client.Query(null, new Columns<Product>(x => x.Code).Add(x => x.Name).Add(x => x.ID)).ToList<Product>();
        });
    }

    private FrameworkElement? Done_Tooltip(DynamicActionColumn column, CoreRow? row)
    {
        if(row is null)
        {
            return column.TextToolTip("Done?");
        }
        return null;
    }

    private bool Done_Click(CoreRow? row)
    {
        if (row is null) return false;

        var item = LoadItem(row);
        item.Done = true;
        SaveItem(item);
        return true;
    }

    private BitmapImage? Done_Image(CoreRow? row)
    {
        if (row is null) return tick;

        return row.Get<RequisitionItem, bool>(x => x.Done) == true ? tick : null;
    }

    private BitmapImage? GetImage(CoreRow? row, BitmapImage image)
    {
        return row == null || !row.Get<RequisitionItem, double>(c => c.ActualQuantity).IsEffectivelyEqual(0.0)
            ? image
            : null;
    }
    
    
    //private bool UpdatePick(CoreRow? row, double qty)
    //{
    //    if (row == null)
    //        return false;
    //    var item = row.ToObject<RequisitionItem>();
    //    item.ActualQuantity = Math.Max(0.0, item.ActualQuantity + qty);
    //    item.Picked = !item.ActualQuantity.IsEffectivelyEqual(0.0)
    //        ? DateTime.Now
    //        : DateTime.MinValue;
    //    if (item.IsChanged())
    //    {
    //        Client.Save(item, item.Picked.IsEmpty() ? "Item Unpicked" : "Item Picked", (o,e) => { });
    //        Data.LoadRow(row, item);
    //        InvalidateRow(row);
    //        return false;
    //    }
    //    return false;
    //}
    //
    //private bool UpdatePick(CoreRow? row)
    //{
    //    if(row is null)
    //        return false;
    //    var item = row.ToObject<RequisitionItem>();

    //    var quantity = item.ActualQuantity;
    //    if (DoubleEdit.Execute("Enter actual quantity picked:", 0, double.MaxValue, ref quantity))
    //    {
    //        item.ActualQuantity = quantity;
    //        item.Picked = !item.ActualQuantity.IsEffectivelyEqual(0.0)
    //            ? DateTime.Now
    //            : DateTime.MinValue;
    //    }
    //    else
    //        return false;

    //    if (item.IsChanged())
    //    {
    //        Client.Save(item, item.Picked.IsEmpty() ? "Item Unpicked" : "Item Picked");
    //        return true;
    //    }

    //    return false;
    //}

    protected override void DoReconfigure(FluentList<DynamicGridOption> options)
    {
        base.DoReconfigure(options);
        options.BeginUpdate()
            .Add(DynamicGridOption.RecordCount)
            .Add(DynamicGridOption.SelectColumns)
            .Add(DynamicGridOption.AddRows)
            .Add(DynamicGridOption.EditRows)
            .Add(DynamicGridOption.DeleteRows)
            .Add(DynamicGridOption.FilterRows)
            .EndUpdate();
    }
    
    protected override void Reload(Filters<RequisitionItem> criteria, Columns<RequisitionItem> columns, ref SortOrder<RequisitionItem>? sort,
        Action<CoreTable?, Exception?> action)
    {
        criteria.Add(
            new Filter<RequisitionItem>(x => x.RequisitionLink.ID).IsEqualTo(Requisition != null ? Requisition.ID : CoreUtils.FullGuid));

        sort = new SortOrder<RequisitionItem>(x => x.Created);

        base.Reload(
            criteria,
            columns,
            ref sort,
            action
        );
    }

    protected override bool CanCreateItems()
    {
        if(!Security.CanEdit<Requisition>() || !Security.CanEdit<RequisitionItem>())
        {
            return false;
        }
        else if(Requisition is null || Requisition.ID == Guid.Empty)
        {
            MessageWindow.ShowMessage("Please select a requisition.", "No requisition selected");
            return false;
        }
        else if (!Requisition.Filled.IsEmpty())
        {
            MessageWindow.ShowMessage("Cannot modify a filled requisition.", "Requisition already filled");
            return false;
        }
        return true;
    }

    public override RequisitionItem CreateItem()
    {
        var item = base.CreateItem();
        item.RequisitionLink.ID = Requisition?.ID ?? Guid.Empty;
        item.RequisitionLink.Synchronise(Requisition);
        item.Quantity = 1;
        return item;
    }

    private void DoEdit(CoreRow? row)
    {
        var item = row?.ToObject<RequisitionItem>();
        if(item is null)
        {
            if (!CanCreateItems())
                return;
            item = CreateItem();
        }

        var editor = new RequisitionItemEditor(_products.Result, item, true);
        if(editor.ShowDialog() == true && editor.Result is not null)
        {
            Refresh(false, true);
            DoChanged();
        }
    }

    protected override void DoEdit()
    {
        var rows = SelectedRows;
        if (rows.Length != 1) return;

        DoEdit(rows[0]);
    }
    protected override void DoAdd(bool OpenEditorOnDirectEdit = false)
    {
        DoEdit(null);
    }

    /*
    public override bool AfterCreate(RequisitionItem item)
    {
        var selection = new MultiSelectDialog<StockHolding>
        (
            null,
            new Columns<StockHolding>(
                x => x.Location.ID,
                x => x.Location.Code,
                x => x.Location.Description,
                x => x.Location.Area.Code,
                x => x.Location.Area.Description,
                x => x.Product.ID,
                x => x.Product.Code,
                x => x.Product.Name,
                x => x.Dimensions.UnitSize,
                x => x.Dimensions.Height,
                x => x.Dimensions.Width,
                x => x.Dimensions.Weight,
                x => x.Dimensions.Quantity,
                x => x.Dimensions.Length,
                x => x.Dimensions.Unit.ID,
                x => x.Dimensions.Unit.Format,
                x => x.Dimensions.Unit.Formula,
                x => x.Dimensions.Unit.HasHeight,
                x => x.Dimensions.Unit.HasWeight,
                x => x.Dimensions.Unit.HasWidth,
                x => x.Dimensions.Unit.HasQuantity,
                x => x.Dimensions.Unit.HasLength,
                x => x.Style.ID,
                x => x.Style.Code,
                x => x.Style.Description,
                x => x.Job.ID,
                x => x.Job.Name,
                x => x.Job.JobNumber,
                x => x.Units
            ), 
            false
        );

        if (!selection.ShowDialog() || !selection.Data().Rows.Any()) 
            return false;
        var row = selection.Data().Rows.First();
        var holding = row.ToObject<StockHolding>();
        item.Location.ID = holding.Location.ID;
        item.Location.Synchronise(holding.Location);
        item.Product.ID = holding.Product.ID;
        item.Product.Synchronise(holding.Product);
        item.Style.ID = holding.Style.ID;
        item.Style.Synchronise(holding.Style);
        item.JobLink.ID = holding.Job.ID;
        item.JobLink.Synchronise(holding.Job);
        item.Dimensions.CopyFrom(holding.Dimensions, true);
        return true;
    }
    */

    //protected override void CustomiseEditor(RequisitionItem[] items, DynamicGridColumn column, BaseEditor editor)
    //{
    //    if (column.ColumnName.Equals(CoreUtils.GetFullPropertyName<RequisitionItem, String>(c => c.Description, ".")))
    //        editor.Editable = Editable.Enabled;
    //    else if (column.ColumnName.Equals(CoreUtils.GetFullPropertyName<RequisitionItem, double>(c => c.Quantity, ".")))
    //        editor.Editable = Editable.Enabled;
    //    else if (column.ColumnName.Equals(CoreUtils.GetFullPropertyName<RequisitionItem, Guid>(c => c.JobRequisitionItem.ID, ".")))
    //        editor.Editable = Editable.Enabled;
    //    else if (column.ColumnName.Equals(CoreUtils.GetFullPropertyName<RequisitionItem, double>(c => c.ActualQuantity, ".")))
    //        editor.Editable = Editable.Hidden;
    //    else if (column.ColumnName.Equals(CoreUtils.GetFullPropertyName<RequisitionItem, DateTime>(c => c.Picked, ".")))
    //        editor.Editable = Editable.Hidden;
    //    else if (editor.Editable == Editable.Enabled)
    //        editor.Editable = Editable.Disabled;
    //    base.CustomiseEditor(items, column, editor);
    //}

    protected override bool CanDeleteItems(params CoreRow[] rows)
    {
        if(!Security.CanEdit<Requisition>() || !Security.CanEdit<RequisitionItem>())
        {
            return false;
        }
        else if(Requisition is null || Requisition.ID == Guid.Empty)
        {
            MessageWindow.ShowMessage("Please select a requisition.", "No requisition selected");
            return false;
        }
        else if (!Requisition.Filled.IsEmpty())
        {
            MessageWindow.ShowMessage("Cannot modify a filled requisition.", "Requisition already filled");
            return false;
        }
        return base.CanDeleteItems(rows);
    }


}