using Comal.Classes;
using Comal.Stores;
using InABox.Core;
using InABox.Database;
using PRS.Shared.Database_Update_Scripts.Utils;
using PRSStores;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static ICSharpCode.AvalonEdit.Document.TextDocumentWeakEventManager;

namespace PRS.Shared;

public class Update_7_52 : DatabaseUpdateScript
{
    public override VersionNumber Version => new VersionNumber(7, 52);

    private IStore<JobRequisitionItem>? _store;

    private IStore<JobRequisitionItem> Store
    {
        get
        {
            _store ??= DbFactory.FindStore<JobRequisitionItem>(Guid.Empty, "", Platform.Server, CoreUtils.GetVersion(), Logger.New());
            return _store;
        }
    }

    private static void UpdateStockMovements()
    {
        var jobRequiItems = DbFactory.NewProvider(Logger.Main).Query(
            new Filter<JobRequisitionItem>(x => x.PurchaseOrderItem.ID).IsNotEqualTo(null),
            Columns.None<JobRequisitionItem>().Add(x => x.ID)
                .Add(x => x.PurchaseOrderItem.ID))
            .ToObjects<JobRequisitionItem>()
            .ToList();

        var mvts = DbFactory.NewProvider(Logger.Main).Query(
            new Filter<StockMovement>(x => x.JobRequisitionItem.ID).IsEqualTo(null)
                .And(x => x.OrderItem.ID).IsNotEqualTo(null)
                .And(new Filter<StockMovement>(x => x.OrderItem.ID).InQuery<JobRequisitionItemPurchaseOrderItem>(null, x => x.PurchaseOrderItem.ID)
                    .Or(x => x.OrderItem.ID).InQuery<JobRequisitionItem>(null, x => x.PurchaseOrderItem.ID)),
            Columns.None<StockMovement>().Add(x => x.ID)
                .Add(x => x.OrderItem.ID))
            .ToObjects<StockMovement>()
            .ToList();

        Logger.Send(LogType.Information, "", $"Updating JobRequisitionItem.ID for {mvts.Count} StockMovements");

        var orderItemIDs = mvts.Select(x => x.OrderItem.ID).ToArray();

        var jriPois = DbFactory.NewProvider(Logger.Main).Query(
            new Filter<JobRequisitionItemPurchaseOrderItem>(x => x.PurchaseOrderItem.ID).InList(orderItemIDs),
            Columns.None<JobRequisitionItemPurchaseOrderItem>().Add(x => x.JobRequisitionItem.ID).Add(x => x.PurchaseOrderItem.ID))
            .ToObjects<JobRequisitionItemPurchaseOrderItem>();

        var jris = DbFactory.NewProvider(Logger.Main).Query(
            new Filter<JobRequisitionItem>(x => x.PurchaseOrderItem.ID).InList(orderItemIDs),
            Columns.None<JobRequisitionItem>().Add(x => x.ID).Add(x => x.PurchaseOrderItem.ID))
            .ToObjects<JobRequisitionItem>();

        var requiIDs = new Dictionary<Guid, Guid>();
        foreach(var jriPoi in jriPois)
        {
            requiIDs.TryAdd(jriPoi.PurchaseOrderItem.ID, jriPoi.JobRequisitionItem.ID);
        }
        foreach (var jriPoi in jris)
        {
            requiIDs.TryAdd(jriPoi.PurchaseOrderItem.ID, jriPoi.ID);
        }

        foreach(var mvt in mvts)
        {
            if(requiIDs.TryGetValue(mvt.OrderItem.ID, out var requiItemID))
            {
                mvt.JobRequisitionItem.ID = requiItemID;
            }
            else
            {
                Logger.Send(LogType.Error, "", $"StockMovement which didn't have an associated JobRequisitionItem: {mvt.ID}");
            }
        }

        var changed = mvts.Where(x => x.IsChanged()).ToList();

        // Not going through the store otherwise the JobRequisitionItem Status will be updated incorrectly.
        DbFactory.NewProvider(Logger.Main).Save(changed);

        Logger.Send(LogType.Information, "", $"Updated {changed.Count} StockMovements");
    }

    private void UpdateOrderStatus()
    {
        var jobRequiItems = DbFactory.NewProvider(Logger.Main).Query(
            new Filter<JobRequisitionItem>(x => x.OrderRequired).IsEqualTo(DateTime.MinValue)
                .And(new Filter<JobRequisitionItem>(x => x.Status).IsEqualTo(JobRequisitionItemStatus.OrderRequired)
                    .Or(x => x.Status).IsEqualTo(JobRequisitionItemStatus.OnOrder)
                    .Or(x => x.Status).IsEqualTo(JobRequisitionItemStatus.Received)),
            Columns.None<JobRequisitionItem>().Add(x => x.ID)
                .Add(x => x.LastUpdate))
            .ToObjects<JobRequisitionItem>()
            .ToList();

        foreach (var jri in jobRequiItems)
        {
            jri.OrderRequired = jri.LastUpdate;
        }

        DbFactory.NewProvider(Logger.Main).Save(jobRequiItems);
    }

    private void CreateJobRequisitionItemPurchaseOrderItems()
    {
        var jobRequiItems = DbFactory.NewProvider(Logger.Main).Query(
            new Filter<JobRequisitionItem>(x => x.PurchaseOrderItem.ID).IsNotEqualTo(null)
                .And(x => x.ID).NotInQuery<JobRequisitionItemPurchaseOrderItem>(
                    null,
                    x => x.JobRequisitionItem.ID),
            Columns.None<JobRequisitionItem>().Add(x => x.ID)
                .Add(x => x.PurchaseOrderItem.ID)
                .Add(x => x.Status))
            .ToObjects<JobRequisitionItem>()
            .ToList();
        Logger.Send(LogType.Information, "", $"Creating JobRequisitionPurchaseOrderItems for {jobRequiItems.Count} JobRequisitionItems");

        var newJRIPois = new List<JobRequisitionItemPurchaseOrderItem>();
        foreach (var jri in jobRequiItems)
        {
            var jriPoi = new JobRequisitionItemPurchaseOrderItem();
            jriPoi.JobRequisitionItem.ID = jri.ID;
            jriPoi.PurchaseOrderItem.ID = jri.PurchaseOrderItem.ID;
            newJRIPois.Add(jriPoi);
        }
        DbFactory.NewProvider(Logger.Main).Save(newJRIPois);
        DbFactory.NewProvider(Logger.Main).Save(jobRequiItems);
    }

    public override bool Update()
    {
        UpdateStockMovements();
        UpdateOrderStatus();
        CreateJobRequisitionItemPurchaseOrderItems();
        JobRequisitionItemUtils.RefreshStatuses(Store);

        return true;
    }
}