using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Data;
using System.IO;
using System.Linq;
using System.Runtime.Caching;
using Aspose.Cells;
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;
using Newtonsoft.Json;
using OfficeOpenXml;

namespace Kreta.BusinessLogic.Helpers.ImportExport
{
    public class TantargyfelosztasImportExportHelper : BaseTantargyfelosztasImportExportHelper
    {
        #region Fields

        private readonly string _importObjectCacheKey;

        #endregion Fields

        #region Properties

        public static Dictionary<int, string> ImportHeaderListEgyszeru => new Dictionary<int, string>
        {
            { 00, ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly },
            { 01, ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport },
            { 02, ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy },
            { 03, ImportExportTantargyfelosztasResource.ImportHeaderNameOraszam },
            { 04, ImportExportTantargyfelosztasResource.ImportHeaderNameTanar },
            { 05, ImportExportTantargyfelosztasResource.ImportHeaderNameTulora },
            { 06, ImportExportTantargyfelosztasResource.ImportHeaderNameTtfOraszamKorrekcio },
            { 07, ImportExportTantargyfelosztasResource.ImportHeaderNameNemzetisegiOra },
            { 08, ImportExportTantargyfelosztasResource.ImportHeaderNameMegbizasiOraszam }
        };

        public static Dictionary<int, string> ExportHeaderListEgyszeru => new Dictionary<int, string>(ImportHeaderListEgyszeru);

        public static Dictionary<int, string> ImportHeaderListKereszttablas => new Dictionary<int, string>
        {
            { 00, ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly },
            { 01, ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport },
            { 02, ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy },
            { 03, ImportExportTantargyfelosztasResource.ImportHeaderNameOsszesen }
        };

        public static Dictionary<int, string> ImportHeaderListKereszttablasOsztalyOszlopokkal => new Dictionary<int, string>
        {
            { 00, ImportExportTantargyfelosztasResource.ImportHeaderNameTanar },
            { 01, ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy },
            { 02, ImportExportTantargyfelosztasResource.ImportHeaderNameOsszesen }
        };

        public static Dictionary<int, string> ImportHeaderListFeladatfelosztasExcel => new Dictionary<int, string>
        {
            { 00, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasPedagogusNeve },
            { 01, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasPedagogusMunkakore },
            { 02, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasFoglalkoztatasiJogviszony },
            { 03, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasPedagogusMunkaugyiAdatai },
            { 04, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasPedagogusLekotottOraszam },
            { 05, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasSzakkepzettsegTanithatoTantargyak },
            { 06, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasTantargyEgyebFoglalkozas },
            { 07, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasOraterviOrakEsEgyebFoglalkozasokSzama },
            { 08, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasPedagogusOrakedvezmenye },
            { 09, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasNevelesselOktatassalLekotottOraszam },
            { 10, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasSzakertoiBizottsagiTevekenyseg },
            { 11, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasNevelesiTanacsadas },
            { 12, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasKonduktivPedagogiaiEllatas },
            { 13, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasIskolapszichologiaiOvodapszichologiaiEllatas },
            { 14, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasLogopediaiEllatas },
            { 15, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasGyogytestneveles },
            { 16, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasGyogypedagogiaiTanacsadas },
            { 17, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasKiemeltenTehetsegesGyermekekTanulokGondozasa },
            { 18, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasTovabbtanulasiPalyavalasztasiTanacsadas },
            { 19, ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasOsszesenNemTanoraiCsoportok }
        };

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

        #endregion Constructors

        public static List<List<string>> GetImportDataFromKereszttablasTantargyfelosztasExcel(Stream uploadedFile, Dictionary<int, string> expectedImportHeaderList, out List<string> errorResult)
        {
            errorResult = new List<string>();
            if (uploadedFile is FileStream fileStream)
            {
                var fileInfo = new FileInfo(fileStream.Name);
                if (fileInfo.Extension != ".xlsx")
                {
                    errorResult.Add(ErrorResource.CsakXlsxKiterjesztesuExcelFiletLehetImportalni);
                    return null;
                }
            }

            using (var excelPackage = new ExcelPackage(uploadedFile))
            {
                var importData = new List<List<string>>
                {
                    ImportHeaderListEgyszeru.Select(x => x.Value).ToList()
                };

                ExcelWorksheet excelWorksheet = excelPackage.Workbook.Worksheets.First();
                ExcelCellAddress startExcelCellAddress = excelWorksheet.Dimension.Start;
                ExcelCellAddress endExcelCellAddress = excelWorksheet.Dimension.End;

                int startColumnIndex = 5;
                //Tanárok kiolvasása
                int tanarColumnIndex = startColumnIndex;
                var tanarList = new List<string>();
                while (!string.IsNullOrWhiteSpace(excelWorksheet.Cells[1, tanarColumnIndex].Text.ReplaceMultipleSpacesAndTrim()))
                {
                    tanarList.Add(excelWorksheet.Cells[1, tanarColumnIndex].Text.ReplaceMultipleSpacesAndTrim());
                    tanarColumnIndex++;
                }

                int lastExpectedImportTanarColumnIndex = tanarList.Count + startColumnIndex;

                var excelHeaderList = new Dictionary<int, string>();
                for (int columnIndex = startExcelCellAddress.Column; columnIndex <= startColumnIndex - 1; columnIndex++)
                {
                    excelHeaderList.Add(columnIndex, excelWorksheet.Cells[2, columnIndex].Text.ReplaceMultipleSpacesAndTrim());
                }

                for (int expectedImportHeaderColumnIndex = 0; expectedImportHeaderColumnIndex < startColumnIndex - 1; expectedImportHeaderColumnIndex++)
                {
                    int excelHeaderColumnIndex = expectedImportHeaderColumnIndex + 1;
                    if (!expectedImportHeaderList[expectedImportHeaderColumnIndex].Equals(excelHeaderList[excelHeaderColumnIndex]))
                    {
                        errorResult.Add(string.Format(ErrorResource.RosszImportHeader, excelHeaderColumnIndex, excelHeaderList[excelHeaderColumnIndex], expectedImportHeaderList[expectedImportHeaderColumnIndex]));
                    }
                }

                if (errorResult.Count > 0)
                {
                    return null;
                }

                for (int rowIndex = 3; rowIndex <= endExcelCellAddress.Row; rowIndex++)
                {
                    string osztalyNev = excelWorksheet.Cells[rowIndex, 1].Text.ReplaceMultipleSpacesAndTrim();
                    string csoportNev = excelWorksheet.Cells[rowIndex, 2].Text.ReplaceMultipleSpacesAndTrim();
                    string tantargyNev = excelWorksheet.Cells[rowIndex, 3].Text.ReplaceMultipleSpacesAndTrim();
                    string tuloraszam = 0.ToString();
                    string isOsszevontOraString = CommonResource.Nem;
                    string isNemzetisegiOraString = CommonResource.Nem;
                    string megbizasiOraszamString = 0.ToString();

                    for (int columnIndex = startColumnIndex; columnIndex <= lastExpectedImportTanarColumnIndex; columnIndex++)
                    {
                        var currentTantargyfelosztasDataList = new List<string>();
                        string oraszam = excelWorksheet.Cells[rowIndex, columnIndex].Text.ReplaceMultipleSpacesAndTrim();
                        if (!string.IsNullOrWhiteSpace(oraszam))
                        {
                            string tanarNev = tanarList.ElementAtOrDefault(columnIndex - startColumnIndex) ?? string.Empty;

                            currentTantargyfelosztasDataList.Add(osztalyNev);
                            currentTantargyfelosztasDataList.Add(csoportNev);
                            currentTantargyfelosztasDataList.Add(tantargyNev);
                            currentTantargyfelosztasDataList.Add(oraszam);
                            currentTantargyfelosztasDataList.Add(tanarNev);
                            currentTantargyfelosztasDataList.Add(tuloraszam);
                            currentTantargyfelosztasDataList.Add(isOsszevontOraString);
                            currentTantargyfelosztasDataList.Add(isNemzetisegiOraString);
                            currentTantargyfelosztasDataList.Add(megbizasiOraszamString);

                            importData.Add(currentTantargyfelosztasDataList);
                        }
                    }
                }

                return importData;
            }
        }

        public static List<List<string>> GetImportDataFromKereszttablasTantargyfelosztasOsztalyOszlopokkalExcel(Stream uploadedFile, Dictionary<int, string> expectedImportHeaderList, out List<string> errorResult)
        {
            errorResult = new List<string>();
            if (uploadedFile is FileStream fileStream)
            {
                var fileInfo = new FileInfo(fileStream.Name);
                if (fileInfo.Extension != ".xlsx")
                {
                    errorResult.Add(ErrorResource.CsakXlsxKiterjesztesuExcelFiletLehetImportalni);
                    return null;
                }
            }

            using (var excelPackage = new ExcelPackage(uploadedFile))
            {
                var importData = new List<List<string>>
                {
                    ImportHeaderListEgyszeru.Select(x => x.Value).ToList()
                };

                ExcelWorksheet excelWorksheet = excelPackage.Workbook.Worksheets.First();
                ExcelCellAddress startExcelCellAddress = excelWorksheet.Dimension.Start;
                ExcelCellAddress endExcelCellAddress = excelWorksheet.Dimension.End;

                int startColumnIndex = 4;
                //Osztályok listája
                int osztalyColumnIndex = startColumnIndex;
                var osztalyList = new List<string>();

                while (osztalyColumnIndex <= endExcelCellAddress.Column)
                {
                    osztalyList.Add(excelWorksheet.Cells[1, osztalyColumnIndex].Text.ReplaceMultipleSpacesAndTrim());
                    osztalyColumnIndex++;
                }

                //Csoportok listája
                int csoportColumnIndex = startColumnIndex;
                var csoportList = new List<string>();
                while (csoportColumnIndex <= endExcelCellAddress.Column)
                {
                    csoportList.Add(excelWorksheet.Cells[2, csoportColumnIndex].Text.ReplaceMultipleSpacesAndTrim());
                    csoportColumnIndex++;
                }

                int lastExpectedImportColumnIndex = osztalyColumnIndex >= csoportColumnIndex ? osztalyColumnIndex : csoportColumnIndex;

                var excelHeaderList = new Dictionary<int, string>();
                for (int columnIndex = startExcelCellAddress.Column; columnIndex <= startColumnIndex - 1; columnIndex++)
                {
                    excelHeaderList.Add(columnIndex, excelWorksheet.Cells[3, columnIndex].Text.ReplaceMultipleSpacesAndTrim());
                }

                for (int expectedImportHeaderColumnIndex = 0; expectedImportHeaderColumnIndex < startColumnIndex - 1; expectedImportHeaderColumnIndex++)
                {
                    int excelHeaderColumnIndex = expectedImportHeaderColumnIndex + 1;
                    if (!expectedImportHeaderList[expectedImportHeaderColumnIndex].Equals(excelHeaderList[excelHeaderColumnIndex]))
                    {
                        errorResult.Add(string.Format(ErrorResource.RosszImportHeader, excelHeaderColumnIndex, excelHeaderList[excelHeaderColumnIndex], expectedImportHeaderList[expectedImportHeaderColumnIndex]));
                    }
                }

                if (errorResult.Count > 0)
                {
                    return null;
                }

                for (int rowIndex = 4; rowIndex <= endExcelCellAddress.Row; rowIndex++)
                {
                    string tanarNev = excelWorksheet.Cells[rowIndex, 1].Text.ReplaceMultipleSpacesAndTrim();
                    string tantargyNev = excelWorksheet.Cells[rowIndex, 2].Text.ReplaceMultipleSpacesAndTrim();
                    string tuloraszam = 0.ToString();
                    string isOsszevontOraString = CommonResource.Nem;
                    string isNemzetisegiOraString = CommonResource.Nem;
                    string megbizasiOraszamString = 0.ToString();

                    for (int columnIndex = startColumnIndex; columnIndex <= lastExpectedImportColumnIndex; columnIndex++)
                    {
                        var currentTantargyfelosztasDataList = new List<string>();
                        string oraszam = excelWorksheet.Cells[rowIndex, columnIndex].Text.ReplaceMultipleSpacesAndTrim();
                        if (!string.IsNullOrWhiteSpace(oraszam))
                        {
                            string osztalyNev = osztalyList.ElementAtOrDefault(columnIndex - startColumnIndex) ?? string.Empty;
                            string csoportnev = csoportList.ElementAtOrDefault(columnIndex - startColumnIndex) ?? string.Empty;

                            currentTantargyfelosztasDataList.Add(osztalyNev);
                            currentTantargyfelosztasDataList.Add(csoportnev);
                            currentTantargyfelosztasDataList.Add(tantargyNev);
                            currentTantargyfelosztasDataList.Add(oraszam);
                            currentTantargyfelosztasDataList.Add(tanarNev);
                            currentTantargyfelosztasDataList.Add(tuloraszam);
                            currentTantargyfelosztasDataList.Add(isOsszevontOraString);
                            currentTantargyfelosztasDataList.Add(isNemzetisegiOraString);
                            currentTantargyfelosztasDataList.Add(megbizasiOraszamString);

                            importData.Add(currentTantargyfelosztasDataList);
                        }
                    }
                }

                return importData;
            }
        }

        public static List<List<string>> GetImportDataFromFeladatfelosztasExcel(Stream uploadedFile, Dictionary<int, string> expectedImportHeaderList, out List<string> errorResult)
        {
            errorResult = new List<string>();
            if (uploadedFile is FileStream fileStream)
            {
                var fileInfo = new FileInfo(fileStream.Name);
                if (fileInfo.Extension != ".xlsx")
                {
                    errorResult.Add(ErrorResource.CsakXlsxKiterjesztesuExcelFiletLehetImportalni);
                    return null;
                }
            }

            using (var excelPackage = new ExcelPackage(uploadedFile))
            {
                var importData = new List<List<string>>
                {
                    ImportHeaderListEgyszeru.Select(x => x.Value).ToList()
                };

                ExcelWorksheet excelWorksheet = excelPackage.Workbook.Worksheets.First();
                ExcelCellAddress startExcelCellAddress = excelWorksheet.Dimension.Start;
                ExcelCellAddress endExcelCellAddress = excelWorksheet.Dimension.End;
                int lastExpectedImportColumnIndex = expectedImportHeaderList.Count;

                var excelHeaderList = new Dictionary<int, string>();
                for (int columnIndex = startExcelCellAddress.Column; columnIndex <= lastExpectedImportColumnIndex; columnIndex++)
                {
                    excelHeaderList.Add(columnIndex, excelWorksheet.Cells[4, columnIndex].Text.ReplaceMultipleSpacesAndTrim());
                }

                for (int expectedImportHeaderColumnIndex = 0; expectedImportHeaderColumnIndex < lastExpectedImportColumnIndex; expectedImportHeaderColumnIndex++)
                {
                    int excelHeaderColumnIndex = expectedImportHeaderColumnIndex + 1;
                    if (!expectedImportHeaderList[expectedImportHeaderColumnIndex].Equals(excelHeaderList[excelHeaderColumnIndex]))
                    {
                        errorResult.Add(string.Format(ErrorResource.RosszImportHeader, excelHeaderColumnIndex, excelHeaderList[excelHeaderColumnIndex], expectedImportHeaderList[expectedImportHeaderColumnIndex]));
                    }
                }

                if (errorResult.Count > 0)
                {
                    return null;
                }

                for (int rowIndex = 5; rowIndex <= endExcelCellAddress.Row; rowIndex++)
                {
                    string osztalyNev = string.Empty;
                    string tantargyNev = excelWorksheet.Cells[rowIndex, 7].Text.ReplaceMultipleSpacesAndTrim();
                    string tanarNev = excelWorksheet.Cells[rowIndex, 1].Text.ReplaceMultipleSpacesAndTrim();
                    string tuloraszam = 0.ToString();
                    string isOsszevontOraString = CommonResource.Nem;
                    string isNemzetisegiOraString = CommonResource.Nem;
                    string mebizasiOraszamString = 0.ToString();

                    for (int columnIndex = 11; columnIndex <= lastExpectedImportColumnIndex - 1; columnIndex++)
                    {
                        var currentTantargyfelosztasDataList = new List<string>();
                        string oraszam = excelWorksheet.Cells[rowIndex, columnIndex].Text.ReplaceMultipleSpacesAndTrim();
                        if (!string.IsNullOrWhiteSpace(oraszam))
                        {
                            string csoportNev = expectedImportHeaderList[columnIndex - 1];

                            currentTantargyfelosztasDataList.Add(osztalyNev);
                            currentTantargyfelosztasDataList.Add(csoportNev);
                            currentTantargyfelosztasDataList.Add(tantargyNev);
                            currentTantargyfelosztasDataList.Add(oraszam);
                            currentTantargyfelosztasDataList.Add(tanarNev);
                            currentTantargyfelosztasDataList.Add(tuloraszam);
                            currentTantargyfelosztasDataList.Add(isOsszevontOraString);
                            currentTantargyfelosztasDataList.Add(isNemzetisegiOraString);
                            currentTantargyfelosztasDataList.Add(mebizasiOraszamString);

                            importData.Add(currentTantargyfelosztasDataList);
                        }
                    }
                }

                return importData;
            }
        }

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

            SetNemImportalhatoSorokByValidation(importCo);

            SetOraszamSumAndRemoveDuplicates(importCo);

            //NOTE: Azért van szükség Dictionary-kre, mert így sokkal gyorsabb a keresés!
            Dictionary<string, ImportItemCompareCo> tantargyCompareHashImportItemCompareCoDictionary = GetTantargyCompareHashImportItemCompareCoDictionary();
            Dictionary<string, ImportItemCompareCo> osztalyCompareHashImportItemCompareCoDictionary = GetOsztalyCompareHashImportItemCompareCoDictionary();
            Dictionary<string, ImportItemCompareCo> csoportCompareHashImportItemCompareCoDictionary = GetCsoportCompareHashImportItemCompareCoDictionary();
            Dictionary<string, ImportItemCompareCo> tantargyfelosztasCompareHashImportItemCompareCoDictionary = GetTantargyfelosztasCompareHashImportItemCompareCoDictionary(importCo.GetBaseImportItemCoList());
            foreach (TantargyfelosztasImportItemCo importItem in importCo.MainImportItemList)
            {
                SetOperationTantargy(importItem, tantargyCompareHashImportItemCompareCoDictionary);
                SetOperationOsztaly(importItem, osztalyCompareHashImportItemCompareCoDictionary);
                SetOperationCsoport(importItem, csoportCompareHashImportItemCompareCoDictionary);
                SetOperationTantargyfelosztas(importItem, tantargyfelosztasCompareHashImportItemCompareCoDictionary, importCo);
            }

            //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 osztalyCsoportImportJsonItemList = new List<OsztalyCsoportImportJsonItemCo>();
            var osztalyImportJsonItemList = new List<OsztalyImportJsonItemCo>();
            var csoportImportJsonItemList = new List<CsoportImportJsonItemCo>();
            var mainImportJsonItemList = new List<TantargyfelosztasImportJsonItemCo>();
            foreach (TantargyfelosztasImportItemCo importItem in importCo.MainImportItemList)
            {
                if (tantargyImportJsonItemList.All(x => x.Nev.ToComparableString() != importItem.TantargyNev.ToComparableString()) &&
                    importItem.OperationTantargy == (int)ImportItemOperationEnum.Insert)
                {
                    tantargyImportJsonItemList.Add(new TantargyImportJsonItemCo(importItem, TanevId, IntezmenyId, FelhasznaloId));
                }

                var osztalyNevToCompare = importItem.OsztalyNev?.ToComparableString();
                if (!string.IsNullOrWhiteSpace(osztalyNevToCompare) &&
                    !osztalyImportJsonItemList.Select(x => x.OsztalyCsoportNev.ToComparableString()).Contains(osztalyNevToCompare) &&
                    importItem.OperationOsztaly == (int)ImportItemOperationEnum.Insert)
                {
                    osztalyImportJsonItemList.Add(new OsztalyImportJsonItemCo(importItem, TanevId, IntezmenyId, FelhasznaloId));
                    osztalyCsoportImportJsonItemList.Add(new OsztalyCsoportImportJsonItemCo(importItem, importItem.OperationOsztaly, importItem.OsztalyNev, importCo.FeladatellatasiHelyId, importCo.FeladatKategoriaId, TanevId, IntezmenyId, FelhasznaloId));
                }

                var csoportNevToCompare = importItem.CsoportNev?.ToComparableString();
                if (!string.IsNullOrWhiteSpace(csoportNevToCompare) &&
                    !csoportImportJsonItemList.Select(x => x.OsztalyCsoportNev.ToComparableString()).Contains(csoportNevToCompare) &&
                    importItem.OperationCsoport == (int)ImportItemOperationEnum.Insert)
                {
                    csoportImportJsonItemList.Add(new CsoportImportJsonItemCo(importItem, TanevId, IntezmenyId, FelhasznaloId));
                    osztalyCsoportImportJsonItemList.Add(new OsztalyCsoportImportJsonItemCo(importItem, importItem.OperationCsoport, importItem.CsoportNev, importCo.FeladatellatasiHelyId, importCo.FeladatKategoriaId, TanevId, IntezmenyId, FelhasznaloId));
                }

                //NOTE: Az egyik ".Value"-s érték sem lehet null, mert ide már csak olyan elem jön be, aminek jók az értékei!
                mainImportJsonItemList.Add(
                    new TantargyfelosztasImportJsonItemCo(
                        importItem,
                        importItem.CompareHash,
                        importItem.OraszamSum,
                        importItem.Tuloraszam.Value,
                        importItem.IsOsszevontOra.Value,
                        importItem.IsNemzetisegiOra.Value,
                        importItem.MegbizasiOraszam.Value, TanevId, IntezmenyId, FelhasznaloId
                    )
                );
            }

            importCo.TantargyImportJsonItemList = tantargyImportJsonItemList;
            importCo.OsztalyCsoportImportJsonItemList = osztalyCsoportImportJsonItemList;
            importCo.OsztalyImportJsonItemList = osztalyImportJsonItemList;
            importCo.CsoportImportJsonItemList = csoportImportJsonItemList;
            importCo.MainImportJsonItemList = mainImportJsonItemList;

            ImportCo = importCo;
        }

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

            //NOTE: Azokat a sorokat, amelyek hibásak beletesszük a NemImportalhatoItemList-be!
            foreach (TantargyfelosztasImportItemCo 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 SetOraszamSumAndRemoveDuplicates(TantargyfelosztasImportCo importCo)
        {
            var mainImportItemList = new List<TantargyfelosztasImportItemCo>();
            foreach (TantargyfelosztasImportItemCo mainImportItem in importCo.MainImportItemList)
            {
                //NOTE: Az Oraszam.Value nem lehet null, mert ide már csak olyan elem jön be, aminek jók az értékei!
                double oraszam = mainImportItem.Oraszam.Value;
                if (mainImportItemList.Any(x => x.CompareHash == mainImportItem.CompareHash))
                {
                    mainImportItemList.Single(x => x.CompareHash == mainImportItem.CompareHash).OraszamSum += oraszam;
                }
                else
                {
                    mainImportItem.OraszamSum = oraszam;
                    mainImportItemList.Add(mainImportItem);
                }
            }

            importCo.MainImportItemList = mainImportItemList;
        }

        private static void SetOperationTantargyfelosztas(TantargyfelosztasImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary, TantargyfelosztasImportCo importCo)
        {
            int importMuvelet = importCo.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 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);
                    }
                }
            }
        }

        public TantargyfelosztasImportCo GetImportCoFromImportData(List<List<string>> importData, int tantargyfelosztasImportTipus, int feladatellatasiHelyId)
        {
            List<AlkalmazottItemCo> tanarCoList = null;
            List<OsztalyItemCo> osztalyCoList = null;
            List<CsoportItemCo> csoportCoList = null;
            FeladatEllatasiHelyCO feladatellatasiHelyCo = null;
            int feladatKategoriaId = -1;
            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
            {
                tanarCoList = new AlkalmazottHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetAlkalmazottCoList();
                osztalyCoList = new OsztalyHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetOsztalyCoList();
                csoportCoList = new CsoportHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetCsoportCoList();
                feladatellatasiHelyCo = new FeladatEllatasiHelyHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetFeladatEllatasiHelyAdatok(feladatellatasiHelyId);
                feladatKategoriaId = new FeladatEllatasiHelyHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetFeladatKategoriaId(feladatellatasiHelyId);
            });
            var importCo = new TantargyfelosztasImportCo
            {
                TantargyfelosztasImportTipus = tantargyfelosztasImportTipus,
                TanarCoList = tanarCoList,
                OsztalyCoList = osztalyCoList,
                CsoportCoList = csoportCoList,
                FeladatellatasiHelyId = feladatellatasiHelyId,
                FeladatellatasiHelyCo = feladatellatasiHelyCo,
                FeladatKategoriaId = feladatKategoriaId
            };

            string csoportNevPrefix = $"{feladatellatasiHelyCo.MukodesiHelyNev} - {feladatellatasiHelyCo.OktatasiNevelesiFeladatNev} - ";

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

                    OsztalyNevImportData = importDataRow[ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly)],
                    CsoportNevImportData = importDataRow[ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport)],
                    TantargyNevImportData = importDataRow[ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy)],
                    OraszamImportData = importDataRow[ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameOraszam)],
                    TanarNevImportData = importDataRow[ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTanar)],
                    TuloraImportData = importDataRow[ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTulora)],
                    TtfOraszamKorrekcioImportData = importDataRow[ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTtfOraszamKorrekcio)],
                    NemzetisegiOraImportData = importDataRow[ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameNemzetisegiOra)],
                    MegbizasiOraszamImportData = importDataRow[ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameMegbizasiOraszam)]
                };
                if (!string.IsNullOrWhiteSpace(importItemCo.TanarNev))
                {
                    var tanarList = tanarCoList.Where(x =>
                        x.FelhasznaloNyomtatasiNevComparableString == importItemCo.TanarNev?.ToComparableString() &&
                        (!importItemCo.TanarSzuletesiIdo.HasValue || importItemCo.TanarSzuletesiIdo == x.FelhasznaloSzuletesiIdo)).ToList();
                    if (tanarList.Count == 1)
                    {
                        importItemCo.TanarId = tanarList.Single().Id;
                    }
                }

                int? csoportTipusId;
                if (tantargyfelosztasImportTipus == (int)TantargyfelosztasImportTipusEnum.FeladatfelosztasImport)
                {
                    if (importItemCo.CsoportNev == ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasSzakertoiBizottsagiTevekenyseg)
                    {
                        csoportTipusId = (int)CsoportTipusEnum.szakertoi_bizottsagi_tevekenyseg;
                    }
                    else if (importItemCo.CsoportNev == ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasNevelesiTanacsadas)
                    {
                        csoportTipusId = (int)CsoportTipusEnum.nevelesi_tanacsadas;
                    }
                    else if (importItemCo.CsoportNev == ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasKonduktivPedagogiaiEllatas)
                    {
                        csoportTipusId = (int)CsoportTipusEnum.konduktiv_pedagogiai_ellatas;
                    }
                    else if (importItemCo.CsoportNev == ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasIskolapszichologiaiOvodapszichologiaiEllatas)
                    {
                        csoportTipusId = (int)CsoportTipusEnum.iskolapszichologiai_ovodapszichologiai_ellatas;
                    }
                    else if (importItemCo.CsoportNev == ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasLogopediaiEllatas)
                    {
                        csoportTipusId = (int)CsoportTipusEnum.logopediai_ellatas;
                    }
                    else if (importItemCo.CsoportNev == ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasGyogytestneveles)
                    {
                        csoportTipusId = (int)CsoportTipusEnum.gyogytestneveles;
                    }
                    else if (importItemCo.CsoportNev == ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasGyogypedagogiaiTanacsadas)
                    {
                        csoportTipusId = (int)CsoportTipusEnum.gyogypedagogiai_tanacsadas_korai_fejlesztes_es_gondozas;
                    }
                    else if (importItemCo.CsoportNev == ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasKiemeltenTehetsegesGyermekekTanulokGondozasa)
                    {
                        csoportTipusId = (int)CsoportTipusEnum.kiemelten_tehetseges_gyermekek_tanulok_gondozasa;
                    }
                    else if (importItemCo.CsoportNev == ImportExportTantargyfelosztasResource.ImportHeaderNameFeladatfelosztasTovabbtanulasiPalyavalasztasiTanacsadas)
                    {
                        csoportTipusId = (int)CsoportTipusEnum.tovabbtanulasi_palyavalasztasi_tanacsadas;
                    }
                    else
                    {
                        csoportTipusId = null;
                    }

                    //NOTE: Beállítjuk a csoportnévnek a feladatellátási hely nevét prefixként, amikor feladatfelosztást importálunk!
                    importItemCo.CsoportNevImportData = $"{csoportNevPrefix}{importItemCo.CsoportNevImportData}";
                }
                else
                {
                    csoportTipusId = (int)CsoportTipusEnum.na;
                }

                importItemCo.CsoportTipusId = csoportTipusId;

                string tantargyMd5HashInput = importItemCo.TantargyNev?.ToComparableString();
                importItemCo.CompareHashTantargy = ImportExportHelper.GetMd5Hash(tantargyMd5HashInput);

                if (!string.IsNullOrWhiteSpace(importItemCo.OsztalyNev))
                {
                    string osztalyMd5HashInput = importItemCo.OsztalyNev.ToComparableString();
                    importItemCo.CompareHashOsztaly = ImportExportHelper.GetMd5Hash(osztalyMd5HashInput);
                }

                if (!string.IsNullOrWhiteSpace(importItemCo.CsoportNev))
                {
                    string csoportMd5HashInput = importItemCo.CsoportNev.ToComparableString();
                    importItemCo.CompareHashCsoport = ImportExportHelper.GetMd5Hash(csoportMd5HashInput);
                }

                string tantargyfelosztasMd5HashInput =
                    importItemCo.OsztalyCsoportNev?.ToComparableString() +
                    importItemCo.TantargyNev?.ToComparableString() +
                    importItemCo.TanarNev?.ToComparableString();
                if (importItemCo.TanarSzuletesiIdo.HasValue)
                {
                    tantargyfelosztasMd5HashInput += importItemCo.TanarSzuletesiIdoString?.ToComparableString();
                }

                importItemCo.CompareHash = ImportExportHelper.GetMd5Hash(tantargyfelosztasMd5HashInput);

                importCo.MainImportItemList.Add(importItemCo);

                lineNumber++;
            }

            return importCo;
        }

        public MemoryStream GetTemplate(bool isSzakkepzo = false, bool isDualisEnabled = false)
        {
            var dropDownColumnSourceDictionary = GetDefaultDropDownColumnSourceDictionary(isFromSzervezet: isDualisEnabled, isSzakkepzo: isSzakkepzo);

            MemoryStream memoryStream = ImportExportHelper.GetTemplate(ImportExportTantargyfelosztasResource.ImportDefaultSheetName, ImportHeaderListEgyszeru, dropDownColumnSourceDictionary);

            return memoryStream;
        }

        public MemoryStream GetExport()
        {
            var dropDownColumnSourceDictionary = GetDefaultDropDownColumnSourceDictionary();

            DataSet tantargyfelosztasDataSet = null;
            List<AlkalmazottItemCo> tanarCoList = null;
            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
            {
                tantargyfelosztasDataSet = dalHandler.TantargyFelosztas(GridParameters).GetTantargyFelosztasokKereses(tanevId: TanevId);
                tanarCoList = new AlkalmazottHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetAlkalmazottCoList();
            });

            using (var workbook = new Workbook())
            {
                var worksheet = ImportExportHelper.GetWorksheetsWithDropDownFormula(workbook, ImportExportTantargyfelosztasResource.ImportDefaultSheetName, ExportHeaderListEgyszeru, dropDownColumnSourceDictionary);

                int rowNumber = 1;
                foreach (DataRow dataRow in tantargyfelosztasDataSet.Tables[0].AsEnumerable())
                {
                    if (SDAConvert.ToBoolean(dataRow["IsOsztaly"], false))
                    {
                        worksheet.Cells[rowNumber, ExportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly)].Value = SDAConvert.ToString(dataRow["OsztalyCsoport"]) ?? string.Empty;
                        worksheet.Cells[rowNumber, ExportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport)].Value = string.Empty;
                    }
                    else
                    {
                        worksheet.Cells[rowNumber, ExportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly)].Value = SDAConvert.ToBoolean(dataRow["IsOsztalyBontottCsoport"], false) ? SDAConvert.ToString(dataRow["OsztalyBontottCsoportNev"]) : string.Empty;
                        worksheet.Cells[rowNumber, ExportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport)].Value = SDAConvert.ToString(dataRow["OsztalyCsoport"]) ?? string.Empty;
                    }

                    worksheet.Cells[rowNumber, ExportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy)].Value = SDAConvert.ToString(dataRow["Tantargy"]) ?? string.Empty;
                    worksheet.Cells[rowNumber, ExportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameOraszam)].Value = SDAConvert.ToDecimal(dataRow["Oraszam"]).ToString();

                    //NOTE: Erre azért van szükség, ha több egyforma nevű tanár szerepel az adatbázisban, akkor zárójelben mögé tesszük a születési dátumát az export-ban, hogy meg tudjuk őket különböztetni!
                    string tanarNev = SDAConvert.ToString(dataRow["Tanar"]) ?? string.Empty;
                    DateTime tanarSzuletesiIdo = SDAConvert.ToDateTime(dataRow["TanarSzuletesiIdo"]).Value;
                    if (tanarCoList.Count(x => x.FelhasznaloNyomtatasiNevComparableString == tanarNev.ToComparableString()) > 1)
                    {
                        var tanarSzuletesiIdoString = tanarSzuletesiIdo.ToString(Constants.ToStringPattern.HungarianDate);
                        tanarNev += $" ({tanarSzuletesiIdoString})";
                    }

                    worksheet.Cells[rowNumber, ExportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTanar)].Value = tanarNev;

                    worksheet.Cells[rowNumber, ExportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTulora)].Value = SDAConvert.ToDecimal(dataRow["TuloraSzam"]).ToString();
                    worksheet.Cells[rowNumber, ExportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTtfOraszamKorrekcio)].Value = SDAConvert.ToBooleanFromTF(dataRow["OsszevontOra"]).GetDisplayName();
                    worksheet.Cells[rowNumber, ExportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameNemzetisegiOra)].Value = SDAConvert.ToBooleanFromTF(dataRow["NemzetisegiOra"]).GetDisplayName();
                    worksheet.Cells[rowNumber, ExportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameMegbizasiOraszam)].Value = SDAConvert.ToDecimal(dataRow["MegbizasiOraszam"]).ToString();

                    rowNumber++;
                }

                MemoryStream memoryStream = SimpleExportLogic.GetWorkbookMemoryStream(workbook);
                return memoryStream;
            }
        }

        public MemoryStream GetNemImportalhatoSorokExport()
        {
            var dropDownColumnSourceDictionary = GetDefaultDropDownColumnSourceDictionary();

            using (var workbook = new Workbook())
            {
                var worksheet = ImportExportHelper.GetWorksheetsWithDropDownFormula(workbook, ImportExportTantargyfelosztasResource.ImportDefaultSheetName, ImportHeaderListEgyszeru, dropDownColumnSourceDictionary);

                int rowNumber = 1;
                foreach (TantargyfelosztasImportItemCo co in ImportCo.NemImportalhatoItemList)
                {
                    worksheet.Cells[rowNumber, ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly)].Value = co.OsztalyNevImportData;
                    worksheet.Cells[rowNumber, ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport)].Value = co.CsoportNevImportData;
                    worksheet.Cells[rowNumber, ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy)].Value = co.TantargyNevImportData;
                    worksheet.Cells[rowNumber, ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameOraszam)].Value = co.OraszamImportData;
                    worksheet.Cells[rowNumber, ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTanar)].Value = co.TanarNevImportData;
                    worksheet.Cells[rowNumber, ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTulora)].Value = co.TuloraImportData;
                    worksheet.Cells[rowNumber, ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTtfOraszamKorrekcio)].Value = co.TtfOraszamKorrekcioImportData;
                    worksheet.Cells[rowNumber, ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameNemzetisegiOra)].Value = co.NemzetisegiOraImportData;
                    worksheet.Cells[rowNumber, ImportHeaderListEgyszeru.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameMegbizasiOraszam)].Value = co.MegbizasiOraszamImportData;

                    Cell errorCell = worksheet.Cells[rowNumber, ImportHeaderListEgyszeru.Count];
                    errorCell.Value = string.Join(Environment.NewLine, co.ErrorList);
                    errorCell.SetTextWrap();

                    rowNumber++;
                }

                var sheetCodeNameAndColumnsToWrapIndexDictionary = new Dictionary<string, List<int>>
                {
                    { workbook.Worksheets[0].CodeName, new List<int> { ImportHeaderListEgyszeru.Count } }
                };
                MemoryStream memoryStream = SimpleExportLogic.GetWorkbookMemoryStream(workbook, sheetCodeNameAndColumnsToWrapIndexDictionary);
                return memoryStream;
            }
        }

        public void Import(object importJsonObject, int importMuvelet)
        {
            string importJson = JsonConvert.SerializeObject(importJsonObject);
            bool isTorles = importMuvelet == (int)ImportMuveletEnum.DeleteAndInsert;
            Dal.CustomConnection.Run(ConnectionType, dalHandler => dalHandler.ImportExportDal().TantargyfelosztasImport(IntezmenyId, TanevId, FelhasznaloId, importJson, isTorles));
        }

        private Dictionary<string, IList<string>> GetDefaultDropDownColumnSourceDictionary(bool isFromSzervezet = false, bool isSzakkepzo = false)
        {
            //NOTE: Create dropdown lists
            var logicalColumnDictionary = new Dictionary<string, IList<string>>
            {
                { ImportExportTantargyfelosztasResource.ImportHeaderNameTtfOraszamKorrekcio, EnumExtensions.GetEnumDisplayNameList<IgenNemEnum>(TanevId) },
                { ImportExportTantargyfelosztasResource.ImportHeaderNameNemzetisegiOra, EnumExtensions.GetEnumDisplayNameList<IgenNemEnum>(TanevId) }
            };
            var dropDownColumnSourceDictionary = new Dictionary<string, IList<string>>(logicalColumnDictionary);

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

                dropDownColumnSourceDictionary.Add(ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly, helper.GetOsztalyList());
                dropDownColumnSourceDictionary.Add(ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport, helper.GetCsoportList());
                dropDownColumnSourceDictionary.Add(ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy, helper.GetTantargyList(isFromSzervezet: isFromSzervezet, isSzakkepzo: isSzakkepzo));
                dropDownColumnSourceDictionary.Add(ImportExportTantargyfelosztasResource.ImportHeaderNameTanar, helper.GetTanarList(true));
            });

            return dropDownColumnSourceDictionary;
        }
    }
}