using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
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;
using Kreta.Enums.ManualEnums.ImportExport;
using Kreta.Resources;

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

        private readonly string _importObjectCacheKey;

        #endregion Fields

        #region Properties

        public static Dictionary<int, string> ImportHeaderListForAlkalmazott => new Dictionary<int, string>
        {
            { 00, ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottNeve },
            { 01, ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottOktatasiAzonosito },
            { 02, ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottSzuletesiDatuma },
            { 03, ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottFelhasznaloneve },
            { 04, ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottJelszava }
        };

        public static Dictionary<int, string> ImportHeaderListForTanulo => new Dictionary<int, string>
        {
            { 00, ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloNevSzulidoOktazon },
            { 01, ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloFelhasznaloneve },
            { 02, ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloJelszava }
        };

        public static Dictionary<int, string> ImportHeaderListForGondviselo => new Dictionary<int, string>
        {
            { 00, ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloNeve },
            { 01, ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloOktatasiAzonosito },
            { 02, ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloSzuletesiDatuma },
            { 03, ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloOsztalya },
            { 04, ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloNeve },
            { 05, ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloRokonsagiFoka },
            { 06, ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloFelhasznaloneve },
            { 07, ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloJelszava }
        };

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

        #endregion Constructors

        public void SetImportCo(List<List<string>> importData, int importMuvelet, FelhasznaloBelepesExportImportTipusEnum tipusEnum, bool isGeneraltFileLetoltes, bool isEmailKuldes, int? anotherYearId, bool isKovTanev, bool isSzakkepzoIntezmeny)
        {
            FelhasznaloBelepesImportCo importCo = GetImportCoFromImportData(importData, tipusEnum, anotherYearId, isKovTanev);
            importCo.ImportMuvelet = importMuvelet;
            importCo.IsGeneraltFileLetoltes = isGeneraltFileLetoltes;
            importCo.IsEmailKuldes = isEmailKuldes;
            importCo.TipusEnum = tipusEnum;

            Dictionary<int, List<ValidationResult>> validationResultDictionary = importCo.Validate(ConnectionType, isSzakkepzoIntezmeny);
            SetNemImportalhatoSorokByValidation(importCo, validationResultDictionary);

            SetOperationAndNemImportalhatoSorokByOperation(importCo);

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

            ImportCo = importCo;
        }

        private static void SetNemImportalhatoSorokByValidation(FelhasznaloBelepesImportCo importCo, Dictionary<int, List<ValidationResult>> validationResultDictionary)
        {
            //NOTE: Azokat a sorokat, amelyek hibásak beletesszük a NemImportalhatoItemList-be!
            foreach (FelhasznaloBelepesImportItemCo 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(FelhasznaloBelepesImportCo 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.FelhasznaloBelepesCoList, importCo.TipusEnum);
            foreach (FelhasznaloBelepesImportItemCo importItem in importCo.MainImportItemList)
            {
                string compareHash = importItem.CompareHash;
                ImportItemCompareCo importItemCompareCo = null;
                if (compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
                {
                    importItemCompareCo = compareHashImportItemCompareCoDictionary[compareHash];
                }

                //NOTE: Ha nem találtunk egyezést és nincs felhasználó belépése a felhasználónak, akkor mindeképpen Insert!
                if (importItemCompareCo == null || !importItemCompareCo.Id.IsEntityId())
                {
                    importItem.Operation = (int)ImportItemOperationEnum.Insert;
                }
                //NOTE: Ha találtunk egyezést, akkor...
                else
                {
                    //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 FelhasznaloBelepesImportCo GetImportCoFromImportData(List<List<string>> importData, FelhasznaloBelepesExportImportTipusEnum tipusEnum, int? anotherYearId, bool isKovTanev)
        {
            var felhasznaloBelepesHelper = new FelhasznaloBelepesHelper(ConnectionType);
            var felhasznaloBelepesCoList = new List<FelhasznaloBelepesItemCo>();

            felhasznaloBelepesCoList.AddRange(felhasznaloBelepesHelper.GetFelhasznaloBelepesCoList().OrderBy(x => x.FelhasznaloVezeteknev).ThenBy(x => x.FelhasznaloKeresztnev));

            if (anotherYearId.HasValue)
            {
                var anotherYearFelBelCoList = felhasznaloBelepesHelper.GetFelhasznaloBelepesCoList(anotherYearId);
                anotherYearFelBelCoList.ForEach(x => x.AnotherYearTanevMegnevezes = (isKovTanev ? ErrorResource.AzAktualisTaneven : ErrorResource.AKovetkezoTaneven));
                felhasznaloBelepesCoList.AddRange(anotherYearFelBelCoList.OrderBy(x => x.FelhasznaloVezeteknev).ThenBy(x => x.FelhasznaloKeresztnev));
            }

            var importCo = new FelhasznaloBelepesImportCo
            {
                FelhasznaloBelepesCoList = felhasznaloBelepesCoList,
                TipusEnum = tipusEnum
            };

            int lineNumber = 1;
            foreach (List<string> importDataRow in importData.Skip(1))
            {
                FelhasznaloBelepesImportItemCo importItemCo;
                switch (tipusEnum)
                {
                    case FelhasznaloBelepesExportImportTipusEnum.Alkalmazott:
                        importItemCo = new FelhasznaloBelepesImportItemCo(TanevId)
                        {
                            NeveImportData = importDataRow[ImportHeaderListForAlkalmazott.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottNeve)],
                            OktatasiAzonositoImportData = importDataRow[ImportHeaderListForAlkalmazott.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottOktatasiAzonosito)],
                            SzuletesiDatumaImportData = importDataRow[ImportHeaderListForAlkalmazott.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottSzuletesiDatuma)],
                            FelhasznaloNeveImportData = importDataRow[ImportHeaderListForAlkalmazott.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottFelhasznaloneve)],
                            JelszavaImportData = importDataRow[ImportHeaderListForAlkalmazott.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottJelszava)]
                        };

                        break;

                    case FelhasznaloBelepesExportImportTipusEnum.Tanulo:
                        importItemCo = new FelhasznaloBelepesImportItemCo(TanevId)
                        {
                            TanuloNevOktAzonSzulDatumImportData = importDataRow[ImportHeaderListForTanulo.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloNevSzulidoOktazon)],
                            FelhasznaloNeveImportData = importDataRow[ImportHeaderListForTanulo.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloFelhasznaloneve)],
                            JelszavaImportData = importDataRow[ImportHeaderListForTanulo.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloJelszava)]
                        };
                        (importItemCo.NeveImportData, importItemCo.SzuletesiDatumaImportData, importItemCo.OktatasiAzonositoImportData) = GetNevSzulDatumOktAzonFromTanuloImportData(importItemCo.TanuloNevOktAzonSzulDatumImportData);
                        break;

                    case FelhasznaloBelepesExportImportTipusEnum.Gondviselo:
                        importItemCo = new FelhasznaloBelepesImportItemCo(TanevId)
                        {
                            NeveImportData = importDataRow[ImportHeaderListForGondviselo.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloNeve)],
                            OktatasiAzonositoImportData = importDataRow[ImportHeaderListForGondviselo.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloOktatasiAzonosito)],
                            SzuletesiDatumaImportData = importDataRow[ImportHeaderListForGondviselo.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloSzuletesiDatuma)],
                            GondviseloNeveImportData = importDataRow[ImportHeaderListForGondviselo.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloNeve)],
                            GondviseloRokonsagiFokaImportData = importDataRow[ImportHeaderListForGondviselo.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloRokonsagiFoka)],
                            FelhasznaloNeveImportData = importDataRow[ImportHeaderListForGondviselo.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloFelhasznaloneve)],
                            JelszavaImportData = importDataRow[ImportHeaderListForGondviselo.GetKeyByUniqueValue(ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloJelszava)]
                        };
                        break;

                    default:
                        throw new Exception();
                }

                importItemCo.TipusEnum = tipusEnum;
                importItemCo.LineNumber = lineNumber;

                //NOTE: Azért nem SingleOrDefault, mert az adatbázisban lehet olyan hiba, hogy egy tanulóhoz több olyan gondviselő van, akinek a neve és rokonsági foka megegyezik
                importItemCo.FelhasznaloBelepes = importCo.FelhasznaloBelepesCoList.Where(x => x.TipusEnum == importItemCo.TipusEnum).FirstOrDefault(x =>
                    x.FelhasznaloNyomtatasiNevComparableString == importItemCo.NeveImportData?.ToComparableString() &&
                    x.FelhasznaloOktatasiAzonositoComparableString == importItemCo.OktatasiAzonosito?.ToComparableString() &&
                    x.FelhasznaloSzuletesiIdo == importItemCo.SzuletesiIdo &&
                    (x.TipusEnum != FelhasznaloBelepesExportImportTipusEnum.Gondviselo && !x.GondviseloId.IsEntityId() ||
                     x.TipusEnum == FelhasznaloBelepesExportImportTipusEnum.Gondviselo && x.GondviseloId.IsEntityId() && x.GondviseloNevComparableString == importItemCo.GondviseloNev?.ToComparableString() && x.GondviseloRokonsagiFokId == importItemCo.GondviseloRokonsagiFokId));

                string md5HashInput =
                    importItemCo.NeveImportData?.ToComparableString() +
                    importItemCo.OktatasiAzonosito?.ToComparableString() +
                    importItemCo.SzuletesiIdoString?.ToComparableString();
                if (importItemCo.TipusEnum == FelhasznaloBelepesExportImportTipusEnum.Gondviselo)
                {
                    md5HashInput += importItemCo.GondviseloNev?.ToComparableString();
                    md5HashInput += importItemCo.GondviseloRokonsagiFokId;
                }

                importItemCo.CompareHash = ImportExportHelper.GetMd5Hash(md5HashInput);

                importCo.MainImportItemList.Add(importItemCo);

                lineNumber++;
            }

            return importCo;
        }

        private (string nev, string szulDatum, string oktAzon) GetNevSzulDatumOktAzonFromTanuloImportData(string tanuloNevOktAzonSzulDatumImportData)
        {
            var splittedTanuloNev = tanuloNevOktAzonSzulDatumImportData.Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries);

            var nev = splittedTanuloNev.ElementAtOrDefault(0);
            var szulDatum = splittedTanuloNev.ElementAtOrDefault(1);
            var oktAzon = splittedTanuloNev.ElementAtOrDefault(2);

            return (nev, szulDatum, oktAzon);
        }

        #region Template

        public MemoryStream GetTemplate(FelhasznaloBelepesExportImportTipusEnum tipusEnum)
        {
            string worksheetName = DetailsByEnum(tipusEnum).WorksheetName;
            string simpleExportColumnAttributeId = null;
            switch (tipusEnum)
            {
                case FelhasznaloBelepesExportImportTipusEnum.Alkalmazott:
                    simpleExportColumnAttributeId = FelhasznaloBelepesItemCo.AlkalmazottFelhasznaloBelepesExportAttributeId;
                    break;

                case FelhasznaloBelepesExportImportTipusEnum.Tanulo:
                    simpleExportColumnAttributeId = FelhasznaloBelepesItemCo.TanuloFelhasznaloBelepesExportAttributeId;
                    break;

                case FelhasznaloBelepesExportImportTipusEnum.Gondviselo:
                    simpleExportColumnAttributeId = FelhasznaloBelepesItemCo.GondviseloFelhasznaloBelepesExportAttributeId;
                    break;
            }

            if (simpleExportColumnAttributeId == null)
            {
                throw new NullReferenceException(string.Format(ErrorResource.Az0ValtozoErtekeNemLehetNull, nameof(simpleExportColumnAttributeId)));
            }

            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<FelhasznaloBelepesItemCo>(simpleExportColumnAttributeId, GetDefaultDropDownColumnSourceDictionary(tipusEnum));
            return SimpleExportLogic.GetTemplate(worksheetName, simpleExportColumnCos);
        }

        #endregion Template

        #region Export

        public MemoryStream GetExport(FelhasznaloBelepesExportImportTipusEnum tipusEnum)
        {
            string worksheetName = DetailsByEnum(tipusEnum).WorksheetName;
            string simpleExportColumnAttributeId = null;
            switch (tipusEnum)
            {
                case FelhasznaloBelepesExportImportTipusEnum.Alkalmazott:
                    simpleExportColumnAttributeId = FelhasznaloBelepesItemCo.AlkalmazottFelhasznaloBelepesExportAttributeId;
                    break;

                case FelhasznaloBelepesExportImportTipusEnum.Tanulo:
                    simpleExportColumnAttributeId = FelhasznaloBelepesItemCo.TanuloFelhasznaloBelepesExportAttributeId;
                    break;

                case FelhasznaloBelepesExportImportTipusEnum.Gondviselo:
                    simpleExportColumnAttributeId = FelhasznaloBelepesItemCo.GondviseloFelhasznaloBelepesExportAttributeId;
                    break;
            }

            if (simpleExportColumnAttributeId == null)
            {
                throw new NullReferenceException(string.Format(ErrorResource.Az0ValtozoErtekeNemLehetNull, nameof(simpleExportColumnAttributeId)));
            }

            List<FelhasznaloBelepesItemCo> coList = new FelhasznaloBelepesHelper(ConnectionType).GetFelhasznaloBelepesCoList()
                .Where(x => x.TipusEnum == tipusEnum)
                .OrderBy(x => x.FelhasznaloVezeteknev)
                .ThenBy(x => x.FelhasznaloKeresztnev)
                .ToList();
            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<FelhasznaloBelepesItemCo>(simpleExportColumnAttributeId, GetDefaultDropDownColumnSourceDictionary(tipusEnum));
            return SimpleExportLogic.GetExport(worksheetName, simpleExportColumnCos, coList, TanevId);
        }

        public MemoryStream GetNemImportalhatoSorokExport(FelhasznaloBelepesExportImportTipusEnum tipusEnum)
        {
            string worksheetName = DetailsByEnum(tipusEnum).WorksheetName;
            string simpleExportColumnAttributeId = null;
            switch (tipusEnum)
            {
                case FelhasznaloBelepesExportImportTipusEnum.Alkalmazott:
                    simpleExportColumnAttributeId = FelhasznaloBelepesImportItemCo.AlkalmazottNemImportalhatoSorokExportAttributeId;
                    break;

                case FelhasznaloBelepesExportImportTipusEnum.Tanulo:
                    simpleExportColumnAttributeId = FelhasznaloBelepesImportItemCo.TanuloNemImportalhatoSorokExportAttributeId;
                    break;

                case FelhasznaloBelepesExportImportTipusEnum.Gondviselo:
                    simpleExportColumnAttributeId = FelhasznaloBelepesImportItemCo.GondviseloNemImportalhatoSorokExportAttributeId;
                    break;
            }

            if (simpleExportColumnAttributeId == null)
            {
                throw new NullReferenceException(string.Format(ErrorResource.Az0ValtozoErtekeNemLehetNull, nameof(simpleExportColumnAttributeId)));
            }

            List<FelhasznaloBelepesImportItemCo> coList = ImportCo.NemImportalhatoItemList;
            List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos<FelhasznaloBelepesImportItemCo>(simpleExportColumnAttributeId, GetDefaultDropDownColumnSourceDictionary(tipusEnum));
            return ImportExportHelper.NemImportalhatoSorokExport(worksheetName, simpleExportColumnCos, coList, TanevId);
        }

        #endregion Export

        private Dictionary<string, ImportItemCompareCo> GetCompareHashImportItemCompareCoDictionary(List<FelhasznaloBelepesItemCo> coList, FelhasznaloBelepesExportImportTipusEnum tipusEnum)
        {
            var compareHashImportItemCompareCoDictionary = new Dictionary<string, ImportItemCompareCo>();
            foreach (FelhasznaloBelepesItemCo co in coList.Where(i => i.TipusEnum == tipusEnum))
            {
                string md5HashInput =
                    co.FelhasznaloNyomtatasiNevComparableString +
                    co.FelhasznaloOktatasiAzonositoComparableString +
                    co.FelhasznaloSzuletesiIdoComparableString;
                if (tipusEnum == FelhasznaloBelepesExportImportTipusEnum.Gondviselo)
                {
                    md5HashInput += co.GondviseloNevComparableString;
                    md5HashInput += co.GondviseloRokonsagiFokId;
                }

                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 (string WorksheetName, Dictionary<int, string> ExcelHeaderList) DetailsByEnum(FelhasznaloBelepesExportImportTipusEnum tipusEnum)
        {
            switch (tipusEnum)
            {
                case FelhasznaloBelepesExportImportTipusEnum.Alkalmazott:
                    return (ImportExportFelhasznaloBelepesResource.AlkalmazottFelhasznaloBelepesiAdatok, ImportHeaderListForAlkalmazott);

                case FelhasznaloBelepesExportImportTipusEnum.Tanulo:
                    return (ImportExportFelhasznaloBelepesResource.TanuloFelhasznaloBelepesiAdatok, ImportHeaderListForTanulo);

                case FelhasznaloBelepesExportImportTipusEnum.Gondviselo:
                    return (ImportExportFelhasznaloBelepesResource.GondviseloFelhasznaloBelepesiAdatok, ImportHeaderListForGondviselo);
            }

            return (string.Empty, null);
        }

        private Dictionary<string, IList<string>> GetDefaultDropDownColumnSourceDictionary(FelhasznaloBelepesExportImportTipusEnum tipusEnum)
        {
            //NOTE: Create dropdown lists
            var dropDownColumnSourceDictionary = new Dictionary<string, IList<string>>();
            switch (tipusEnum)
            {
                case FelhasznaloBelepesExportImportTipusEnum.Alkalmazott:
                    Dal.CustomConnection.Run(ConnectionType, dalHandler =>
                    {
                        var helper = new ImportExportHelper(new DalHandlerConnectionType(ConnectionType, dalHandler));
                        dropDownColumnSourceDictionary.Add(ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottNeve, helper.GetTanarList());
                    });
                    break;

                case FelhasznaloBelepesExportImportTipusEnum.Tanulo:
                    Dal.CustomConnection.Run(ConnectionType, dalHandler =>
                    {
                        var helper = new ImportExportHelper(new DalHandlerConnectionType(ConnectionType, dalHandler));
                        dropDownColumnSourceDictionary.Add(ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloNevSzulidoOktazon, helper.GetTanuloNevOktAzonSzulDatumList());
                    });
                    break;

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

                        var helper = new ImportExportHelper(connectionType);
                        dropDownColumnSourceDictionary.Add(ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloNeve, helper.GetTanuloList());
                        dropDownColumnSourceDictionary.Add(ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloNeve, helper.GetGondviseloList());

                        dropDownColumnSourceDictionary.Add(ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloRokonsagiFoka, EnumExtensions.GetAdatszotarElemekForTipus(TanevId, GeneratedAdatszotarTipusEnum.RokonsagiFok));
                    });
                    break;

                default:
                    throw new Exception();
            }

            return dropDownColumnSourceDictionary;
        }
    }
}