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 GondviseloImportExportHelper : LogicBase
    {
        #region Fields

        private readonly string _importObjectCacheKey;

        #endregion Fields

        #region Properties

        public static Dictionary<int, string> ImportHeaderList => new Dictionary<int, string>
        {
            { 00, ImportExportGondviseloResource.ImportHeaderNameTanuloNeve },
            { 01, ImportExportGondviseloResource.ImportHeaderNameTanuloOktatasiAzonosito },
            { 02, ImportExportGondviseloResource.ImportHeaderNameGondviseloNevElotag },
            { 03, ImportExportGondviseloResource.ImportHeaderNameGondviseloVezetekNev },
            { 04, ImportExportGondviseloResource.ImportHeaderNameGondviseloKeresztNev },
            { 05, ImportExportGondviseloResource.ImportHeaderNameGondviseloRokonsagiFoka },
            { 06, ImportExportGondviseloResource.ImportHeaderNameTorvenyesKepviselo },
            { 07, ImportExportGondviseloResource.ImportHeaderNameGondviseloTelefonszama },
            { 08, ImportExportGondviseloResource.ImportHeaderNameTelefonTipus },
            { 09, ImportExportGondviseloResource.ImportHeaderNameGondviseloEmailCime },
            { 10, ImportExportGondviseloResource.ImportHeaderNameEmailTipus },
            { 11, ImportExportGondviseloResource.ImportHeaderNameGondviseloCimTipusa },
            { 12, ImportExportGondviseloResource.ImportHeaderNameGondviseloCimOrszag },
            { 13, ImportExportGondviseloResource.ImportHeaderNameGondviseloCimIranyitoszam },
            { 14, ImportExportGondviseloResource.ImportHeaderNameGondviseloCimHelysegNev },
            { 15, ImportExportGondviseloResource.ImportHeaderNameGondviseloCimKozteruletNev },
            { 16, ImportExportGondviseloResource.ImportHeaderNameGondviseloCimKozteruletJelleg },
            { 17, ImportExportGondviseloResource.ImportHeaderNameGondviseloCimHazszam },
            { 18, ImportExportGondviseloResource.ImportHeaderNameGondviseloCimEmelet },
            { 19, ImportExportGondviseloResource.ImportHeaderNameGondviseloCimAjto },
        };

        public static Dictionary<int, string> ExportHeaderList => new Dictionary<int, string>(ImportHeaderList);

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

        #endregion Constructors

        public void SetImportCo(List<List<string>> importData, int importMuvelet, bool isGeneraltFileLetoltes, bool isEmailKuldes, bool isSzirIntezmeny)
        {
            GondviseloImportCo importCo = GetImportCoFromImportData(importData);
            importCo.ImportMuvelet = importMuvelet;
            importCo.IsGeneraltFileLetoltes = isGeneraltFileLetoltes;
            importCo.IsEmailKuldes = isEmailKuldes;

            SetNemImportalhatoSorokByValidation(importCo);

            List<GondviseloItemCo> coList = importCo.GondviseloCoList;
            //NOTE: Azért van szükség Dictionary-kre, mert így sokkal gyorsabb a keresés!
            Dictionary<string, ImportItemCompareCo> telefonCompareHashImportItemCompareCoDictionary = GetTelefonCompareHashImportItemCompareCoDictionary(coList);
            Dictionary<string, ImportItemCompareCo> emailCompareHashImportItemCompareCoDictionary = GetEmailCompareHashImportItemCompareCoDictionary(coList);
            Dictionary<string, ImportItemCompareCo> cimCompareHashImportItemCompareCoDictionary = GetCimCompareHashImportItemCompareCoDictionary(coList);
            Dictionary<string, ImportItemCompareCo> gondviseloCompareHashImportItemCompareCoDictionary = GetGondviseloCompareHashImportItemCompareCoDictionary(coList);
            foreach (GondviseloImportItemCo importItem in importCo.MainImportItemList)
            {
                if (!string.IsNullOrWhiteSpace(importItem.Telefonszam))
                {
                    SetOperationTelefon(importItem, telefonCompareHashImportItemCompareCoDictionary, importCo.ImportMuvelet);
                }

                if (!string.IsNullOrWhiteSpace(importItem.EmailCim))
                {
                    SetOperationEmail(importItem, emailCompareHashImportItemCompareCoDictionary, importCo.ImportMuvelet);
                }

                if (!string.IsNullOrWhiteSpace(importItem.CimTipusaNev) && importItem.CimOrszagId.IsEntityId())
                {
                    SetOperationCim(importItem, cimCompareHashImportItemCompareCoDictionary, importCo.ImportMuvelet);
                }

                SetOperationGondviselo(importItem, gondviseloCompareHashImportItemCompareCoDictionary, 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 telefonImportJsonItemList = new List<TelefonGondviseloImportJsonItemCo>();
            var emailImportJsonItemList = new List<EmailGondviseloImportJsonItemCo>();
            var cimImportJsonItemList = new List<CimGondviseloImportJsonItemCo>();
            var mainImportJsonItemList = new List<GondviseloImportJsonItemCo>();
            foreach (GondviseloImportItemCo importItem in importCo.MainImportItemList)
            {
                if (!string.IsNullOrWhiteSpace(importItem.Telefonszam))
                {
                    telefonImportJsonItemList.Add(new TelefonGondviseloImportJsonItemCo(importItem, TanevId, IntezmenyId, FelhasznaloId));
                }

                if (!string.IsNullOrWhiteSpace(importItem.EmailCim))
                {
                    emailImportJsonItemList.Add(new EmailGondviseloImportJsonItemCo(importItem, TanevId, IntezmenyId, FelhasznaloId));
                }

                if (!string.IsNullOrWhiteSpace(importItem.CimTipusaNev))
                {
                    cimImportJsonItemList.Add(new CimGondviseloImportJsonItemCo(importItem, TanevId, IntezmenyId, FelhasznaloId));
                }

                mainImportJsonItemList.Add(new GondviseloImportJsonItemCo(importItem, isSzirIntezmeny, TanevId, IntezmenyId, FelhasznaloId));
            }

            importCo.TelefonGondviseloImportJsonItemList = telefonImportJsonItemList;
            importCo.EmailGondviseloImportJsonItemList = emailImportJsonItemList;
            importCo.CimGondviseloImportJsonItemList = cimImportJsonItemList;
            importCo.MainImportJsonItemList = mainImportJsonItemList;

            ImportCo = importCo;
        }

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

            //NOTE: Azokat a sorokat, amelyek hibásak beletesszük a NemImportalhatoItemList-be!
            foreach (GondviseloImportItemCo 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 static void SetOperationTelefon(GondviseloImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary, int importMuvelet)
        {
            var compareHash = importItem.CompareHashTelefon;
            //NOTE: Ha nem találtunk egyezést, akkor mindeképpen Insert!
            if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
            {
                importItem.OperationTelefon = (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.TelefonId = importItemCompareCo.Id;
                    importItem.OperationTelefon = (int)ImportItemOperationEnum.Update;
                }
            }
        }

        private static void SetOperationEmail(GondviseloImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary, int importMuvelet)
        {
            var compareHash = importItem.CompareHashEmail;
            //NOTE: Ha nem találtunk egyezést, akkor mindeképpen Insert!
            if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
            {
                importItem.OperationEmail = (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.EmailId = importItemCompareCo.Id;
                    importItem.OperationEmail = (int)ImportItemOperationEnum.Update;
                }
            }
        }

        private static void SetOperationCim(GondviseloImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary, int importMuvelet)
        {
            var compareHash = importItem.CompareHashCim;
            //NOTE: Ha nem találtunk egyezést, akkor mindeképpen Insert!
            if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
            {
                importItem.OperationCim = (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.CimId = importItemCompareCo.Id;
                    importItem.OperationCim = (int)ImportItemOperationEnum.Update;
                }
            }
        }

        private void SetOperationGondviselo(GondviseloImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary, int importMuvelet)
        {
            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 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;
                }
            }
        }

        private GondviseloImportCo GetImportCoFromImportData(List<List<string>> importData)
        {
            var importCo = new GondviseloImportCo
            {
                GondviseloCoList = new GondviseloHelper(ConnectionType).GetGondviseloCoList()
            };

            List<TanuloItemCo> tanuloCoList = new TanuloHelper(ConnectionType).GetTanuloCoList();
            int lineNumber = 1;
            foreach (List<string> importDataRow in importData.Skip(1))
            {
                var importItemCo = new GondviseloImportItemCo(TanevId)
                {
                    LineNumber = lineNumber,

                    TanuloNeveImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameTanuloNeve)],
                    TanuloOktatasiAzonositoImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameTanuloOktatasiAzonosito)],
                    GondviseloNevElotagImportData = Extensions.NameExtensions.CleanElotag(importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloNevElotag)]),
                    GondviseloVezeteknevImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloVezetekNev)].ReplaceMultipleSpacesAndTrim(),
                    GondviseloKeresztnevImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloKeresztNev)].ReplaceMultipleSpacesAndTrim(),
                    GondviseloRokonsagiFokaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloRokonsagiFoka)],
                    GondviseloTelefonszamaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloTelefonszama)],
                    GondviseloEmailCimeImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloEmailCime)],
                    CimAjtoImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimAjto)],
                    EmailTipusImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameEmailTipus)],
                    CimEmeletImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimEmelet)],
                    CimHazszamImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimHazszam)],
                    CimHelysegNevImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimHelysegNev)],
                    CimIranyitoszamImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimIranyitoszam)],
                    CimKozteruletJellegeImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimKozteruletJelleg)],
                    CimKozteruletNevImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimKozteruletNev)],
                    CimOrszagImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimOrszag)],
                    CimTipusaImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimTipusa)],
                    TelefonTipusImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameTelefonTipus)],
                    TorvenyesKepviseloImportData = importDataRow[ImportHeaderList.GetKeyByUniqueValue(ImportExportGondviseloResource.ImportHeaderNameTorvenyesKepviselo)],
                };

                //NOTE: Azért nem SingleOrDefault, mert többször gondviselője is lehet egy tanulónak.
                importItemCo.FelhasznaloId = tanuloCoList.FirstOrDefault(x =>
                    x.FelhasznaloNyomtatasiNevComparableString == importItemCo.TanuloNeveImportData?.ToComparableString() &&
                    x.FelhasznaloOktatasiAzonositoComparableString == importItemCo.FelhasznaloOktatasiAzonosito?.ToComparableString())?.Id;

                var gondviseloNev = Extensions.NameExtensions.GetNevSorrendben("F", Extensions.NameExtensions.CleanElotag(importItemCo.GondviseloNevElotag), importItemCo.GondviseloVezeteknev, importItemCo.GondviseloKeresztnev);
                //NOTE: Azért nem SingleOrDefault, mert hibásan lehet több gondviselő ugyanazzal a névvel és rokonsági fokkal
                importItemCo.Gondviselo = importCo.GondviseloCoList.FirstOrDefault(x =>
                    x.FelhasznaloId == importItemCo.FelhasznaloId &&
                    x.NevComparableString == gondviseloNev?.ToComparableString() &&
                    x.RokonsagiFokId == importItemCo.RokonsagiFokId);

                string telefonMd5HashInput =
                    importItemCo.FelhasznaloId +
                    gondviseloNev?.ToComparableString() +
                    importItemCo.RokonsagiFokId;
                importItemCo.CompareHashTelefon = ImportExportHelper.GetMd5Hash(telefonMd5HashInput);

                string emailMd5HashInput =
                    importItemCo.FelhasznaloId +
                    gondviseloNev?.ToComparableString() +
                    importItemCo.RokonsagiFokId;
                importItemCo.CompareHashEmail = ImportExportHelper.GetMd5Hash(emailMd5HashInput);

                string cimMd5HashInput =
                    importItemCo.FelhasznaloId +
                    gondviseloNev?.ToComparableString() +
                    importItemCo.RokonsagiFokId +
                    importItemCo.CimTipusaId;
                importItemCo.CompareHashCim = ImportExportHelper.GetMd5Hash(cimMd5HashInput);

                string gondviseloMd5HashInput =
                    importItemCo.FelhasznaloId +
                    gondviseloNev?.ToComparableString() +
                    importItemCo.RokonsagiFokId;
                importItemCo.CompareHash = ImportExportHelper.GetMd5Hash(gondviseloMd5HashInput);

                importCo.MainImportItemList.Add(importItemCo);

                lineNumber++;
            }

            return importCo;
        }

        public MemoryStream GetTemplate()
        {
            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<GondviseloItemCo>(GondviseloItemCo.GondviselokExportAttributeId, GetDefaultDropDownColumnSourceDictionary());
            return SimpleExportLogic.GetTemplate(ImportExportGondviseloResource.ImportDefaultSheetName, simpleExportColumnCos);
        }

        public MemoryStream GetExport()
        {
            List<GondviseloItemCo> coList = new GondviseloHelper(ConnectionType).GetGondviseloCoList().OrderBy(x => x.FelhasznaloVezeteknev).ThenBy(x => x.FelhasznaloKeresztnev).ThenBy(x => x.VezetekNev).ThenBy(x => x.KeresztNev).ToList();
            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<GondviseloItemCo>(GondviseloItemCo.GondviselokExportAttributeId, GetDefaultDropDownColumnSourceDictionary());
            return SimpleExportLogic.GetExport(ImportExportGondviseloResource.ImportDefaultSheetName, simpleExportColumnCos, coList, TanevId);
        }

        public MemoryStream GetNemImportalhatoSorokExport()
        {
            List<GondviseloImportItemCo> coList = ImportCo.NemImportalhatoItemList.OrderBy(x => x.TanuloNeveImportData).ThenBy(x => x.GondviseloVezeteknevImportData).ThenBy(x => x.GondviseloKeresztnevImportData).ToList();
            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<GondviseloImportItemCo>(GondviseloImportItemCo.NemImportalhatoSorokExportAttributeId);
            return ImportExportHelper.NemImportalhatoSorokExport(ImportExportGondviseloResource.ImportDefaultSheetName, simpleExportColumnCos, coList, TanevId);
        }

        private Dictionary<string, ImportItemCompareCo> GetTelefonCompareHashImportItemCompareCoDictionary(List<GondviseloItemCo> gondviseloItemCoList)
        {
            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
            foreach (GondviseloItemCo gondviseloItemCo in gondviseloItemCoList)
            {
                var telefon = gondviseloItemCo.TelefonList.FirstOrDefault();
                if (telefon != null)
                {
                    var md5HashInput =
                        gondviseloItemCo.FelhasznaloId +
                        gondviseloItemCo.NevComparableString +
                        gondviseloItemCo.RokonsagiFokId;
                    string compareHash = ImportExportHelper.GetMd5Hash(md5HashInput);

                    var importItemCompareCo = new ImportItemCompareCo
                    {
                        Id = telefon.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> GetEmailCompareHashImportItemCompareCoDictionary(List<GondviseloItemCo> gondviseloItemCoList)
        {
            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
            foreach (GondviseloItemCo gondviseloItemCo in gondviseloItemCoList)
            {
                var email = gondviseloItemCo.EmailList.FirstOrDefault();
                if (email != null)
                {
                    var md5HashInput =
                        gondviseloItemCo.FelhasznaloId +
                        gondviseloItemCo.NevComparableString +
                        gondviseloItemCo.RokonsagiFokId;
                    string compareHash = ImportExportHelper.GetMd5Hash(md5HashInput);

                    var importItemCompareCo = new ImportItemCompareCo
                    {
                        Id = email.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> GetCimCompareHashImportItemCompareCoDictionary(List<GondviseloItemCo> gondviseloItemCoList)
        {
            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
            foreach (GondviseloItemCo gondviseloItemCo in gondviseloItemCoList)
            {
                var cim = gondviseloItemCo.AllandoLakcim;
                if (cim != null)
                {
                    var md5HashInput =
                        gondviseloItemCo.FelhasznaloId +
                        gondviseloItemCo.NevComparableString +
                        gondviseloItemCo.RokonsagiFokId +
                        cim.TipusId;
                    string compareHash = ImportExportHelper.GetMd5Hash(md5HashInput);

                    var importItemCompareCo = new ImportItemCompareCo
                    {
                        Id = cim.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> GetGondviseloCompareHashImportItemCompareCoDictionary(List<GondviseloItemCo> gondviseloItemCoList)
        {
            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
            foreach (GondviseloItemCo co in gondviseloItemCoList)
            {
                var md5HashInput =
                    co.FelhasznaloId +
                    co.NevComparableString +
                    co.RokonsagiFokId;
                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;
        }

        public BelepesiAdatokListCO Import(object importJsonObject, bool isEmailKuldes, bool isActivTanev, bool isKovTanev, bool isSzirIntezmeny)
        {
            string importJson = JsonConvert.SerializeObject(importJsonObject);
            var belepesiAdatokListCo = new BelepesiAdatokListCO();
            if (!isSzirIntezmeny && (isActivTanev || isKovTanev))
            {
                Dal.CustomConnection.Run(ConnectionType, h =>
                {
                    DataSet result = h.ImportExportDal().GondviseloImport(IntezmenyId, TanevId, FelhasznaloId, importJson);
                    h.Felhasznalo().UpdateAllEgyediAzonosito();

                    if (isActivTanev && result.Tables[0].Rows.Count > 0)
                    {
                        var tanuloHelper = new TanuloHelper(new DalHandlerConnectionType(ConnectionType, h));
                        foreach (DataRow dataRow in result.Tables[0].Rows)
                        {
                            tanuloHelper.AlapertelmezettGondviseloBelepesGeneralas(SDAConvert.ToInt32(dataRow["ID"]), isEmailKuldes, belepesiAdatokListCo);
                        }
                    }
                });
            }

            return belepesiAdatokListCo;
        }

        private Dictionary<string, IList<string>> GetDefaultDropDownColumnSourceDictionary()
        {
            var dropDownColumnSourceDictionary = new Dictionary<string, IList<string>>();

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

                dropDownColumnSourceDictionary.Add(ImportExportGondviseloResource.ImportHeaderNameGondviseloRokonsagiFoka, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.RokonsagiFok));
                dropDownColumnSourceDictionary.Add(ImportExportGondviseloResource.ImportHeaderNameTelefonTipus, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.TelefonTipus));
                dropDownColumnSourceDictionary.Add(ImportExportGondviseloResource.ImportHeaderNameEmailTipus, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.EmailTipus));
                dropDownColumnSourceDictionary.Add(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimOrszag, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.OrszagTipus));

                dropDownColumnSourceDictionary.Add(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimTipusa, new List<string> { CimTipusEnum.allando_lakcim.GetDisplayName(TanevId) });

                dropDownColumnSourceDictionary.Add(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimKozteruletJelleg, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.KozteruletJelleg));

                var importExportHelper = new ImportExportHelper(connectionType);

                dropDownColumnSourceDictionary.Add(ImportExportGondviseloResource.ImportHeaderNameTanuloNeve, importExportHelper.GetTanuloList());

                var telepulesHelper = new TelepulesHelper(connectionType);

                dropDownColumnSourceDictionary.Add(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimIranyitoszam, telepulesHelper.GetIranyitoszamok("").Select(i => i.Iranyitoszam).ToList());
                dropDownColumnSourceDictionary.Add(ImportExportGondviseloResource.ImportHeaderNameGondviseloCimHelysegNev, telepulesHelper.GetTelepulesek().Select(t => t.TelepulesNev).ToList());
            });

            return dropDownColumnSourceDictionary;
        }
    }
}