using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Data;
using System.IO;
using System.Linq;
using System.Runtime.Caching;
using Kreta.BusinessLogic.Classes;
using Kreta.BusinessLogic.HelperClasses;
using Kreta.BusinessLogic.HelperClasses.ImportCo;
using Kreta.BusinessLogic.Logic;
using Kreta.Core;
using Kreta.Core.ConnectionType;
using Kreta.DataAccessManual;
using Kreta.DataAccessManual.Util;
using Kreta.Enums;
using Kreta.Enums.ManualEnums.ImportExport;
using Kreta.Resources;
using Newtonsoft.Json;

namespace Kreta.BusinessLogic.Helpers.ImportExport
{
    public class OratervImportExportHelper : LogicBase
    {
        #region Fields

        private readonly string _importObjectCacheKey;

        #endregion Fields

        #region Properties

        public static Dictionary<int, string> ImportHeaderList => new Dictionary<int, string>
        {
            { 00, ImportExportOratervResource.ImportHeaderNameTantervNeve },
            { 01, ImportExportOratervResource.ImportHeaderNameOratervNeve },
            { 02, ImportExportOratervResource.ImportHeaderNameEvfolyamNeve },
            { 03, ImportExportOratervResource.ImportHeaderNameTantargyNeve },
            { 04, ImportExportOratervResource.ImportHeaderNameEvesOraszam }
        };

        public OratervImportCo ImportCo
        {
            get => (OratervImportCo)Cache.Get(_importObjectCacheKey);
            set
            {
                if (ImportCo != null)
                {
                    Cache.Remove(_importObjectCacheKey);
                }

                Cache.Add(_importObjectCacheKey, value, new CacheItemPolicy { SlidingExpiration = TimeSpan.FromMinutes(30) });
            }
        }

        #endregion Properties

        #region Constructors

        public OratervImportExportHelper(IConnectionType connectionType) : base(connectionType)
        {
            _importObjectCacheKey = $"{nameof(OratervImportCo)}_{IntezmenyId}_{FelhasznaloId}_ImportObjectCacheKey";
        }

        #endregion Constructors

        public void SetImportCo(List<List<string>> importData, int importMuvelet)
        {
            OratervImportCo importCo = GetImportCoFromImportData(importData);
            importCo.ImportMuvelet = importMuvelet;

            SetNemImportalhatoSorokByValidation(importCo);

            //NOTE: Azért van szükség Dictionary-kre, mert így sokkal gyorsabb a keresés!
            Dictionary<string, ImportItemCompareCo> tantargyCompareHashImportItemCompareCoDictionary = GetTantargyCompareHashImportItemCompareCoDictionary(importCo.TantargyCOList);
            Dictionary<string, ImportItemCompareCo> oratervCompareHashImportItemCompareCoDictionary = GetOratervCompareHashImportItemCompareCoDictionary(importCo.OratervCOList);
            Dictionary<string, ImportItemCompareCo> oratervTantargyCompareHashImportItemCompareCoDictionary = GetOratervTantargyCompareHashImportItemCompareCoDictionary(importCo.OratervTantargyCOList);

            foreach (OratervImportItemCo importItem in importCo.MainImportItemList)
            {
                SetOperationTantargy(importItem, tantargyCompareHashImportItemCompareCoDictionary);
                SetOperationOraterv(importItem, oratervCompareHashImportItemCompareCoDictionary, importCo.ImportMuvelet);
                SetOperationOratervTantargy(importItem, oratervTantargyCompareHashImportItemCompareCoDictionary, importCo.ImportMuvelet);
            }

            //NOTE: Azokat a sorokat, amelyek bekerültek a NemImportalhatoItemList-be, azokat kiveszzük a MainImportItemList-ből!
            importCo.MainImportItemList.RemoveRange(importCo.NemImportalhatoItemList);

            var tantargyImportJsonItemList = new List<TantargyImportJsonItemCo>();
            var oratervImportJsonItemList = new List<OratervImportJsonItemCo>();
            var oratervTantargyJsonItemList = new List<OratervTargyImportJsonItemCo>();

            var tantargyImportJsonItemCoList = importCo.MainImportItemList.GroupBy(x => x.TantargyNeve).Select(x => x.First()).Select(x => new TantargyImportJsonItemCo(x, TanevId, IntezmenyId, FelhasznaloId)).ToList();
            var oratervImportJsonItemCoList = importCo.MainImportItemList.GroupBy(x => x.OratervNeve).Select(x => x.First()).Select(x => new OratervImportJsonItemCo(x, TanevId, IntezmenyId, FelhasznaloId)).ToList();
            var oratervTantargyImportJsonItemCoList = importCo.MainImportItemList.Select(x => new OratervTargyImportJsonItemCo(x, TanevId, IntezmenyId, FelhasznaloId)).ToList();
            tantargyImportJsonItemList.AddRange(tantargyImportJsonItemCoList);
            oratervImportJsonItemList.AddRange(oratervImportJsonItemCoList);
            oratervTantargyJsonItemList.AddRange(oratervTantargyImportJsonItemCoList);

            importCo.TantargyImportJsonItemList = tantargyImportJsonItemList;
            importCo.OratervImportJsonItemList = oratervImportJsonItemList;
            importCo.OratervTantargyImportJsonItemList = oratervTantargyJsonItemList;

            ImportCo = importCo;
        }

        private static void SetNemImportalhatoSorokByValidation(OratervImportCo importCo)
        {
            Dictionary<int, List<ValidationResult>> validationResultDictionary = importCo.Validate();

            //NOTE: Azokat a sorokat, amelyek hibásak beletesszük a NemImportalhatoItemList-be!
            foreach (OratervImportItemCo importItem in importCo.MainImportItemList.Where(x => validationResultDictionary.Keys.Contains(x.LineNumber)))
            {
                IEnumerable<ValidationResult> validationResultList = validationResultDictionary[importItem.LineNumber];
                importItem.ErrorList = validationResultList.Select(x => x.ErrorMessage).ToList();
                importCo.NemImportalhatoItemList.Add(importItem);
            }

            //NOTE: Azokat a sorokat, amelyek bekerültek a NemImportalhatoItemList-be, azokat kiveszzük a MainImportItemList-ből!
            importCo.MainImportItemList.RemoveRange(importCo.NemImportalhatoItemList);
        }

        private OratervImportCo GetImportCoFromImportData(List<List<string>> importData)
        {
            List<TantervCO> tantervCoList = null;
            List<TantargyItemCo> tantargyCoList = null;
            List<OratervCO> oratervCoList = null;
            List<OratervTantargyCO> oratervTantargyCoList = null;

            Dal.CustomConnection.Run(ConnectionType, h =>
            {
                tantervCoList = new TantervHelper(new DalHandlerConnectionType(ConnectionType, h)).GetAktivTantervDataSet().Tables[0].AsEnumerable().Select(row => new TantervCO()
                {
                    ID = SDAConvert.ToInt32(row["ID"]),
                    Nev = SDAConvert.ToString(row["Nev"]),
                }).ToList();
                tantargyCoList = new TantargyHelper(new DalHandlerConnectionType(ConnectionType, h)).GetTantargyCoList();
                var oratervHelper = new OratervHelper(new DalHandlerConnectionType(ConnectionType, h));
                oratervCoList = oratervHelper.GetOratervCoList();
                oratervTantargyCoList = oratervHelper.GetOratervTantargyCoList();
            });

            var importCo = new OratervImportCo
            {
                TantervCOList = tantervCoList,
                TantargyCOList = tantargyCoList,
                OratervCOList = oratervCoList,
                OratervTantargyCOList = oratervTantargyCoList,
            };

            int lineNumber = 1;
            foreach (List<string> importDataRow in importData.Skip(1))
            {
                var importItemCo = new OratervImportItemCo(TanevId)
                {
                    LineNumber = lineNumber,

                    TantervNeveImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportOratervResource.ImportHeaderNameTantervNeve)],
                    OratervNeveImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportOratervResource.ImportHeaderNameOratervNeve)],
                    EvfolyamNeveImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportOratervResource.ImportHeaderNameEvfolyamNeve)],
                    TantargyNeveImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportOratervResource.ImportHeaderNameTantargyNeve)],
                    EvesOraszamImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportOratervResource.ImportHeaderNameEvesOraszam)],
                };

                importItemCo.TantervId = importCo.TantervCOList.SingleOrDefault(x =>
                    x.Nev?.ToComparableString() == importItemCo.TantervNeve?.ToComparableString())?.ID;

                importItemCo.TantargyId = importCo.TantargyCOList.SingleOrDefault(x => x.Nev?.ToComparableString() == importItemCo.TantargyNeve?.ToComparableString())?.Id;

                importItemCo.OratervId = importCo.OratervCOList.SingleOrDefault(x => x.Nev?.ToComparableString() == importItemCo.OratervNeve?.ToComparableString())?.OratervId;

                string lineMd5HashInput =
                    importItemCo.OratervId +
                    importItemCo.OratervNeve?.ToComparableString() +
                    importItemCo.TantargyId +
                    importItemCo.TantargyNeve?.ToComparableString();
                importItemCo.CompareHash = ImportExportHelper.GetMd5Hash(lineMd5HashInput);

                string tantargyMd5HashInput =
                    importItemCo.TantargyId +
                    importItemCo.TantargyNeve?.ToComparableString();
                importItemCo.CompareHashTantargy = ImportExportHelper.GetMd5Hash(tantargyMd5HashInput);

                string oratervMd5HashInput =
                    importItemCo.OratervId +
                    importItemCo.OratervNeve?.ToComparableString();
                importItemCo.CompareHashOraterv = ImportExportHelper.GetMd5Hash(oratervMd5HashInput);

                importCo.MainImportItemList.Add(importItemCo);

                lineNumber++;
            }

            return importCo;
        }

        #region Template

        public MemoryStream GetTemplate()
        {
            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<OratervTantargyCO>(OratervTantargyCO.OratervTantargyExportAttributeId, GetDefaultDropDownColumnSourceDictionary());
            return SimpleExportLogic.GetTemplate(ImportExportOratervResource.ImportDefaultSheetName, simpleExportColumnCos);
        }

        #endregion Template

        #region Export

        public MemoryStream GetExport()
        {
            List<OratervTantargyCO> coList = new OratervHelper(ConnectionType).GetOratervTantargyCoList().OrderBy(x => x.TantervNev).ThenBy(x => x.OratervNev).ThenBy(x => x.TantargyNev).ToList();
            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<OratervTantargyCO>(OratervTantargyCO.OratervTantargyExportAttributeId, GetDefaultDropDownColumnSourceDictionary());
            return SimpleExportLogic.GetExport(ImportExportOratervResource.ImportDefaultSheetName, simpleExportColumnCos, coList, TanevId);
        }

        public MemoryStream GetNemImportalhatoSorokExport()
        {
            List<OratervImportItemCo> coList = ImportCo.NemImportalhatoItemList;
            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<OratervImportItemCo>(OratervImportItemCo.NemImportalhatoSorokExportAttributeId, GetDefaultDropDownColumnSourceDictionary());
            return ImportExportHelper.NemImportalhatoSorokExport(ImportExportOratervResource.ImportDefaultSheetName, simpleExportColumnCos, coList, TanevId);
        }

        #endregion Export

        private Dictionary<string, ImportItemCompareCo> GetTantargyCompareHashImportItemCompareCoDictionary(List<TantargyItemCo> tantargyItemCoList)
        {
            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
            foreach (TantargyItemCo tantargyItemCo in tantargyItemCoList)
            {
                var md5HashInput =
                    tantargyItemCo.Id +
                    tantargyItemCo.Nev?.ToComparableString();
                string compareHash = ImportExportHelper.GetMd5Hash(md5HashInput);

                var importItemCompareCo = new ImportItemCompareCo
                {
                    Id = tantargyItemCo.Id,
                    CompareHash = compareHash
                };
                //NOTE: Elvileg nem fordulhatna elő, de ha az adatbázisban duplikált adat van, akkor csak az elsőt adjuk hozzá!
                if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
                {
                    compareHashImportItemCompareCoDictionary.Add(compareHash, importItemCompareCo);
                }
            }

            return compareHashImportItemCompareCoDictionary;
        }

        private Dictionary<string, ImportItemCompareCo> GetOratervTantargyCompareHashImportItemCompareCoDictionary(List<OratervTantargyCO> oratervTantargyCoList)
        {
            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
            foreach (OratervTantargyCO oratervTantargyItemCo in oratervTantargyCoList)
            {
                var md5HashInput =
                    oratervTantargyItemCo.OratervId +
                    oratervTantargyItemCo.OratervNev?.ToComparableString() +
                    oratervTantargyItemCo.Tantargy +
                    oratervTantargyItemCo.TantargyNev?.ToComparableString();
                string compareHash = ImportExportHelper.GetMd5Hash(md5HashInput);

                var importItemCompareCo = new ImportItemCompareCo
                {
                    Id = oratervTantargyItemCo.OratervTantargyId,
                    CompareHash = compareHash
                };
                //NOTE: Elvileg nem fordulhatna elő, de ha az adatbázisban duplikált adat van, akkor csak az elsőt adjuk hozzá!
                if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
                {
                    compareHashImportItemCompareCoDictionary.Add(compareHash, importItemCompareCo);
                }
            }

            return compareHashImportItemCompareCoDictionary;
        }

        private Dictionary<string, ImportItemCompareCo> GetOratervCompareHashImportItemCompareCoDictionary(List<OratervCO> oratervCoList)
        {
            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
            foreach (OratervCO oratervItemCo in oratervCoList)
            {
                var md5HashInput =
                    oratervItemCo.OratervId +
                    oratervItemCo.Nev?.ToComparableString();
                string compareHash = ImportExportHelper.GetMd5Hash(md5HashInput);

                var importItemCompareCo = new ImportItemCompareCo
                {
                    Id = oratervItemCo.OratervId,
                    CompareHash = compareHash
                };
                //NOTE: Elvileg nem fordulhatna elő, de ha az adatbázisban duplikált adat van, akkor csak az elsőt adjuk hozzá!
                if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
                {
                    compareHashImportItemCompareCoDictionary.Add(compareHash, importItemCompareCo);
                }
            }

            return compareHashImportItemCompareCoDictionary;
        }

        private static void SetOperationTantargy(OratervImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary)
        {
            var compareHash = importItem.CompareHashTantargy;
            //NOTE: Ha nem találtunk egyezést, akkor mindeképpen Insert!
            if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
            {
                importItem.OperationTantargy = (int)ImportItemOperationEnum.Insert;
            }
        }

        private static void SetOperationOratervTantargy(OratervImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary, int importMuvelet)
        {
            var compareHash = importItem.CompareHash;
            //NOTE: Ha nem találtunk egyezést, akkor mindeképpen Insert!
            if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
            {
                importItem.Operation = (int)ImportItemOperationEnum.Insert;
            }
            //NOTE: Ha találtunk egyezést, akkor...
            else
            {
                ImportItemCompareCo importItemCompareCo = compareHashImportItemCompareCoDictionary[compareHash];
                //NOTE: ...ha a művelet InsertAndUpdate, akkor Update és beállítjuk az Id-t!
                if (importMuvelet == (int)ImportMuveletEnum.InsertAndUpdate)
                {
                    importItem.OratervTantargyId = importItemCompareCo.Id;
                    importItem.Operation = (int)ImportItemOperationEnum.Update;
                }
            }
        }

        private static void SetOperationOraterv(OratervImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary, int importMuvelet)
        {
            var compareHash = importItem.CompareHashOraterv;
            //NOTE: Ha nem találtunk egyezést, akkor mindeképpen Insert!
            if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
            {
                importItem.OperationOraterv = (int)ImportItemOperationEnum.Insert;
            }
            //NOTE: Ha találtunk egyezést, akkor...
            else
            {
                ImportItemCompareCo importItemCompareCo = compareHashImportItemCompareCoDictionary[compareHash];
                //NOTE: ...ha a művelet InsertAndUpdate, akkor Update és beállítjuk az Id-t!
                if (importMuvelet == (int)ImportMuveletEnum.InsertAndUpdate)
                {
                    importItem.OratervId = importItemCompareCo.Id;
                    importItem.OperationOraterv = (int)ImportItemOperationEnum.Update;
                }
                else
                {
                    importItem.OratervId = null;
                }
            }
        }

        public void Import(object importJsonObject)
        {
            string importJson = JsonConvert.SerializeObject(importJsonObject);
            Dal.CustomConnection.Run(ConnectionType, dalHandler => dalHandler.ImportExportDal().OratervImport(IntezmenyId, TanevId, FelhasznaloId, importJson));
        }

        private Dictionary<string, IList<string>> GetDefaultDropDownColumnSourceDictionary()
        {
            //NOTE: Create dropdown lists
            var dropDownColumnSourceDictionary = new Dictionary<string, IList<string>>();

            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
            {
                var connectionType = new DalHandlerConnectionType(ConnectionType, dalHandler);

                dropDownColumnSourceDictionary.Add(ImportExportOratervResource.ImportHeaderNameEvfolyamNeve, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.EvfolyamTipus));

                var tantervHelper = new TantervHelper(connectionType);
                var tantargyHelper = new TantargyHelper(connectionType);
                dropDownColumnSourceDictionary.Add(ImportExportOratervResource.ImportHeaderNameTantervNeve, tantervHelper.GetAktivTantervDataSet().Tables[0].AsEnumerable().Select(t => t.Field<string>("Nev")).ToList());
                dropDownColumnSourceDictionary.Add(ImportExportOratervResource.ImportHeaderNameTantargyNeve, tantargyHelper.GetTantargyCoList(true).OrderBy(x => x.Rendez0).ThenBy(x => x.Rendez1).ThenBy(x => x.Rendez2).ThenBy(x => x.Rendez3).ThenBy(x => x.Rendez4).ThenBy(x => x.Rendez5).Select(t => t.Nev).ToList());
            });

            return dropDownColumnSourceDictionary;
        }
    }
}