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;

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

        private readonly string _importObjectCacheKey;

        #endregion Fields

        #region Properties

        public static Dictionary<int, string> ImportHeaderList => new Dictionary<int, string>
        {
            { 00, ImportExportTeremResource.ImportHeaderNameHelyisegNev },
            { 01, ImportExportTeremResource.ImportHeaderNameJelleg },
            { 02, ImportExportTeremResource.ImportHeaderNameBefogadokepesseg },
            { 03, ImportExportTeremResource.ImportHeaderNameAlapterulet }
        };

        public TeremImportCo ImportCo
        {
            get => (TeremImportCo)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 TeremImportExportHelper(IConnectionType connectionType) : base(connectionType)
        {
            _importObjectCacheKey = $"{nameof(TeremImportCo)}_{IntezmenyId}_{FelhasznaloId}_ImportObjectCacheKey";
        }

        #endregion Constructors

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

            SetNemImportalhatoSorokByValidation(importCo);

            SetOperationAndNemImportalhatoSorokByOperation(importCo);

            var mainImportJsonItemList = new List<TeremImportJsonItemCo>(importCo.MainImportItemList.Select(x => new TeremImportJsonItemCo(x, mukodesiHelyId, TanevId, IntezmenyId, FelhasznaloId)));
            importCo.MainImportJsonItemList = mainImportJsonItemList;

            ImportCo = importCo;
        }

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

            //NOTE: Azokat a sorokat, amelyek hibásak beletesszük a NemImportalhatoItemList-be!
            foreach (TeremImportItemCo 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 void SetOperationAndNemImportalhatoSorokByOperation(TeremImportCo importCo)
        {
            int importMuvelet = importCo.ImportMuvelet;
            //NOTE: Azért van szükség Dictionary-re, mert így sokkal gyorsabb a keresés!
            Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary = GetCompareHashImportItemCompareCoDictionary(importCo.TeremCoList);
            foreach (TeremImportItemCo importItem in importCo.MainImportItemList)
            {
                string 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 az import művelet DeleteAndInsert és a db-ből jövő adat Importalt(a nem importáltakat egyelőre nem töröljük), akkor Insert, mert töröljük a korábbi elemeket és újra be kell szúrni!
                    if (importMuvelet == (int)ImportMuveletEnum.DeleteAndInsert && importItemCompareCo.Importalt)
                    {
                        importItem.Operation = (int)ImportItemOperationEnum.Insert;
                    }
                    //NOTE: ...ha nincs törlés, akkor...
                    else
                    {
                        //NOTE: ...ha a művelet InsertAndUpdate, akkor Update és beállítjuk az Id-t!
                        if (importMuvelet == (int)ImportMuveletEnum.InsertAndUpdate)
                        {
                            importItem.Id = importItemCompareCo.Id;
                            importItem.Operation = (int)ImportItemOperationEnum.Update;
                        }
                        //NOTE: ...ha a művelet nem InsertAndUpdate, akkor hozzá kell adni a nem NemImportalhatoItemList-hez és jelezni, hogy már szerepel az adatbázisban(Insert vagy DeleteAndInsert műveletnél. A DeleteAndInsert csak akkor fut be ide, ha az elem nem importált.)!
                        else
                        {
                            importItem.ErrorList.Add(ImportExportCommonResource.NemImportalhatoMertMarSzerepelAzAdatbazisban);
                            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 TeremImportCo GetImportCoFromImportData(List<List<string>> importData)
        {
            var importCo = new TeremImportCo
            {
                TeremCoList = new TeremHelper(ConnectionType).GetTeremCoList()
            };

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

                    HelyisegNevImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTeremResource.ImportHeaderNameHelyisegNev)],
                    JellegImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTeremResource.ImportHeaderNameJelleg)],
                    BefogadokepessegImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTeremResource.ImportHeaderNameBefogadokepesseg)],
                    AlapteruletImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportTeremResource.ImportHeaderNameAlapterulet)]
                };

                string md5HashInput = importItemCo.Nev?.ToComparableString();
                importItemCo.CompareHash = ImportExportHelper.GetMd5Hash(md5HashInput);

                importCo.MainImportItemList.Add(importItemCo);

                lineNumber++;
            }

            return importCo;
        }

        #region Template

        public MemoryStream GetTemplate()
        {
            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<TeremItemCo>(TeremItemCo.TeremTemplateExportAttributeId, GetDefaultDropDownColumnSourceDictionary());
            return SimpleExportLogic.GetTemplate(ImportExportTeremResource.ImportDefaultSheetName, simpleExportColumnCos);
        }

        #endregion Template

        #region Export

        public MemoryStream GetExport(bool isTermekAdataiExport)
        {
            string simpleExportColumnAttributeId;
            Dictionary<string, IList<string>> dropDownColumnSourceDictionary;
            if (isTermekAdataiExport)
            {
                simpleExportColumnAttributeId = TeremItemCo.TermekAdataiExportAttributeId;
                dropDownColumnSourceDictionary = GetTermekAdataiExportDropDownColumnSourceDictionary();
            }
            else
            {
                simpleExportColumnAttributeId = TeremItemCo.TeremExportAttributeId;
                dropDownColumnSourceDictionary = GetExportDropDownColumnSourceDictionary();
            }

            List<TeremItemCo> coList = new TeremHelper(ConnectionType).GetTeremCoList().OrderBy(x => x.Nev).ToList();
            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<TeremItemCo>(simpleExportColumnAttributeId, dropDownColumnSourceDictionary);
            return SimpleExportLogic.GetExport(ImportExportTeremResource.ImportDefaultSheetName, simpleExportColumnCos, coList, TanevId);
        }

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

        #endregion Export

        private Dictionary<string, ImportItemCompareCo> GetCompareHashImportItemCompareCoDictionary(List<TeremItemCo> coList)
        {
            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
            foreach (TeremItemCo co in coList)
            {
                string md5HashInput = co.NevComparableString;
                string compareHash = ImportExportHelper.GetMd5Hash(md5HashInput);

                var importItemCompareCo = new ImportItemCompareCo
                {
                    Id = co.Id,
                    CompareHash = compareHash,
                    Importalt = co.Importalt
                };
                //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, 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(ImportExportTeremResource.ImportHeaderNameJelleg, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.TeremTipus));

            });

            return dropDownColumnSourceDictionary;
        }

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

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

                dropDownColumnSourceDictionary.Add(ImportExportTeremResource.ImportHeaderNameJelleg, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.TeremTipus));

                var helper = new ImportExportHelper(connectionType);
                DataSet feladatellatasiHelyDataSet = dalHandler.FeladatEllatasiHelyDal().GetFeladatellatasiHelyDataSet(TanevId);

                dropDownColumnSourceDictionary.Add(ImportExportTeremResource.ExportHeaderNameMukodesiHely, helper.GetMukodesiHelyList(feladatellatasiHelyDataSet));
            });

            return dropDownColumnSourceDictionary;
        }

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

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

                dropDownColumnSourceDictionary.Add(ImportExportTeremResource.ImportHeaderNameJelleg, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.TeremTipus));

                var helper = new ImportExportHelper(connectionType);
                DataSet feladatellatasiHelyDataSet = dalHandler.FeladatEllatasiHelyDal().GetFeladatellatasiHelyDataSet(TanevId);

                dropDownColumnSourceDictionary.Add(ImportExportTeremResource.ExportHeaderNameMukodesiHely, helper.GetMukodesiHelyList(feladatellatasiHelyDataSet));
                dropDownColumnSourceDictionary.Add(ImportExportTeremResource.ExportHeaderNameTeremfelelos, helper.GetTanarList());
            });

            return dropDownColumnSourceDictionary;
        }
    }
}