using System;
using System.Collections.Generic;
using System.Linq;
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.Reports;
using InABox.Core.Reports;
using InABox.Wpf.Reports;
using InABox.WPF;

namespace PRSDesktop
{
    public class ReadyToGoGrid : DynamicDataGrid<DeliveryItem>, IJobControl, IDataModelSource
    {
        private readonly BitmapImage barcode = PRSDesktop.Resources.barcode.AsBitmapImage();

        private readonly BitmapImage setout = PRSDesktop.Resources.design.AsBitmapImage();

        private readonly BitmapImage Tick = PRSDesktop.Resources.tick.AsBitmapImage();

        //private BitmapImage Lifter = PRSDesktop.Resources.lifter.AsBitmapImage();
        private readonly BitmapImage Truck = PRSDesktop.Resources.truck.AsBitmapImage();

        public ReadyToGoGrid()
        {
            ParentID = Guid.Empty;
            Search = "";

            Options.AddRange(DynamicGridOption.RecordCount, DynamicGridOption.SelectColumns, DynamicGridOption.AddRows, DynamicGridOption.EditRows,
                DynamicGridOption.FilterRows, DynamicGridOption.DeleteRows, DynamicGridOption.MultiSelect);

            ActionColumns.Add(new DynamicImageColumn(BarcodeImage, BarcodeClick) { AllowHeaderClick = true });
            ActionColumns.Add(new DynamicMapColumn<DeliveryItem>(this, x => x.Location));

            AddButton("Mark as Delivered", Truck, MarkAsDelivered);

            HiddenColumns.Add(x => x.DeliveredDate);
            HiddenColumns.Add(x => x.Delivery.ID);

            ActionColumns.Add(new DynamicImageColumn(SetoutImage, SetoutClick) { Position = DynamicActionColumnPosition.Start });
            HiddenColumns.Add(x => x.ManufacturingPacketLink.ID);
            HiddenColumns.Add(x => x.ManufacturingPacketLink.Deleted);
            HiddenColumns.Add(x => x.ManufacturingPacketLink.WaterMark);
            HiddenColumns.Add(x => x.ManufacturingPacketLink.SetoutLink.ID);
            HiddenColumns.Add(x => x.ManufacturingPacketLink.SetoutLink.Deleted);
            HiddenColumns.Add(x => x.ManufacturingPacketLink.ManufacturingTemplateLink.Factory.Name);
        }

        public string Search { get; set; }

        public CoreTable Items { get; private set; }

        public event DataModelUpdateEvent OnUpdateDataModel;

        public string SectionName => "Ready To Go Grid";

        public DataModel DataModel(Selection selection)
        {
            var ids = ExtractValues(x => x.ID, selection).ToArray();
            return new DeliveryItemDataModel(new Filter<DeliveryItem>(x => x.ID).InList(ids));
        }

        public Guid ParentID { get; set; }
        
        public JobPanelSettings Settings { get; set; }

        private BitmapImage BarcodeImage(CoreRow? arg)
        {
            return barcode;
        }

        private BitmapImage? SetoutImage(CoreRow? arg)
        {
            if (arg == null)
                return null;
            return arg.IsEntityLinkValid<DeliveryItem, ManufacturingPacketLink>(x => x.ManufacturingPacketLink) ? setout : null;
        }

        private bool SetoutClick(CoreRow? arg)
        {
            if (arg is null) return false;

            var setoutid = arg.EntityLinkID<DeliveryItem, SetoutLink>(x => x.ManufacturingPacketLink.SetoutLink) ?? Guid.Empty;
            if (setoutid != Guid.Empty)
            {
                var table = new Client<SetoutDocument>().Query(new Filter<SetoutDocument>(x => x.EntityLink.ID).IsEqualTo(setoutid));
                IEntityDocument[] docs = table.Rows.Select(r => r.ToObject<SetoutDocument>()).ToArray();
                var viewer = new DocumentEditor(docs);
                //viewer.PrintAllowed = Security.IsAllowed<CanPrintFactoryFloorDrawings>();
                viewer.SaveAllowed = Security.IsAllowed<CanSaveFactoryFloorDrawings>();
                viewer.Watermark = arg.Get<DeliveryItem, string>(x => x.ManufacturingPacketLink.WaterMark);
                viewer.ShowDialog();
            }

            return false;
        }

        private bool MarkAsDelivered(Button sender, CoreRow[] rows)
        {
            if (!rows.Any())
            {
                MessageBox.Show("Please select at least one row to process");
                return false;
            }

            var date = DateTime.Today;
            if (DateEdit.Execute("Enter Delivered Date", ref date))
            {
                Filter<DeliveryItem>? filter = null;
                foreach (var row in rows)
                {
                    var id = row.Get<DeliveryItem, Guid>(x => x.ID);
                    if (filter == null)
                        filter = new Filter<DeliveryItem>(x => x.ID).IsEqualTo(id);
                    else
                        filter = filter.Or(x => x.ID).IsEqualTo(id);
                }

                if (filter != null)
                {
                    var items = new Client<DeliveryItem>().Load(filter);
                    foreach (var item in items)
                        item.DeliveredDate = date;
                    new Client<DeliveryItem>().Save(items, "Items Marked as Delivered");
                    return true;
                }
            }

            return false;
        }

        private bool BarcodeClick(CoreRow? arg)
        {
            if (arg is null) return false;

            var id = arg.Get<DeliveryItem, Guid>(x => x.ID);
            var group = arg.Get<DeliveryItem, string>(x => x.ManufacturingPacketLink.ManufacturingTemplateLink.Factory.Name);
            var ReportName = "Print Bar Codes" + (!string.IsNullOrWhiteSpace(group) ? " - " + group : "");
            var datamodel = new DeliveryItemDataModel(new Filter<DeliveryItem>(x => x.ID).IsEqualTo(id));

            var repclient = new Client<ReportTemplate>();
            var report = repclient.Load(
                new Filter<ReportTemplate>(x => x.DataModel).IsEqualTo(datamodel.Name)
                    .And(x => x.Section).IsEqualTo(SectionName)
                    .And(x => x.Name).IsEqualTo(ReportName)
                ).FirstOrDefault();
            if (report == null)
            {
                ReportName = "Print Bar Codes";
                report = repclient.Load(
                    new Filter<ReportTemplate>(x => x.DataModel).IsEqualTo(datamodel.Name)
                    .And(x => x.Section).IsEqualTo(SectionName)
                        .And(x => x.Name).IsEqualTo(ReportName)
                    ).FirstOrDefault();
            }

            if (report == null)
            {
                MessageBox.Show(string.Format("{0} -> [{1}] report does not exist!", datamodel.Name, ReportName));
                return false;
            }

            var rows = new List<CoreRow>();

            ReportUtils.PreviewReport(report, datamodel, false, Security.IsAllowed<CanDesignReports>());
            return false;
        }

        private bool DeliveredClick(CoreRow arg)
        {
            var id = arg.Get<DeliveryItem, Guid>(x => x.ID);
            var item = new Client<DeliveryItem>().Load(new Filter<DeliveryItem>(x => x.ID).IsEqualTo(id)).FirstOrDefault();
            if (item != null)
            {
                item.DeliveredDate = item.DeliveredDate.IsEmpty() ? DateTime.Now : DateTime.MinValue;
                new Client<DeliveryItem>().Save(item, item.DeliveredDate.IsEmpty() ? "Delivered Flag Cleared" : "Item Marked as Delivered");
            }

            return true;
        }

        private BitmapImage? DeliveredImage(CoreRow arg)
        {
            if (arg == null)
                return Truck;
            var date = arg.Get<DeliveryItem, DateTime>(x => x.DeliveredDate);
            return date.IsEmpty() ? null : Tick;
        }

        protected override void Reload(Filters<DeliveryItem> criteria, Columns<DeliveryItem> columns, ref SortOrder<DeliveryItem>? sort,
            Action<CoreTable?, Exception?> action)
        {
            var filter = new Filter<DeliveryItem>(x => x.DeliveredDate).IsEqualTo(DateTime.MinValue)
                .And(x => x.ManufacturingPacketLink.Completed).IsNotEqualTo(DateTime.MinValue);
            if (ParentID != Guid.Empty)
                filter = filter.And(x => x.JobLink.ID).IsEqualTo(ParentID);
            if (!string.IsNullOrEmpty(Search))
                filter = filter.TextSearch(Search,
                    x => x.Barcode,
                    x => x.Description,
                    x => x.JobLink.JobNumber,
                    x => x.JobLink.Name,
                    x => x.ManufacturingPacketLink.Serial,
                    x => x.ManufacturingPacketLink.Title,
                    x => x.ManufacturingPacketLink.SetoutLink.Number
                );
            criteria.Add(filter);
            sort = new SortOrder<DeliveryItem>(x => x.Barcode);
            base.Reload(criteria, columns, ref sort, action);
        }
    }
}