using EgwCoreLib.Lux.Core.RestPayload;
using static Egw.Window.Data.Enums;
using static EgwCoreLib.Lux.Core.Enums;

namespace Lux.API.Services
{
    public class ExternalMessageProcessor
    {
        #region Public Constructors

        /// <summary>
        /// Init classe message processor con accesso REDIS e DB
        /// </summary>
        /// <param name="imgService"></param>
        /// <param name="dlService"></param>
        /// <param name="crService"></param>
        /// <param name="prodService"></param>
        public ExternalMessageProcessor(IImageCacheService imgService, IDataLayerServices dlService, ICalcRuidService crService, IProdService prodService)
        {
            cacheService = imgService;
            dbService = dlService;
            _calcRuidService = crService;
            _prodService = prodService;
        }

        #endregion Public Constructors

        #region Public Methods

        public async Task HandleResultMessageAsync(string channel, string message)
        {
            Log.Info($"Processing message from {channel} | {message.Length}");

            Stopwatch sw = new Stopwatch();
            sw.Start();
            string rawData = $"{message}";
            if (!string.IsNullOrEmpty(rawData) && rawData.Length > 2)
            {
                try
                {
                    AnswerDTO? retData = JsonConvert.DeserializeObject<AnswerDTO>(rawData);
                    bool saved = await ProcessAnswer(retData);
#if DEBUG
                    // se in debug forzo save dell'ultima chiamata comunque...
                    saved = false;
#endif
                    // se non avessi salvato e non sapessi cosa fosse --> salvo comunque x debug...
                    if (!saved && retData != null)
                    {
                        string UID = retData.Args["UID"];
                        var envir = retData.ExecEnvironment;
                        // salvo in area generica...
                        await SaveRawData(UID, retData.ExecEnvironment, rawData);
                    }
                }
                catch (Exception exc)
                {
                    Log.Error($"Errore in fase decodifica messaggio da REDIS Channel{Environment.NewLine}{exc}");
                }
            }

            sw.Stop();
            Log.Info($"HandleResultMessageAsync | {sw.Elapsed.TotalMilliseconds:N3} ms");
#if false
            // Process message (parse, validate, act)
            var payload = message; // or JSON-deserialize, etc.
            await _redisService.SetAsync("last:result", payload);
#endif
        }

        /// <summary>
        /// Rilettura della risposta in formato RawData x Debug
        /// </summary>
        /// <param name="rawData"></param>
        /// <returns></returns>
        public async Task<string> LoadRawData(string UID, Constants.EXECENVIRONMENTS envir)
        {
            // rileggo
            string rawData = await cacheService.LoadDebug(UID, envir);
            return rawData;
        }

        /// <summary>
        /// Processing di una risposta AnswerDTO
        /// </summary>
        /// <param name="retData"></param>
        /// <returns></returns>
        public async Task<bool> ProcessAnswer(AnswerDTO? retData)
        {
            bool saved = false;
            if (retData != null)
            {
                if (retData.Args != null && retData.Args.Count > 0)
                {
                    /*------------------------------------------
                     * Richieste "continue" di stato/update
                     * ----------------------------------------*/
                    string UID = retData.Args["UID"];
                    string RUID = "";
                    Egw.Window.Data.Enums.QuestionModes cMode = QuestionModes.NULL;
                    if (retData.Args.ContainsKey("Mode"))
                    {
                        string sMode = retData.Args["Mode"];
                        if (int.TryParse(sMode, out int iMode))
                        {
                            bool modeValido = Enum.IsDefined(typeof(QuestionModes), iMode);
                            if (modeValido)
                            {
                                cMode = (QuestionModes)iMode;
                            }
                        }
                    }

                    // gestione RUID
                    if (retData.Args.ContainsKey("RUID"))
                    {
                        RUID = retData.Args["RUID"];
                        // salvo SUBITO chiusura statistiche...
                        string hKey = await _calcRuidService.CompleteRequestAsync(RUID);

                        // verifico eventuali spostamenti code calcolo
                        await _prodService.UpdateQueueAsync(retData.ExecEnvironment, hKey);
                    }

                    // gestione ritorno preview SVG
                    if (retData.Args.ContainsKey("Svg"))
                    {
                        // recupero UID ed SVG
                        string newSvg = retData.Args["Svg"];
                        // reinvio in redis (cache + channel)
                        await cacheService.SaveSvgAsync(UID, retData.ExecEnvironment, newSvg);
                        saved = true;
                    }

                    // gestione ritorno preview PNG
                    if (retData.Args.ContainsKey("Png"))
                    {
                        // recupero UID ed SVG
                        string newPng = retData.Args["Png"];
                        // reinvio in redis (cache + channel)
                        await cacheService.SavePngAsync(UID, retData.ExecEnvironment, newPng);
                        saved = true;
                    }

                    // gesitone ritorno BOM
                    if (retData.Args.ContainsKey("BOM"))
                    {
                        // recupero UID e BOM
                        string newBom = retData.Args["BOM"];
                        // salvo BOM ricevuta RAW in redis (cache)
                        await cacheService.SaveBomAsync(UID, retData.ExecEnvironment, newBom);
                        // salvo la BOM completa con i dati recuperati dal DB
                        await dbService.SaveBomAsync(UID, cMode, retData.ExecEnvironment, newBom);
                        // reset cache redis...
                        await cacheService.ExecFlushRedisPatternAsync((RedisValue)$"{redisBaseKey}:Offers:*");
                        await cacheService.ExecFlushRedisPatternAsync((RedisValue)$"{redisBaseKey}:OfferRows:*");
                        // pubblico refresh info così da segnalare richiesta di update conseguente
                        await cacheService.PublishUpdateAsync(UID, retData.ExecEnvironment);
                        saved = true;
                    }

                    // gestione ritorno tipo Shape
                    if (retData.Args.ContainsKey("SashShape"))
                    {
                        // recupero UID ed SVG
                        string newShape = retData.Args["SashShape"];
                        // reinvio in redis (cache + channel)
                        await cacheService.SaveShapeAsync(UID, retData.ExecEnvironment, newShape);
                        saved = true;
                    }

                    // gestione ritorno tipo Stima Tempi e lavorabilità (x carico macchine/schedulazione)
                    if (retData.Args.ContainsKey("Estimate"))
                    {
                        // recupero lista risultati calcolo...
                        string rawAnsw = retData.Args["Estimate"];
                        List<MachineCalcResultDTO>? machineEstimList = new List<MachineCalcResultDTO>();
                        // deserializzo
                        try
                        {
                            await dbService.SaveProdEstimateAsync(UID, retData.ExecEnvironment, rawAnsw);
                        }
                        catch (Exception exc)
                        {
                            Log.Error($"Eccezione in gestione Estimate{Environment.NewLine}{exc}");
                        }
                        // reinvio in redis (cache + channel)
                        await cacheService.SaveProdEstimateAsync(UID, retData.ExecEnvironment, rawAnsw);
                        saved = true;
                    }

                    // gestione ritorno tipo Balance dei gruppi di lavorazione (x carico macchine/schedulazione)
                    if (retData.Args.ContainsKey("Balance"))
                    {
                        // ATTENZIONE! qui oltre al valore UID deve leggere ANCHE il gruppo cui è riferito (es: Group: 1)
                        // recupero lista risultati calcolo...
                        string refGroup = retData.Args["Group"];
                        string rawBalance = retData.Args["Balance"];
                        List<MachineCalcResultDTO>? machineEstimList = new List<MachineCalcResultDTO>();
                        // deserializzo
                        try
                        {
                            await dbService.SaveProdBalanceAsync(UID, refGroup, retData.ExecEnvironment, rawBalance);
                        }
                        catch (Exception exc)
                        {
                            Log.Error($"Eccezione in gestione Balance{Environment.NewLine}{exc}");
                        }
                        // sistemo code, definendo nuova key...
                        string qKey = $"{QuestionModes.ORDER}:{QuestionOrderSubModes.BALANCE}:{UID}.{refGroup}";
                        await _prodService.SetDoneAsync(retData.ExecEnvironment, qKey, ProdQueueType.running);
                        // reinvio in redis (cache + channel)
                        await cacheService.SaveProdBalanceAsync(UID, retData.ExecEnvironment, rawBalance);
                        saved = true;
                    }

                    // gestione ritorno opzioni HW
                    if (retData.Args.ContainsKey("HardwareOptions"))
                    {
                        // recupero UID ed SVG
                        string newHwOpt = retData.Args["HardwareOptions"];
                        // reinvio in redis (cache + channel)
                        await cacheService.SaveHwOptAsync(UID, retData.ExecEnvironment, newHwOpt);
                        saved = true;
                    }

                    /*------------------------------------------
                     * Richieste "one shot" di configurazione
                     * - fare 1/gg o su richiesta utente
                     * ----------------------------------------*/

                    // Gestione ritorno lista preferiti HW (ammissibili)
                    if (retData.Args.ContainsKey("HardwareModelList"))
                    {
                        // recupero UID e lista preferiti HW
                        string newHml = retData.Args["HardwareModelList"];
                        // salvo HardwareList ricevuta
                        await cacheService.SaveHmlAsync(UID, retData.ExecEnvironment, newHml);
                        await dbService.SaveHmlAsync(UID, retData.ExecEnvironment, newHml);
                        saved = true;
                    }

                    // gestione ritorno lista profili VALIDI per JWD
                    if (retData.Args.ContainsKey("ProfileListAsync"))
                    {
                        // recupero UID e elenco profili validi
                        string profList = retData.Args["ProfileListAsync"];
                        // salvo ProfileListAsync ricevuta
                        await cacheService.SaveProfileListAsync(UID, retData.ExecEnvironment, profList);
                        await dbService.SaveProfileListAsync(UID, retData.ExecEnvironment, profList);
                        saved = true;
                    }

                    // gestione ritorno lista AreaProfiles per live JWD
                    if (retData.Args.ContainsKey("AreaProfiles"))
                    {
                        // recupero UID e elenco profili validi
                        string areaProfList = retData.Args["AreaProfiles"];
                        // salvo ProfileListAsync ricevuta
                        await cacheService.SaveProfileElemAsync(UID, retData.ExecEnvironment, areaProfList);
                        saved = true;
                    }

                    // gestione ritorno dati Threshold x profilo VALIDI per JWD
                    if (retData.Args.ContainsKey("ThresholdList"))
                    {
                        // recupero UID e elenco profili validi
                        string threshList = retData.Args["ThresholdList"];
                        // recuperro anche i profile data
                        string profData = retData.Args["ProfileData"];

                        // salvo ProfileListAsync ricevuta
                        await cacheService.SaveProfileThreshAsync(UID, retData.ExecEnvironment, threshList, profData);
                        await dbService.SaveProfileThreshAsync(UID, retData.ExecEnvironment, threshList, profData);
                        saved = true;
                    }
                }
            }
            return saved;
        }

        /// <summary>
        /// Salvataggio della risposta in formato RawData x Debug
        /// </summary>
        /// <param name="rawData"></param>
        /// <returns></returns>
        public async Task SaveRawData(string UID, Constants.EXECENVIRONMENTS envir, string rawData)
        {
            // salvo in area generica...
            await cacheService.SaveDebug(UID, envir, rawData);
        }

        #endregion Public Methods

        #region Private Fields

        private static Logger Log = LogManager.GetCurrentClassLogger();
        private readonly ICalcRuidService _calcRuidService;
        private readonly IProdService _prodService;
        private readonly IImageCacheService cacheService;
        private readonly IDataLayerServices dbService;
        private string redisBaseKey = "Lux:Cache";

        #endregion Private Fields
    }
}