using EgwCoreLib.Lux.Core;
using EgwCoreLib.Lux.Core.Generic;
using EgwCoreLib.Lux.Core.RestPayload;
using EgwCoreLib.Lux.Data.DbModel.Config;
using EgwCoreLib.Lux.Data.DbModel.Sales;
using EgwCoreLib.Lux.Data.Services;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Cors.Infrastructure;
using Microsoft.EntityFrameworkCore.Migrations;
using Microsoft.JSInterop;
using NLog;

namespace Lux.UI.Components.Pages
{
    public partial class Orders
    {
        #region Protected Enums

        /// <summary>
        /// Stato Ordine
        /// </summary>
        protected enum CompileStep
        {
            Draft = 0,
            Header = 1,
            General,
            Rows,
            Delivery,
            FinalCheck
        }

        #endregion Protected Enums

        #region Protected Properties

        [Inject]
        protected IConfiguration Config { get; set; } = null!;

        [Inject]
        protected CalcRuidService CRService { get; set; } = null!;

        protected string DivMainCss
        {
            get => SelRecord != null ? "col-6" : "col-12";
        }

        [Inject]
        protected DataLayerServices DLService { get; set; } = null!;

        /// <summary>
        /// Filtro stato ordini
        /// </summary>
        protected Enums.OrderStates? FiltState
        {
            get => filtState;
            set
            {
                if (filtState != value)
                {
                    filtState = value;
                    DoFilter();
                    UpdateTable();
                }
            }
        }

        [Inject]
        protected IJSRuntime JSRuntime { get; set; } = null!;

        [Inject]
        protected ProdService PService { get; set; } = null!;

        #endregion Protected Properties

        #region Protected Methods

        protected string CheckSelect(OrderModel curRec)
        {
            string answ = "";
            if (SelRecord != null)
            {
                answ = curRec.OfferID == SelRecord.OfferID ? "table-info" : "";
            }
            return answ;
        }

        protected void DoAdd()
        {
            EditRecord = new OrderModel()
            {
                RefYear = DateTime.Today.Year,
                Description = $"Nuova Offerta {DateTime.Today:ddd yyyy.MM.dd}",
                ValidUntil = DateTime.Today.AddMonths(1)
            };
        }

        protected void DoEdit(OrderModel curRec)
        {
            currStep = CompileStep.Header;
            EditRecord = curRec;
        }

        protected void DoReset()
        {
            EditRecord = null;
            SelRecord = null;
        }

        protected void DoSelect(OrderModel curRec)
        {
            SelRecord = curRec;
        }

        protected override async Task OnInitializedAsync()
        {
            // prendo il trim corrente + anno precedente...
            PeriodoSel = new EgwCoreLib.Utils.DtUtils.Periodo(EgwCoreLib.Utils.DtUtils.PeriodSet.ThisTrim);
            PeriodoSel.Inizio = PeriodoSel.Inizio.AddYears(-1);
            SetupArrows();
            ConfInit();
            await ReloadBaseData();
            await ReloadData();
            UpdateTable();
        }

        /// <summary>
        /// Rimette un Job da coda running in waiting
        /// </summary>
        /// <returns></returns>
        protected async Task ReRunJob(string? JobCode)
        {
            if (!string.IsNullOrEmpty(JobCode))
            {
                if (!await JSRuntime.InvokeAsync<bool>("confirm", $"Sicuro di voler rimettere in coda il calcolo?"))
                    return;

                await PService.ReRunJob(JobCode);
                await UpdateJobQueue();
            }
        }

        /// <summary>
        /// Reseet History dell'ordine
        /// </summary>
        /// <param name="currRec"></param>
        /// <returns></returns>
        protected async Task ResetHistory(OrderModel currRec)
        {
            if (!await JSRuntime.InvokeAsync<bool>("confirm", $"Sicuro di voler resettare l'history dell'ordine corrente? L'operazione non è revertibile."))
                return;

            currRec.LogHistory = new List<TaskHistDTO>();
            OrderHist = currRec.LogHistory;
            await DLService.OrderUpsert(currRec);
        }

        /// <summary>
        /// Resetta coda running riportandoli in waiting
        /// </summary>
        /// <returns></returns>
        protected async Task ResetRunQueue()
        {
            if (!await JSRuntime.InvokeAsync<bool>("confirm", $"Sicuro di voler resettarela coda di run calcolo? Le richieste verranno riaccodate in waiting."))
                return;

            await PService.ResetRunning();
            await UpdateJobQueue();
        }

        /// <summary>
        /// Resetta coda waiting eliminando task
        /// </summary>
        /// <returns></returns>
        protected async Task ResetWaitQueue()
        {
            if (!await JSRuntime.InvokeAsync<bool>("confirm", $"Sicuro di voler resettarela coda di attesa calcolo eliminando le richieste in attesa? L'operazione non è revertibile."))
                return;

            await PService.QueueResetAsync(ProdService.QueueType.waiting);
            await UpdateJobQueue();
        }

        /// <summary>
        /// Manda l'ordine in fase di estimation
        /// </summary>
        /// <returns></returns>
        protected async Task SendEstim(OrderModel currRec)
        {
            /* ---------------------------------
             * Manda in stima l'ordine:
             * - genera Json richiesta
             * - salva in cache REDIS + invia richiesta via channel Redis
             * - prepara x visualizzazione l'history
             * - registra l'history serializzata sul record..
             * --------------------------------- */

            if (!await JSRuntime.InvokeAsync<bool>("confirm", $"Confermi di voler inviare una richiesta di stima tempi per l'ordine in oggetto? l'esecuzione non avverà in realtime e sarà accodata per l'esecuzione."))
                return;

            // processo riga ordine x riga ordine creando per ogni riga una richiesta...
            if (currRec.OrderRowNav != null && currRec.OrderRowNav.Count > 0)
            {
                // verifico parametri da conf envir...
                var envRec = AllConfEnvir.FirstOrDefault(x => x.EnvirID == currRec.Envir);
                Egw.Window.Data.Enums.QuestionModes cMode = Egw.Window.Data.Enums.QuestionModes.ORDER;
                Egw.Window.Data.Enums.QuestionOrderSubModes cSubMode = Egw.Window.Data.Enums.QuestionOrderSubModes.ESTIMATE;
                string reqKey = "";
                foreach (var rigaOrd in currRec.OrderRowNav)
                {
                    // preparo le 2 richieste (creazione, stima)
                    CalcRequestDTO calcReq = new CalcRequestDTO();
                    bool needCalc = false;
                    // recupero elenco items collegati alla riga d'ordine
                    var ProdList = await DLService.ProdItemByOrderRow(rigaOrd.OrderRowID);
                    List<string> TagsList = ProdList.Select(x => x.ProdLabel).ToList();
                    //string serTagList = JsonConvert.SerializeObject(TagList);
                    string serTagList = string.Join(",", TagsList);
                    // preparo richiesta serializzata e la accodo (viene inviata richiesta calcolo)
                    Dictionary<string, string> dictArgs = new Dictionary<string, string>();
                    dictArgs.Add("UID", rigaOrd.OrderRowUID);
                    // creo registrazione richiesta...
                    var ruid = await CRService.AddRequestAsync($"{currRec.Envir}", $"{(int)cMode}-{(int)cSubMode}", rigaOrd.OrderRowUID);
                    // aggiungo RUID effettivo
                    dictArgs.Add("RUID", ruid);
                    dictArgs.Add("OrderUID", rigaOrd.OrderNav.OrderCode);
                    dictArgs.Add("Mode", $"{(int)cMode}");
                    dictArgs.Add("TagList", serTagList);
                    // aggiungo file secondo ambiente...
                    string serKey = envRec != null ? envRec.SerStrucKey : "SerializedData";
                    switch (currRec.Envir)
                    {
                        case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WINDOW:
                            dictArgs.Add(serKey, rigaOrd.SerStruct);
                            needCalc = rigaOrd.SerStruct.Length > 2;
                            break;

                        case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.BEAM:
                        case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.WALL:
                        case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.CABINET:
                            // rileggo da file... 2check, spostare?!?
                            string folderPath = $"SO-{currRec.OfferID:X8}";
                            string rawData = FileUtils.LoadFileContent(Path.Combine(basePath, folderPath), rigaOrd.FileResource);
                            dictArgs.Add(serKey, rawData);
                            dictArgs.Add("FileName", rigaOrd.FileName);
                            needCalc = rawData.Length > 2;
                            break;

                        case EgwMultiEngineManager.Data.Constants.EXECENVIRONMENTS.NULL:
                        default:
                            break;
                    }
                    // solo SE va calcolato...
                    if (needCalc)
                    {
                        // tolta richiesta create
#if false
                        // mando richiesta "create" preliminare con tutti i dati
                        cSubMode = Egw.Window.Data.Enums.QuestionOrderSubModes.CREATE;
                        dictArgs.Add("SubMode", $"{(int)cSubMode}");
                        calcReq = new CalcRequestDTO()
                        {
                            DictExec = dictArgs,
                            EnvType = currRec.Envir
                        };
                        reqKey = $"{cMode}:{cSubMode}:{rigaOrd.OrderRowUID}";
                        await PService.EnqueueRequest("Estimation", reqKey, calcReq);
#endif

                        // ora richiedo la stima, rimuovendo serializzato (serKey), fileName e tagList...
                        dictArgs.Remove(serKey);
                        dictArgs.Remove("FileName");
                        dictArgs.Remove("TagList");
                        //... e infine cambio il submode...
                        dictArgs.Remove("SubMode");
                        cSubMode = Egw.Window.Data.Enums.QuestionOrderSubModes.ESTIMATE;
                        dictArgs.Add("SubMode", $"{(int)cSubMode}");
                        calcReq = new CalcRequestDTO()
                        {
                            DictExec = dictArgs,
                            EnvType = currRec.Envir
                        };
                        // chiave: composta da cMode, submode, UID riga...
                        reqKey = $"{cMode}:{cSubMode}:{rigaOrd.OrderRowUID}";
                        await PService.EnqueueRequest("Estimation", reqKey, calcReq);
                        // parto dalla history attuale
                        var currHist = currRec.LogHistory;
                        // aggiungo evento...
                        currHist.Add(new TaskHistDTO()
                        {
                            DtEvent = DateTime.Now,
                            UserName = "Default User",
                            Message = $"{reqKey}",
                            IconCss = "fa-solid fa-hourglass-start"
                        });
                        currRec.LogHistory = currHist;
                        OrderHist = currRec.LogHistory;
                        await DLService.OrderUpsert(currRec);
                    }
                }
            }

            await UpdateJobQueue();
        }

        #endregion Protected Methods

        #region Private Fields

        private static Logger Log = LogManager.GetCurrentClassLogger();

        private List<EnvirParamModel> AllConfEnvir = new();

        private List<OrderModel> AllRecords = new List<OrderModel>();

        /// <summary>
        /// Base path x network share files
        /// </summary>
        private string basePath = "unsafe_uploads";

        private int currPage = 1;

        private CompileStep currStep = CompileStep.Draft;

        private OrderModel? EditRecord = null;

        private OrderModel? EditStateRec = null;

        private bool isLoading = false;

        private List<string> JobQueueDone = new List<string>();
        private List<string> JobQueueRun = new List<string>();

        private List<string> JobQueueWait = new List<string>();

        private List<OrderModel> ListFilt = new List<OrderModel>();

        private List<OrderModel> ListRecords = new List<OrderModel>();

        private int numRecord = 10;

        private List<TaskHistDTO> OrderHist = new List<TaskHistDTO>();

        /// <summary>
        /// Periodo selezionato attuale
        /// </summary>
        private EgwCoreLib.Utils.DtUtils.Periodo PeriodoSel = new EgwCoreLib.Utils.DtUtils.Periodo(EgwCoreLib.Utils.DtUtils.PeriodSet.ThisYear);

        private string searchVal = "";

        private OrderModel? SelRecord = null;

        private int totalCount = 0;

        private string txtStyle = "font-size: 1.2em; font-weight:bold; fill: white;";

        #endregion Private Fields

        #region Private Properties

        private Enums.OrderStates? filtState { get; set; } = null;

        private List<string> listBord01 { get; set; } = new();

        #endregion Private Properties

        #region Private Methods

        private void AdvStep(CompileStep newStep)
        {
            currStep = newStep;
        }

        private string ArrowBackCol(CompileStep arrowStep)
        {
            string answ = $"fill: #000000;";
            if (arrowStep == currStep)
            {
                answ = $"fill: #123456;";
            }
            else if (arrowStep < currStep)
            {
                answ = $"fill: #456789;";
            }
            else
            {
                answ = $"fill: #89ABCD;";
            }
            return answ;
        }

        private void ConfInit()
        {
            basePath = Config.GetValue<string>("ServerConf:FileSharePath") ?? "unsafe_uploads";
        }

        private void DoClose()
        {
            EditRecord = null;
        }

        private void DoFilter()
        {
            // verifico eventuali filtri
            ListFilt = AllRecords
                        .Where(x => filtState == null || x.OrderState == filtState)
                        .ToList();

            if (!string.IsNullOrEmpty(searchVal))
            {
                ListFilt = ListFilt
                                .Where(x => x.Description.Contains(searchVal, StringComparison.InvariantCultureIgnoreCase) || x.OrderCode.Contains(searchVal, StringComparison.InvariantCultureIgnoreCase))
                                .ToList();
            }
            totalCount = ListFilt.Count();
        }

        /// <summary>
        /// Salva record ed avanza compilazione
        /// </summary>
        /// <param name="updRec"></param>
        /// <returns></returns>
        private async Task DoSave(OrderModel updRec)
        {
            // salvo record
            await DLService.OrderUpsert(updRec);
            // cambio step
            CompileStep nextStep = currStep < CompileStep.FinalCheck ? currStep + 1 : currStep;
            AdvStep(nextStep);
        }

        /// <summary>
        /// Rilegge tabella
        /// </summary>
        private async Task ForceReload()
        {
            isLoading = true;
            await Task.Delay(50);
            await ReloadData();
            await Task.Delay(50);
            UpdateTable();
            await Task.Delay(50);
            isLoading = false;
            await Task.Delay(50);
        }

#if false
        /// <summary>
        /// Restituisce il contenuto del file salvato
        /// </summary>
        /// <param name="folderPath"></param>
        /// <param name="secureName"></param>
        /// <returns></returns>
        private string LoadFileContent(string folderPath, string secureName)
        {
            string answ = "";
            if (!string.IsNullOrEmpty(folderPath))
            {
                try
                {
                    // calcolo path file...
                    string filePath = Path.Combine(basePath, folderPath, secureName);
                    if (File.Exists(filePath))
                    {
                        answ = File.ReadAllText(filePath);
                    }
                }
                catch (Exception exc)
                {
                    Log.Error($"Exception on LoadFileContent{Environment.NewLine}{exc}");
                }
            }
            return answ;
        }
#endif

        /// <summary>
        /// Modalità gestione code calcolo + display history
        /// </summary>
        /// <param name="curRec"></param>
        private async Task ManageCalcReq(OrderModel? curRec)
        {
            EditStateRec = curRec;
            OrderHist = curRec != null ? curRec.LogHistory : new List<TaskHistDTO>();
            await UpdateJobQueue();
        }

        /// <summary>
        /// Rilettura info di base
        /// </summary>
        /// <returns></returns>
        private async Task ReloadBaseData()
        {
            AllConfEnvir = await DLService.ConfEnvirParamGetAllAsync();
        }

        /// <summary>
        /// Legge i dati dei record completi
        /// </summary>
        private async Task ReloadData()
        {
            await DLService.OffersCheckExpired();
            AllRecords = await DLService.OrderGetFilt(PeriodoSel.Inizio, PeriodoSel.Fine);
            DoFilter();
        }

        private async Task ResetQueue(string args)
        {
            switch (args)
            {
                case "Run":
                    await ResetRunQueue();
                    break;

                case "Wait":
                    await ResetWaitQueue();
                    break;

                default:
                    break;
            }
        }

        /// <summary>
        /// Imposta periodo da filtro
        /// </summary>
        /// <param name="newPeriod"></param>
        /// <returns></returns>
        private async Task SetPeriodo(EgwCoreLib.Utils.DtUtils.Periodo newPeriod)
        {
            PeriodoSel = newPeriod;
            await ReloadData();
            UpdateTable();
        }

        private void SetupArrows()
        {
            listBord01 = new();
            listBord01.Add("");
            listBord01.Add("White");
            listBord01.Add("");
            listBord01.Add("");
        }

        private async Task UpdateJobQueue()
        {
            // aggiorno coda corrente x display...
            var currQueueWait = await PService.QueueListAllAsync(ProdService.QueueType.waiting);
            var currQueueRun = await PService.QueueListAllAsync(ProdService.QueueType.running);
            var currQueueDone = await PService.QueueListAllAsync(ProdService.QueueType.done);
            // converto x display...
            JobQueueWait = currQueueWait.Select(x => $"{x}").ToList();
            JobQueueRun = currQueueRun.Select(x => $"{x}").ToList();
            JobQueueDone = currQueueDone.Select(x => $"{x}").ToList();
            // inverto ordine delle liste!
            JobQueueWait.Reverse();
            JobQueueRun.Reverse();
            JobQueueDone.Reverse();

        }

        /// <summary>
        /// Filtro e paginazione
        /// </summary>
        private void UpdateTable()
        {
            // fix paginazione
            ListRecords = ListFilt
                            .Skip(numRecord * (currPage - 1))
                            .Take(numRecord)
                            .ToList();
        }

        #endregion Private Methods
    }
}