using MapoSDK;
using Newtonsoft.Json;
using SteamWare.IO;
using SteamWare.Reports;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Text.RegularExpressions;
using System.Web;

namespace MagData
{
    public class MagDataLayer
    {
        #region Public Fields

        /// <summary>
        /// oggetto static/singleton per fare chiamate sul datalayer
        /// </summary>
        public static MagDataLayer man = new MagDataLayer();

        /// <summary>
        /// RegExp x Qty odette
        /// </summary>
        public static string re_QtyOdette = memLayer.ML.cdv("regExp_QtyOdette");

        public static string redQueueConf = "MP-CTRACK:MAG:queueConf";

        /// <summary>
        /// chaive redis x cache conteggio coda PJQ
        /// </summary>
        public static string redQueueCount = "MP:MAG:PJQ";

        /// <summary>
        /// chaive redis x cache conteggio coda PJQ composta da tante code
        /// </summary>
        public static string redQueueCountSet = "MP:MAG:PJQCOUNT";

        public static string redReportConf = "MP-CTRACK:MAG:reportConf";
        public DS_MagTableAdapters.AnagArtTableAdapter taAA;
        public DS_MagTableAdapters.AnagArticoli2ClientiTableAdapter taAA2C;
        public DS_MagTableAdapters.AnagClientiTableAdapter taACF;
        public DS_MagTableAdapters.AnagDestinClientiTableAdapter taADC;
        public DS_ReportTableAdapters.stp_prt_CartellinoFinitiOdetteTableAdapter taCFOdette;
        public DS_ReportTableAdapters.stp_prt_CartellinoPedaneTableAdapter taCPed;
        public DS_ReportTableAdapters.stp_prt_CartellinoSemilavoratiTableAdapter taCSemil;
        public DS_MagTableAdapters.ElencoAL2UDCTableAdapter taEA2U;
        public DS_MagTableAdapters.ElencoALTableAdapter taEAL;
        public DS_MagTableAdapters.ElencoLottiTableAdapter taEL;
        public DS_PackListTableAdapters.ExtOrdersListTableAdapter taEOL;
        public DS_MagTableAdapters.Elencopost2QueueTableAdapter taEP2Q;
        public DS_MagTableAdapters.ElencoUdcTableAdapter taEUdc;
        public DS_MagTableAdapters.ODLTableAdapter taODL;
        public DS_PackListTableAdapters.OrdersListTableAdapter taOList;
        public DS_ReportTableAdapters.PrintJobQueueTableAdapter taPJQ;
        public DS_PackListTableAdapters.PackListTableAdapter taPList;
        public DS_MagTableAdapters.RegGiacenzeTableAdapter taRegGia;
        public DS_ReportTableAdapters.stp_prt_ReportPackListTableAdapter taRepPL;
        public DS_ReportTableAdapters.stp_prt_ReportPackListFullTableAdapter taRepPLFull;

        #endregion Public Fields

        #region Public Constructors

        public MagDataLayer()
        {
            // inizializzaizone classe
            initTA();
            setupConnString();
        }

        #endregion Public Constructors

        #region Public Properties

        /// <summary>
        /// Dati Prod e Print correnti x sessione utente salvati come cookie
        /// </summary>
        public prodPrintData currProdPrintData
        {
            set
            {
                string rawData = JsonConvert.SerializeObject(value);
                memLayer.ML.setSessionVal("currProdPrintData", rawData, true);
            }
            get
            {
                prodPrintData answ = new prodPrintData();
                string rawData = memLayer.ML.StringSessionObj("currProdPrintData");
                if (!string.IsNullOrEmpty(rawData))
                {
                    answ = JsonConvert.DeserializeObject<prodPrintData>(rawData);
                }
                return answ;
            }
        }

        /// <summary>
        /// Restituisce un array JSon x le conf delle code di stampa leggendo dal file
        /// </summary>
        /// <returns>lista oggetto Json in formato SteamwareSDK.queueConf</returns>
        public List<queueConf> queueConfJson
        {
            get
            {
                List<queueConf> answ = new List<queueConf>();
                string dirPath = HttpContext.Current.Server.MapPath("~/Reports/");
                string nomeFile = "queueConf.json";
                bool fileExist = fileMover.obj.fileExist(dirPath, nomeFile);
                if (fileExist)
                {
                    string rawData = File.ReadAllText($"{dirPath}\\{nomeFile}");
                    if (!string.IsNullOrEmpty(rawData))
                    {
                        try
                        {
                            answ = JsonConvert.DeserializeObject<List<queueConf>>(rawData);
                        }
                        catch (Exception exc)
                        {
                            SteamWare.Logger.Logging.Instance.Error(exc, "Eccezione in decodifica file conf queueConfJson");
                        }
                    }
                }
                return answ;
            }
        }

        /// <summary>
        /// Cache redis della conf delle code
        /// </summary>
        /// <returns>lista oggetto Json in formato SteamwareSDK.queueConf</returns>
        public List<queueConf> queueConfRedis
        {
            get
            {
                List<queueConf> answ = new List<queueConf>();
                string redKey = memLayer.ML.redHash(redQueueConf);
                string rawData = memLayer.ML.getRSV(redKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    try
                    {
                        answ = JsonConvert.DeserializeObject<List<queueConf>>(rawData);
                    }
                    catch (Exception exc)
                    {
                        SteamWare.Logger.Logging.Instance.Error(exc, "Eccezione in recupero dati queueConf da redis");
                    }
                }
                // controllo se vuoto rileggo da file
                if (answ.Count == 0)
                {
                    answ = queueConfJson;
                    // a quesot punto salvo in Redis
                    queueConfRedis = answ;
                }
                return answ;
            }
            set
            {
                string redKey = memLayer.ML.redHash(redQueueConf);
                string rawData = JsonConvert.SerializeObject(value);
                // salvo in cache per 1 h...
                memLayer.ML.setRSV(redKey, rawData, 3600);
            }
        }

        /// <summary>
        /// Restituisce un array JSon x le conf dei report/template di stampa leggendo dal file
        /// </summary>
        /// <returns>lista oggetto Json in formato SteamwareSDK.templateConf</returns>
        public List<reportConf> reportConfJson
        {
            get
            {
                List<reportConf> answ = new List<reportConf>();
                string dirPath = HttpContext.Current.Server.MapPath("~/Reports/");
                string nomeFile = "reportConf.json";
                bool fileExist = fileMover.obj.fileExist(dirPath, nomeFile);
                if (fileExist)
                {
                    string rawData = File.ReadAllText($"{dirPath}\\{nomeFile}");
                    if (!string.IsNullOrEmpty(rawData))
                    {
                        try
                        {
                            answ = JsonConvert.DeserializeObject<List<reportConf>>(rawData);
                        }
                        catch (Exception exc)
                        {
                            SteamWare.Logger.Logging.Instance.Error(exc, "Eccezione in decodifica file conf reportConfJson");
                        }
                    }
                }
                return answ;
            }
        }

        /// <summary>
        /// Cache redis della conf dei tipo report
        /// </summary>
        /// <returns>lista oggetto Json in formato SteamwareSDK.queueConf</returns>
        public List<reportConf> reportConfRedis
        {
            get
            {
                List<reportConf> answ = new List<reportConf>();
                string redKey = memLayer.ML.redHash(redReportConf);
                string rawData = memLayer.ML.getRSV(redKey);
                if (!string.IsNullOrEmpty(rawData))
                {
                    try
                    {
                        answ = JsonConvert.DeserializeObject<List<reportConf>>(rawData);
                    }
                    catch (Exception exc)
                    {
                        SteamWare.Logger.Logging.Instance.Error(exc, "Eccezione in recupero dati reportConf da redis");
                    }
                }
                // controllo se vuoto rileggo da file
                if (answ.Count == 0)
                {
                    answ = reportConfJson;
                    // a quesot punto salvo in Redis
                    reportConfRedis = answ;
                }
                return answ;
            }
            set
            {
                string redKey = memLayer.ML.redHash(redReportConf);
                string rawData = JsonConvert.SerializeObject(value);
                // salvo in cache per 1 h...
                memLayer.ML.setRSV(redKey, rawData, 3600);
            }
        }

        #endregion Public Properties

        #region Public Methods

        /// <summary>
        /// Decodifica barcode
        /// </summary>
        /// <param name="bcValue"></param>
        /// <returns></returns>
        public decodedData decodeBcode(string bcValue)
        {
            decodedData answ = new decodedData();
            int codeInt = 0;
            answ.rawData = bcValue;
            if (bcValue.StartsWith("CMD"))
            {
                answ.codeType = codeType.Command;
                answ.code = bcValue.Replace("CMD", "");
                answ.codeInt = codeInt;
                answ.description = $"Comando: {answ.code}";
            }
            else if (bcValue.StartsWith("M"))
            {
                answ.codeType = codeType.LottoInt;
                answ.code = bcValue.Replace("M", "");
                answ.codeInt = codeInt;
                answ.description = $"Lotto: {answ.code}";
            }
            else if (bcValue.StartsWith("PED"))
            {
                answ.codeType = codeType.Pedana;
                answ.code = bcValue.Replace("PED", "");
                int.TryParse(answ.code, NumberStyles.Integer, CultureInfo.InvariantCulture, out codeInt);
                answ.codeInt = codeInt;
                answ.description = $"Pedana: {bcValue}";
            }
            else if (bcValue.StartsWith("PL"))
            {
                answ.codeType = codeType.PackList;
                answ.code = bcValue.Replace("PL", "");
                int.TryParse(answ.code, NumberStyles.Integer, CultureInfo.InvariantCulture, out codeInt);
                answ.codeInt = codeInt;
                answ.description = $"PackList: {answ.code}";
            }
            else if (bcValue.StartsWith("P"))
            {
                // controllo se data (6 numeri...) oppure part...
                if (bcValue.Length == 7)
                {
                    answ.codeType = codeType.Date;
                    answ.code = bcValue.Replace("P", "");
                    int.TryParse(answ.code, NumberStyles.Integer, CultureInfo.InvariantCulture, out codeInt);
                    answ.codeInt = 0;
                    answ.description = $"Data YYMMDD: {answ.code}";
                }
                else
                {
                    answ.codeType = codeType.PartNumber;
                    answ.code = bcValue.Replace("P", "");
                    int.TryParse(answ.code, NumberStyles.Integer, CultureInfo.InvariantCulture, out codeInt);
                    answ.codeInt = 0;
                    answ.description = $"PartNumber Odette: {answ.code}";
                }
            }
            else if (bcValue.StartsWith("Q"))
            {
                // controllo regex
                Match testQty = Regex.Match(bcValue, re_QtyOdette);
                if (testQty.Success)
                {
                    answ.codeType = codeType.Quantity;
                    answ.code = bcValue.Replace("Q", "");
                    int.TryParse(answ.code, NumberStyles.Integer, CultureInfo.InvariantCulture, out codeInt);
                    answ.codeInt = codeInt;
                    answ.description = $"Qty Odette: {answ.code}";
                }
                else
                {
                    answ.codeType = codeType.UNK;
                }
            }
            else if (bcValue.StartsWith("H"))
            {
                answ.codeType = codeType.Lotto;
                answ.code = bcValue.Replace("H", "");
                answ.codeInt = 0;
                answ.description = $"Lotto Odette: {answ.code}";
            }
            else if (bcValue.StartsWith("S"))
            {
                answ.codeType = codeType.Udc;
                answ.code = bcValue.Replace("S", "");
                answ.codeInt = codeInt;
                answ.description = $"UDC Odette: {answ.code}";
            }
            else if (bcValue.Length >= 6 && bcValue.Length <= 7)
            {
                // cerco x lotto SOLO Ext (M=INT, E=Ext)
                DS_Mag.ElencoLottiDataTable tabLotti;
                tabLotti = taEL.getByKey(bcValue, "*", "*");
                if (tabLotti.Count > 0)
                {
                    var riga = tabLotti[0];
                    answ.codeType = codeType.Lotto;
                    answ.code = bcValue;
                    answ.codeInt = codeInt;
                    answ.description = $"Lotto: {answ.code}";
                }
                else
                {
                    answ.codeType = codeType.UNK;
                }
            }
            else if (bcValue.Length >= 12)
            {
                // cerco x UDC
                var tabEUdc = taEUdc.getByKey(bcValue);
                if (tabEUdc.Count > 0)
                {
                    answ.codeType = codeType.Udc;
                    answ.code = bcValue;
                    answ.codeInt = codeInt;
                    answ.description = $"UDC: {answ.code}";
                }
                else
                {
                    answ.codeType = codeType.UNK;
                }
            }
            return answ;
        }

        /// <summary>
        /// Esegue svuotamento giacenze dato elenco ODL...
        /// </summary>
        /// <param name="listODL"></param>
        /// <returns></returns>
        public bool resetRegGiacByOdl(List<int> listODL)
        {
            bool fatto = false;
            if (listODL.Count > 0)
            {
                foreach (var item in listODL)
                {
                    taRegGia.DeleteByOdl(item);
                    fatto = true;
                }
            }
            else
            {
                fatto = true;
            }
            return fatto;
        }

        /// <summary>
        /// Esegue salvataggio records giacenze...
        /// </summary>
        /// <param name="listGiacenze"></param>
        /// <returns></returns>
        public bool salvaRegGiac(List<RegGiacenze> listGiacenze)
        {
            bool fatto = false;
            if (listGiacenze.Count > 0)
            {
                foreach (var item in listGiacenze)
                {
                    taRegGia.InsertQuery(item.IdxODL, item.IdentRG, item.Product, item.Variety, item.Supplier, item.ExtDoc, item.DateRif, item.QtyTot, item.NumPack, item.Notes);
                    fatto = true;
                }
            }
            else
            {
                fatto = true;
            }
            return fatto;
        }

        /// <summary>
        /// effettua la stampa di un documento
        /// </summary>
        /// <param name="keyParam">Codice UNIVOCO del documento</param>
        /// <param name="printQueue">
        /// stampante specifica (da postazione o std da web.config, a cura dell'utente
        /// </param>
        /// <param name="tipoDoc">Tipo documento richiesto</param>
        /// <param name="clientIp">IP del chiamante</param>
        /// <returns></returns>
        public bool stampaDoc(string keyParam, string printQueue, tipoDocumento tipoDoc, string clientIp)
        {
            bool answ = false;
            // controllo se esista UDC
            if (checkDoc(printQueue, tipoDoc, keyParam))
            {
                answ = reportPrinter.obj.stampaReport(tipoDoc, keyParam, printQueue);
                // svuoto code redis salvate..
                memLayer.ML.redFlushKey(redQueueCount);
                memLayer.ML.redFlushKey(redQueueCountSet);
                if (answ)
                {
                    SteamWare.Logger.Logging.Instance.Info($" | {clientIp} | salvata richiesta stampa  su coda {printQueue} | key {keyParam}");
                }
                else
                {
                    SteamWare.Logger.Logging.Instance.Error($"ERRORE | {clientIp} | richiesta stampa  su coda {printQueue} | key {keyParam}");
                }
            }
            else
            {
                SteamWare.Logger.Logging.Instance.Error($"Impossibile | {clientIp} | richiesta stampa  su coda {printQueue} | key {keyParam}");
            }
            return answ;
        }

        #endregion Public Methods

        #region Private Methods

        /// <summary>
        /// Verifica esistenza record da NOME CODA stampa + tipoDoc + chiave...
        /// </summary>
        /// <param name="printQueue"></param>
        /// <param name="tipoDoc"></param>
        /// <param name="keyParam"></param>
        /// <returns></returns>
        private bool checkDoc(string printQueue, tipoDocumento tipoDoc, string keyParam)
        {
            bool answ = false;
            reportRichiesto tipoReport = reportRichiesto.ND;

            // se ho un TIPO DOC --> cerco
            if (tipoDoc != tipoDocumento.docND)
            {
                //cerco in setup queueConf
                var repConf = reportConfRedis.Find(a => a.name == $"{tipoDoc}");
                if (repConf != null)
                {
                    try
                    {
                        tipoReport = (reportRichiesto)Enum.Parse(typeof(reportRichiesto), repConf.template.Replace(".rdlc", ""));
                    }
                    catch
                    { }
                }
            }
            // se non trovato esplicitamente
            if (tipoReport == reportRichiesto.ND)
            {
                //cerco in setup queueConf
                var coda = queueConfRedis.Find(a => a.name == printQueue);
                if (coda != null)
                {
                    try
                    {
                        tipoReport = (reportRichiesto)Enum.Parse(typeof(reportRichiesto), coda.template.Replace(".rdlc", ""));
                    }
                    catch
                    { }
                }
            }
            // ricerco!
            switch (tipoReport)
            {
                case reportRichiesto.CartellinoFinitiOdette:
                    var tabFiniti = taCFOdette.GetData(keyParam);
                    answ = tabFiniti.Count > 0;
                    break;

                case reportRichiesto.CartellinoPedane:
                    var tabPedane = taCPed.GetData(keyParam);
                    answ = tabPedane.Count > 0;
                    break;

                case reportRichiesto.CartellinoSemilavorati:
                    var tabSemilav = taCSemil.GetData(keyParam);
                    answ = tabSemilav.Count > 0;
                    break;

                case reportRichiesto.ReportPackList:
                    var tabPackList = taRepPL.GetData(keyParam, false);
                    answ = tabPackList.Count > 0;
                    break;

                case reportRichiesto.ReportPackListFull:
                    var tabPackListFull = taRepPLFull.GetData(keyParam, false);
                    answ = tabPackListFull.Count > 0;
                    break;

                default:
                    break;
            }
            return answ;
        }

        private void initTA()
        {
            // reports
            taPJQ = new DS_ReportTableAdapters.PrintJobQueueTableAdapter();
            taCFOdette = new DS_ReportTableAdapters.stp_prt_CartellinoFinitiOdetteTableAdapter();
            taCPed = new DS_ReportTableAdapters.stp_prt_CartellinoPedaneTableAdapter();
            taCSemil = new DS_ReportTableAdapters.stp_prt_CartellinoSemilavoratiTableAdapter();
            taRepPL = new DS_ReportTableAdapters.stp_prt_ReportPackListTableAdapter();
            taRepPLFull = new DS_ReportTableAdapters.stp_prt_ReportPackListFullTableAdapter();

            taAA = new DS_MagTableAdapters.AnagArtTableAdapter();
            taAA2C = new DS_MagTableAdapters.AnagArticoli2ClientiTableAdapter();
            taACF = new DS_MagTableAdapters.AnagClientiTableAdapter();
            taADC = new DS_MagTableAdapters.AnagDestinClientiTableAdapter();
            taEA2U = new DS_MagTableAdapters.ElencoAL2UDCTableAdapter();
            taEAL = new DS_MagTableAdapters.ElencoALTableAdapter();
            taEL = new DS_MagTableAdapters.ElencoLottiTableAdapter();
            taEP2Q = new DS_MagTableAdapters.Elencopost2QueueTableAdapter();
            taEUdc = new DS_MagTableAdapters.ElencoUdcTableAdapter();
            taODL = new DS_MagTableAdapters.ODLTableAdapter();
            taRegGia = new DS_MagTableAdapters.RegGiacenzeTableAdapter();

            taEOL = new DS_PackListTableAdapters.ExtOrdersListTableAdapter();
            taOList = new DS_PackListTableAdapters.OrdersListTableAdapter();
            taPList = new DS_PackListTableAdapters.PackListTableAdapter();
        }

        private void setupConnString()
        {
            string connString = memLayer.ML.CRS("MagDataConnectionString");
            // reports
            taPJQ.Connection.ConnectionString = connString;
            taCFOdette.Connection.ConnectionString = connString;
            taCPed.Connection.ConnectionString = connString;
            taCSemil.Connection.ConnectionString = connString;
            taRepPL.Connection.ConnectionString = connString;
            taRepPLFull.Connection.ConnectionString = connString;

            taAA.Connection.ConnectionString = connString;
            taAA2C.Connection.ConnectionString = connString;
            taACF.Connection.ConnectionString = connString;
            taADC.Connection.ConnectionString = connString;
            taEA2U.Connection.ConnectionString = connString;
            taEAL.Connection.ConnectionString = connString;
            taEL.Connection.ConnectionString = connString;
            taEP2Q.Connection.ConnectionString = connString;
            taEUdc.Connection.ConnectionString = connString;
            taODL.Connection.ConnectionString = connString;
            taRegGia.Connection.ConnectionString = connString;

            taEOL.Connection.ConnectionString = connString;
            taOList.Connection.ConnectionString = connString;
            taPList.Connection.ConnectionString = connString;
        }

        #endregion Private Methods
    }
}