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.Helpers.SystemSettings;
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.Enums.ManualEnums.SystemSettings;
using Kreta.Resources;
using Newtonsoft.Json;
using Cache = Kreta.Core.Cache;

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

        private readonly string _importObjectCacheKey;

        #endregion Fields

        #region Properties

        public static Dictionary<int, string> ImportHeaderList =>
            new Dictionary<int, string>
            {
                { 00, ImportExportOrarendResource.ImportHeaderNameHetirend },
                { 01, ImportExportOrarendResource.ImportHeaderNameNap },
                { 02, ImportExportOrarendResource.ImportHeaderNameOra },
                { 03, ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly },
                { 04, ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport },
                { 05, ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy },
                { 06, ImportExportTantargyfelosztasResource.ImportHeaderNameTanar },
                { 07, ImportExportOrarendResource.ImportHeaderNameHelyiseg }
            };

        public static Dictionary<int, string> ImportHeaderListNapirend =>
            new Dictionary<int, string>
            {
                { 00, ImportExportOrarendResource.ImportHeaderNameHetirend },
                { 01, ImportExportOrarendResource.ImportHeaderNameNap },
                { 02, ImportExportOrarendResource.ImportHeaderNameFoglalkozasKezdete },
                { 03, ImportExportOrarendResource.ImportHeaderNameFoglalkozasVege },
                { 04, ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly },
                { 05, ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport },
                { 06, ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy },
                { 07, ImportExportTantargyfelosztasResource.ImportHeaderNameTanar },
                { 08, ImportExportOrarendResource.ImportHeaderNameHelyiseg }
            };

        public static Dictionary<int, string> ImportHeaderListOraErvenyessegiIdovel =>
            new Dictionary<int, string>
            {
                { 00, ImportExportOrarendResource.ImportHeaderNameOraErvenyessegKezdete },
                { 01, ImportExportOrarendResource.ImportHeaderNameOraErvenyessegVege },
                { 02, ImportExportOrarendResource.ImportHeaderNameHetirend },
                { 03, ImportExportOrarendResource.ImportHeaderNameNap },
                { 04, ImportExportOrarendResource.ImportHeaderNameOra },
                { 05, ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly },
                { 06, ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport },
                { 07, ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy },
                { 08, ImportExportTantargyfelosztasResource.ImportHeaderNameTanar },
                { 09, ImportExportOrarendResource.ImportHeaderNameHelyiseg }
            };

        public static Dictionary<int, string> ImportHeaderListNapirendOraErvenyessegiIdovel =>
            new Dictionary<int, string>
            {
                { 00, ImportExportOrarendResource.ImportHeaderNameOraErvenyessegKezdete },
                { 01, ImportExportOrarendResource.ImportHeaderNameOraErvenyessegVege },
                { 02, ImportExportOrarendResource.ImportHeaderNameHetirend },
                { 03, ImportExportOrarendResource.ImportHeaderNameNap },
                { 04, ImportExportOrarendResource.ImportHeaderNameFoglalkozasKezdete },
                { 05, ImportExportOrarendResource.ImportHeaderNameFoglalkozasVege },
                { 06, ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly },
                { 07, ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport },
                { 08, ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy },
                { 09, ImportExportTantargyfelosztasResource.ImportHeaderNameTanar },
                { 10, ImportExportOrarendResource.ImportHeaderNameHelyiseg }
            };

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

        #endregion Constructors

        public void SetImportCo(OrarendImportFileUploadCo orarendImportFileUploadCo, bool isAktivTanev)
        {
            OrarendImportCo importCo = GetImportCoFromImportData(orarendImportFileUploadCo, isAktivTanev);
            importCo.OrarendImportMuvelet = orarendImportFileUploadCo.OrarendImportMuvelet;
            importCo.FeladatellatasiHelyId = orarendImportFileUploadCo.FeladatellatasiHelyId;
            importCo.MukodesiHelyId = new FeladatEllatasiHelyHelper(ConnectionType).GetMukodesiHelyIdByFeladatellatasiHelyId(orarendImportFileUploadCo.FeladatellatasiHelyId);

            SetNemImportalhatoSorokByValidation(importCo, isAktivTanev);

            //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 = null;
            if (orarendImportFileUploadCo.IsTtfImport)
            {
                tantargyfelosztasCompareHashImportItemCompareCoDictionary = GetTantargyfelosztasCompareHashImportItemCompareCoDictionary(importCo.GetBaseImportItemCoList());
            }

            Dictionary<string, ImportItemCompareCo> teremCompareHashImportItemCompareCoDictionary = GetTeremCompareHashImportItemCompareCoDictionary();
            foreach (OrarendImportItemCo importItem in importCo.MainImportItemList)
            {
                SetOperationTantargy(importItem, tantargyCompareHashImportItemCompareCoDictionary);
                SetOperationOsztaly(importItem, osztalyCompareHashImportItemCompareCoDictionary);
                SetOperationCsoport(importItem, csoportCompareHashImportItemCompareCoDictionary);
                if (orarendImportFileUploadCo.IsTtfImport)
                {
                    SetOperationTantargyfelosztas(importItem, tantargyfelosztasCompareHashImportItemCompareCoDictionary, orarendImportFileUploadCo.OrarendImportMuvelet, importCo.OrarendiElemekRogzitesenekElofeltetele);
                }

                SetOperationTerem(importItem, teremCompareHashImportItemCompareCoDictionary);
                SetOperationOrarend(importItem);
            }

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

            List<string> vegzosOsztalyCsoportNevComperableList =
                new OsztalyCsoportHelper(ConnectionType)
                    .GetOsztalyCsoportCoList()
                    .Where(x => x.IsVegzosEvfolyam)
                    .Select(x => x.NevComparableString)
                    .ToList();

            int feladatKategoriaId = new FeladatEllatasiHelyHelper(ConnectionType).GetFeladatKategoriaId(orarendImportFileUploadCo.FeladatellatasiHelyId);
            var tantargyImportJsonItemList = new List<TantargyImportJsonItemCo>();
            var osztalyCsoportImportJsonItemList = new List<OsztalyCsoportImportJsonItemCo>();
            var osztalyImportJsonItemList = new List<OsztalyImportJsonItemCo>();
            var csoportImportJsonItemList = new List<CsoportImportJsonItemCo>();
            var tantargyfelosztasImportJsonItemList = new List<TantargyfelosztasImportJsonItemCo>();
            var teremImportJsonItemList = new List<TeremImportJsonItemCo>();
            var mainImportJsonItemList = new List<OrarendImportJsonItemCo>();

            var csoportTipusOraPercDict = new AdatszotarHelper(ConnectionType).GetCsoportTipusList().ToDictionary(x => x.Id, x => x.OraPerc);

            foreach (OrarendImportItemCo 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, 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, feladatKategoriaId, TanevId, IntezmenyId, FelhasznaloId));
                }

                if (orarendImportFileUploadCo.IsTtfImport)
                {
                    if (tantargyfelosztasImportJsonItemList.All(x => x.CompareHash != importItem.CompareHashTantargyfelosztas) &&
                        (importItem.OperationTantargyfelosztas == (int)ImportItemOperationEnum.Insert
                            || (importItem.OperationTantargyfelosztas == (int)ImportItemOperationEnum.Update && importCo.OrarendiElemekRogzitesenekElofeltetele == SystemSettingsOrarendiElemekRogzitesenekElofelteteleEnum.NemNullasTTF)
                        ))
                    {
                        List<OrarendImportItemCo> ttfhezTartozoOrarendImportItemCoList = importCo.MainImportItemList.Where(x => x.CompareHashTantargyfelosztas == importItem.CompareHashTantargyfelosztas).ToList();
                        double oraszam = GetOraszam(importItem, ttfhezTartozoOrarendImportItemCoList, csoportTipusOraPercDict);
                        tantargyfelosztasImportJsonItemList.Add(
                            new TantargyfelosztasImportJsonItemCo(
                                importItem,
                                importItem.CompareHashTantargyfelosztas,
                                oraszam,
                                0,
                                false,
                                false,
                                0, TanevId, IntezmenyId, FelhasznaloId
                            )
                            {
                                Operation = importItem.OperationTantargyfelosztas,
                            }
                        );
                    }
                }

                if (teremImportJsonItemList.All(x => x.Nev.ToComparableString() != importItem.TeremNev.ToComparableString()) &&
                    importItem.OperationTerem == (int)ImportItemOperationEnum.Insert)
                {
                    teremImportJsonItemList.Add(new TeremImportJsonItemCo(importItem, importCo.MukodesiHelyId, TanevId, IntezmenyId, FelhasznaloId));
                }

                bool isVegzos = !string.IsNullOrWhiteSpace(osztalyNevToCompare) && vegzosOsztalyCsoportNevComperableList.Contains(osztalyNevToCompare) ||
                                !string.IsNullOrWhiteSpace(csoportNevToCompare) && vegzosOsztalyCsoportNevComperableList.Contains(csoportNevToCompare);
                mainImportJsonItemList.Add(new OrarendImportJsonItemCo(importItem, orarendImportFileUploadCo, isVegzos, ConnectionType));
            }

            importCo.TantargyImportJsonItemList = tantargyImportJsonItemList;
            importCo.OsztalyCsoportImportJsonItemList = osztalyCsoportImportJsonItemList;
            importCo.OsztalyImportJsonItemList = osztalyImportJsonItemList;
            importCo.CsoportImportJsonItemList = csoportImportJsonItemList;
            importCo.TantargyfelosztasImportJsonItemList = tantargyfelosztasImportJsonItemList;
            importCo.TeremImportJsonItemList = teremImportJsonItemList;
            importCo.MainImportJsonItemList = mainImportJsonItemList;

            ImportCo = importCo;
        }

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

            //NOTE: Azokat a sorokat, amelyek hibásak beletesszük a NemImportalhatoItemList-be!
            foreach (OrarendImportItemCo 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 SetOperationTantargyfelosztas(OrarendImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary, int orarendImportMuvelet, SystemSettingsOrarendiElemekRogzitesenekElofelteteleEnum orarendiElemekRogzitesenekElofeltetele)
        {
            var compareHash = importItem.CompareHashTantargyfelosztas;
            //NOTE: Ha nem találtunk egyezést, akkor mindeképpen Insert!
            if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHash))
            {
                importItem.OperationTantargyfelosztas = (int)ImportItemOperationEnum.Insert;
            }
            //NOTE: Ha találtunk egyezést, akkor...
            else
            {
                var 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 (orarendImportMuvelet == (int)OrarendImportMuveletEnum.DeleteAndInsert && importItemCompareCo.Importalt)
                {
                    importItem.OperationTantargyfelosztas = (int)ImportItemOperationEnum.Insert;
                }

                if ((orarendImportMuvelet == (int)OrarendImportMuveletEnum.UpdateAndInsert
                     || orarendImportMuvelet == (int)OrarendImportMuveletEnum.Insert)
                    && orarendiElemekRogzitesenekElofeltetele == SystemSettingsOrarendiElemekRogzitesenekElofelteteleEnum.NemNullasTTF)
                {
                    importItem.OperationTantargyfelosztas = (int)ImportItemOperationEnum.Update;
                    importItem.Id = importItemCompareCo.Id;
                }
            }
        }

        private static void SetOperationTerem(OrarendImportItemCo importItem, Dictionary<string, ImportItemCompareCo> compareHashImportItemCompareCoDictionary)
        {
            var compareHashTerem = importItem.CompareHashTerem;
            if (!string.IsNullOrWhiteSpace(compareHashTerem))
            {
                //NOTE: Ha nem találtunk egyezést, akkor Insert!
                if (!compareHashImportItemCompareCoDictionary.ContainsKey(compareHashTerem))
                {
                    importItem.OperationTerem = (int)ImportItemOperationEnum.Insert;
                }
            }
        }

        private static void SetOperationOrarend(OrarendImportItemCo importItem)
        {
            //NOTE: Minden esetben Insert!
            importItem.Operation = (int)ImportItemOperationEnum.Insert;
        }

        private Dictionary<string, ImportItemCompareCo> GetTeremCompareHashImportItemCompareCoDictionary()
        {
            List<TeremItemCo> coList = new TeremHelper(ConnectionType).GetTeremCoList();

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

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

            return compareHashImportItemCompareCoDictionary;
        }

        public OrarendImportCo GetImportCoFromImportData(OrarendImportFileUploadCo orarendImportFileUploadCo, bool isAktivTanev)
        {
            List<AlkalmazottItemCo> tanarCoList = null;
            List<OsztalyItemCo> osztalyCoList = null;
            List<CsoportItemCo> csoportCoList = null;
            List<TeremItemCo> teremCoList = null;
            List<TanevrendOsztalyokkalNaptipusTulajdonsagokkalCO> tanevRendjeNaptipusTulajdonsagokkalCOs = null;
            List<string> tantargyNincsBeloleOra = null;
            List<TantargyfelosztasItemCo> tantargyfelosztasCoList = null;
            SystemSettingsOrarendiElemekRogzitesenekElofelteteleEnum orarendiElemekRogzitesenekElofeltetele = SystemSettingsOrarendiElemekRogzitesenekElofelteteleEnum.NincsTTF;
            DataSet hetirendTipusDataSet = null;
            int foglalkozasokRogziteseHetvegereId = 0;
            int csengetesiRendId = 0;
            List<CsengetesiRendOraCO> csengetesiRendOraCoList = null;
            bool isOravegeBeallitasOrahosszAlapjan = false;
            Dictionary<int, int?> csoportTipusOraPercDict = null;
            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();
                teremCoList = new TeremHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetTeremCoList();
                tanevRendjeNaptipusTulajdonsagokkalCOs = new TanevrendHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetTanevRendjeNaptipusTulajdonsagokkal();
                hetirendTipusDataSet = dalHandler.AdatszotarDAL().GetAdatszotarLathatoElemek(GeneratedAdatszotarTipusEnum.HetiRendTipus, TanevId);

                var systemSettingsHelper = new SystemSettingsHelper(new DalHandlerConnectionType(ConnectionType, dalHandler));

                foglalkozasokRogziteseHetvegereId = (int)systemSettingsHelper.GetSystemSettingValue<FoglalkozasokRogziteseHetvegere>(RendszerBeallitasTipusEnum.Foglalkozasok_Rogzitese_Hetvegere);
                csengetesiRendId = new CsengetesiRendHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetAktivCsengetesiRendId();
                csengetesiRendOraCoList = new CsengetesiRendOrakHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetCsengetesiRendOraCoList(csengetesiRendId);
                isOravegeBeallitasOrahosszAlapjan = systemSettingsHelper.GetSystemSettingValue<bool>(RendszerBeallitasTipusEnum.Orarendi_Elem_Hossz);
                csoportTipusOraPercDict = new AdatszotarHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetCsoportTipusList().ToDictionary(x => x.Id, x => x.OraPerc);
                tantargyNincsBeloleOra = new TantargyHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetTantargyakNincsBeloleOra();
                tantargyfelosztasCoList = new TantargyFelosztasHelper(new DalHandlerConnectionType(ConnectionType, dalHandler)).GetTantargyfelosztasCoList();
                orarendiElemekRogzitesenekElofeltetele = (SystemSettingsOrarendiElemekRogzitesenekElofelteteleEnum)(systemSettingsHelper.GetSystemSettingValue<int>(RendszerBeallitasTipusEnum.orarendi_elemek_rogzitesenek_elofeltetele));
            });

            var importCo = new OrarendImportCo
            {
                OrarendImportTipus = orarendImportFileUploadCo.OrarendImportTipus,
                IsNapirendImport = orarendImportFileUploadCo.IsNapirendImport,
                IsTtfImport = orarendImportFileUploadCo.IsTtfImport,
                OrarendiOraLezarasDateTime = orarendImportFileUploadCo.OrarendiOraLezarasDateTime,
                TanarCoList = tanarCoList,
                OsztalyCoList = osztalyCoList,
                CsoportCoList = csoportCoList,
                TanevrendOsztalyokkalNaptipusTulajdonsagokkalCOs = tanevRendjeNaptipusTulajdonsagokkalCOs,
                TantargyNincsBeloleOra = tantargyNincsBeloleOra,
                TantargyfelosztasCoList = tantargyfelosztasCoList,
                OrarendiElemekRogzitesenekElofeltetele = orarendiElemekRogzitesenekElofeltetele,
                TeremCoList = teremCoList
            };

            Dictionary<int, string> hetirendTipusDictionary = new Dictionary<int, string>();
            foreach (DataRow dataRow in hetirendTipusDataSet.Tables[0].Rows)
            {
                hetirendTipusDictionary.Add(SDAConvert.ToInt32(dataRow["ID"]), SDAConvert.ToString(dataRow["Megnevezes"]));
            }

            int lineNumber = 1;
            foreach (List<string> importDataRow in orarendImportFileUploadCo.ImportData.Skip(1))
            {
                Dictionary<int, string> importHeaderList = !orarendImportFileUploadCo.IsNapirendImport ? ImportHeaderListOraErvenyessegiIdovel : ImportHeaderListNapirendOraErvenyessegiIdovel;
                var importItemCo = new OrarendImportItemCo(TanevId, isAktivTanev)
                {
                    LineNumber = lineNumber,

                    OraErvenyessegKezdeteImportData = importDataRow[importHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameOraErvenyessegKezdete)],
                    OraErvenyessegVegeImportData = importDataRow[importHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameOraErvenyessegVege)],
                    HetirendImportData = importDataRow[importHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameHetirend)],
                    NapImportData = importDataRow[importHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameNap)],
                    OsztalyNevImportData = importDataRow[importHeaderList.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly)],
                    CsoportNevImportData = importDataRow[importHeaderList.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport)],
                    TantargyNevImportData = importDataRow[importHeaderList.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy)],
                    TanarNevImportData = importDataRow[importHeaderList.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTanar)],
                    HelyisegImportData = importDataRow[importHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameHelyiseg)],

                    OraErvenyessegMinDate = orarendImportFileUploadCo.OraErvenyessegMinDate,
                    OraErvenyessegMaxDate = orarendImportFileUploadCo.OraErvenyessegMaxDate,
                    HetirendTipusDictionary = hetirendTipusDictionary,

                    IsNapirendImport = orarendImportFileUploadCo.IsNapirendImport,
                    FoglalkozasokRogziteseHetvegereId = foglalkozasokRogziteseHetvegereId
                };

                var osztalyCsoportId =
                    importCo.OsztalyCoList.FirstOrDefault(x => x.NevComparableString == importItemCo.OsztalyCsoportNev.ToComparableString())?.Id ??
                    importCo.CsoportCoList.FirstOrDefault(x => x.NevComparableString == importItemCo.OsztalyCsoportNev.ToComparableString())?.Id;
                ChangeFoglalkozasokRogziteseHetvegere(importCo, importItemCo, osztalyCsoportId);

                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;
                    }
                }

                importItemCo.HetirendTipusId = importItemCo.HetirendTipusDictionary.SingleOrDefault(x => x.Value == importItemCo.HetirendTipusNev).Key;
                if (!importItemCo.IsNapirendImport)
                {
                    importItemCo.OraImportData = importDataRow[importHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameOra)];

                    importItemCo.CsengetesiRendId = csengetesiRendId;
                    importItemCo.CsengetesiRendOraCoList = csengetesiRendOraCoList;
                    importItemCo.CsengetesiRendOraId = csengetesiRendOraCoList.SingleOrDefault(x => x.Oraszam == importItemCo.OraSorszam)?.ID;
                }
                else
                {
                    importItemCo.FoglalkozasKezdeteImportData = importDataRow[importHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameFoglalkozasKezdete)];
                    importItemCo.FoglalkozasVegeImportData = importDataRow[importHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameFoglalkozasVege)];

                    importItemCo.CsengetesiRendId = null;
                    importItemCo.CsengetesiRendOraCoList = null;
                    importItemCo.CsengetesiRendOraId = null;
                }

                var csoportCo = importCo.CsoportCoList.SingleOrDefault(x => x.NevComparableString == importItemCo.CsoportNev.ToComparableString());

                if (csoportCo != null)
                {
                    importItemCo.CsoportTipusId = csoportCo.TipusId ?? (int)CsoportTipusEnum.iskolai_csoport_tanorai_celu_;
                }
                else
                {
                    importItemCo.CsoportTipusId = orarendImportFileUploadCo.IsOsszefuggoSzakmaiGyakorlat ? (int)CsoportTipusEnum.OsszefuggoSzakmaiGyakorlatiCsoport : (int)CsoportTipusEnum.na;
                }

                // NOTE: Órarendi óra esetén, rendszerbeállítástól függ az óra végének meghatározása.
                // NOTE: Ha 'IGEN', órahossz alapján kell, amit a csoport típusa határoz meg.
                if (importItemCo.OraSorszam == null)
                {
                    importItemCo.OraVege = BaseImportItemCo.GetDateTimeValueFromTimeString(importItemCo.FoglalkozasVegeImportData);
                }
                else
                {
                    if (!importItemCo.IsCsoport || !isOravegeBeallitasOrahosszAlapjan)
                    {
                        importItemCo.OraVege = importItemCo.CsengetesiRendOraCoList.SingleOrDefault(x => x.Oraszam == importItemCo.OraSorszam)?.Veg;
                    }
                    else
                    {
                        // NOTE: Létező csoport esetén kikeressük, milyen csoport típus tartozik hozzá.
                        if (csoportTipusOraPercDict.TryGetValue(importItemCo.CsoportTipusId.Value, out int? csoportTipusOraPerc) && csoportTipusOraPerc.HasValue)
                        {
                            importItemCo.OraVege = importItemCo.OraKezdete?.AddMinutes(csoportTipusOraPerc.Value);
                        }
                    }
                }

                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.CompareHashTantargyfelosztas = ImportExportHelper.GetMd5Hash(tantargyfelosztasMd5HashInput);

                if (!string.IsNullOrWhiteSpace(importItemCo.TeremNev))
                {
                    string teremMd5HashInput = importItemCo.TeremNev.ToComparableString();
                    importItemCo.CompareHashTerem = ImportExportHelper.GetMd5Hash(teremMd5HashInput);
                }

                string orarendMd5HashInput = string.Empty;
                if (importCo.OrarendImportTipus == (int)OrarendImportTipusEnum.ErvenyessegiIdovelImport)
                {
                    orarendMd5HashInput += importItemCo.OraErvenyessegKezdeteString?.ToComparableString();
                    orarendMd5HashInput += importItemCo.OraErvenyessegVegeString?.ToComparableString();
                }

                orarendMd5HashInput += importItemCo.HetirendTipusNev?.ToComparableString();
                orarendMd5HashInput += importItemCo.HetNapjaTipusId?.GetDisplayName<HetNapjaTipusEnum>(TanevId)?.ToComparableString();
                if (!importItemCo.IsNapirendImport)
                {
                    orarendMd5HashInput += importItemCo.OraSorszam;
                }
                else
                {
                    orarendMd5HashInput += importItemCo.OraKezdeteString?.ToComparableString();
                    orarendMd5HashInput += importItemCo.OraVegeString?.ToComparableString();
                }

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

                orarendMd5HashInput += importItemCo.TeremNev?.ToComparableString();

                importItemCo.CompareHash = ImportExportHelper.GetMd5Hash(orarendMd5HashInput);

                importCo.MainImportItemList.Add(importItemCo);

                lineNumber++;
            }

            return importCo;
        }

        public MemoryStream GetTemplate(OrarendImportFileUploadCo orarendImportFileUploadCo, bool isSzakkepzo = false, int? szervezetTipus = null, int? szervezetId = null)
        {
            Dictionary<string, IList<string>> dropDownColumnSourceDictionary = GetDefaultDropDownColumnSourceDictionary(true, isSzakkepzo, szervezetTipus, szervezetId);
            MemoryStream memoryStream = ImportExportHelper.GetTemplate(orarendImportFileUploadCo.WorksheetName, orarendImportFileUploadCo.ExcelHeaderList, dropDownColumnSourceDictionary);
            return memoryStream;
        }

        public MemoryStream GetExport(OrarendImportFileUploadCo orarendImportFileUploadCo, DateTime orarendExportKezdete, DateTime orarendExportVege, bool isIdoszakonKivuliElemekMegjelenitese, bool isEgyediNapOrainakKihagyasa)
        {
            bool isOraErvenyessegiIdovel = orarendImportFileUploadCo.OrarendImportTipus == (int)OrarendImportTipusEnum.ErvenyessegiIdovelImport;
            DataSet dataSet = Dal.CustomConnection.Run(ConnectionType, dalHandler => dalHandler.ImportExportDal().GetOrarendExcelExportData(TanevId, orarendExportKezdete, orarendExportVege, isOraErvenyessegiIdovel, isIdoszakonKivuliElemekMegjelenitese, isEgyediNapOrainakKihagyasa, orarendImportFileUploadCo.IsNapirendImport));

            return GetWorkbook(orarendImportFileUploadCo, dataSet);
        }

        public MemoryStream GetWorkbook(OrarendImportFileUploadCo orarendImportFileUploadCo, DataSet dataSet)
        {
            Dictionary<string, IList<string>> dropDownColumnSourceDictionary = GetDefaultDropDownColumnSourceDictionary(false);
            bool isOraErvenyessegiIdovel = orarendImportFileUploadCo.OrarendImportTipus == (int)OrarendImportTipusEnum.ErvenyessegiIdovelImport;

            using (var workbook = new Workbook())
            {
                List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos(orarendImportFileUploadCo.ExcelHeaderList, dropDownColumnSourceDictionary);
                var worksheet = SimpleExportLogic.GetWorksheet(workbook, orarendImportFileUploadCo.WorksheetName, simpleExportColumnCos);

                int rowNumber = 1;
                foreach (DataRow dataRow in dataSet.Tables[0].AsEnumerable())
                {
                    if (isOraErvenyessegiIdovel)
                    {
                        var oraErvenyessegKezdete = SDAConvert.ToDateTime(dataRow["OraErvenyessegKezdete"]).Value;
                        worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameOraErvenyessegKezdete)].Value = oraErvenyessegKezdete.ToString(Constants.ToStringPattern.HungarianDate);
                        var oraErvenyessegVege = SDAConvert.ToDateTime(dataRow["OraErvenyessegVege"]);
                        //NOTE: Az OraErvenyessegVege 00:00-t tartalmaz, de aznap napközben még lehet óra, ezért a következő nap 00:00 időpont a jó és azt mentjük a db-be!
                        DateTime? oraErvenyessegVegeDatum = oraErvenyessegKezdete.Equals(oraErvenyessegVege) ? oraErvenyessegVege : oraErvenyessegVege?.AddDays(-1);
                        worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameOraErvenyessegVege)].Value = oraErvenyessegVegeDatum?.ToString(Constants.ToStringPattern.HungarianDate) ?? string.Empty;
                    }

                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameHetirend)].Value = SDAConvert.ToString(dataRow["Hetirend"]) ?? string.Empty;
                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameNap)].Value = SDAConvert.ToString(dataRow["Nap"]) ?? string.Empty;
                    if (orarendImportFileUploadCo.IsNapirendImport)
                    {
                        worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameFoglalkozasKezdete)].Value = SDAConvert.ToDateTime(dataRow["FoglalkozasKezdete"]).Value.ToString(Constants.ToStringPattern.HungarianTime);
                        worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameFoglalkozasVege)].Value = SDAConvert.ToDateTime(dataRow["FoglalkozasVege"]).Value.ToString(Constants.ToStringPattern.HungarianTime);
                    }
                    else
                    {
                        worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameOra)].Value = SDAConvert.ToNullableInt32(dataRow["Ora"])?.ToString() ?? string.Empty;
                    }

                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly)].Value = SDAConvert.ToString(dataRow["Osztaly"]) ?? string.Empty;
                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport)].Value = SDAConvert.ToString(dataRow["Csoport"]) ?? string.Empty;
                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy)].Value = SDAConvert.ToString(dataRow["Tantargy"]) ?? string.Empty;
                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTanar)].Value = SDAConvert.ToString(dataRow["Tanar"]) ?? string.Empty;
                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameHelyiseg)].Value = SDAConvert.ToString(dataRow["Helyiseg"]) ?? string.Empty;

                    rowNumber++;
                }

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

        public MemoryStream GetNemImportalhatoSorokExport(OrarendImportFileUploadCo orarendImportFileUploadCo)
        {
            Dictionary<string, IList<string>> dropDownColumnSourceDictionary = GetDefaultDropDownColumnSourceDictionary(false);
            using (var workbook = new Workbook())
            {
                var worksheet = ImportExportHelper.GetWorksheetsWithDropDownFormula(workbook, orarendImportFileUploadCo.WorksheetName, orarendImportFileUploadCo.ExcelHeaderList, dropDownColumnSourceDictionary);

                int rowNumber = 1;
                foreach (OrarendImportItemCo co in ImportCo.NemImportalhatoItemList)
                {
                    if (orarendImportFileUploadCo.OrarendImportTipus == (int)OrarendImportTipusEnum.ErvenyessegiIdovelImport)
                    {
                        worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameOraErvenyessegKezdete)].Value = co.OraErvenyessegKezdeteImportData;
                        worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameOraErvenyessegVege)].Value = co.OraErvenyessegVegeImportData;
                    }

                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameHetirend)].Value = co.HetirendImportData;
                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameNap)].Value = co.NapImportData;
                    if (orarendImportFileUploadCo.IsNapirendImport)
                    {
                        worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameFoglalkozasKezdete)].Value = co.FoglalkozasKezdeteImportData;
                        worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameFoglalkozasVege)].Value = co.FoglalkozasVegeImportData;
                    }
                    else
                    {
                        worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameOra)].Value = co.OraImportData;
                    }

                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly)].Value = co.OsztalyNevImportData;
                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport)].Value = co.CsoportNevImportData;
                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy)].Value = co.TantargyNevImportData;
                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportTantargyfelosztasResource.ImportHeaderNameTanar)].Value = co.TanarNevImportData;
                    worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.GetKeyByUniqueValue(ImportExportOrarendResource.ImportHeaderNameHelyiseg)].Value = co.HelyisegImportData;

                    Cell errorCell = worksheet.Cells[rowNumber, orarendImportFileUploadCo.ExcelHeaderList.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> { ImportHeaderList.Count } }
                };
                MemoryStream memoryStream = SimpleExportLogic.GetWorkbookMemoryStream(workbook, sheetCodeNameAndColumnsToWrapIndexDictionary);
                return memoryStream;
            }
        }

        public void Import(object importJsonObject, int orarendImportMuvelet, bool isNapirendImport, DateTime? orarendiOraLezarasDateTime)
        {
            string importJson = JsonConvert.SerializeObject(importJsonObject);
            bool isTorles = orarendImportMuvelet == (int)OrarendImportMuveletEnum.DeleteAndInsert;
            bool isModositas = orarendImportMuvelet == (int)OrarendImportMuveletEnum.UpdateAndInsert;
            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
            {
                dalHandler.ImportExportDal().OrarendImport(IntezmenyId, TanevId, FelhasznaloId, importJson, isTorles, isModositas, isNapirendImport, orarendiOraLezarasDateTime);
                dalHandler.OrarendiOra().UpdateOrarend(IntezmenyId, TanevId, null, null, null, null);
            });
        }

        private void ChangeFoglalkozasokRogziteseHetvegere(OrarendImportCo importCo, OrarendImportItemCo importItemCo, int? osztalyCsoportId)
        {
            if (importItemCo.IsEgyediNap)
            {
                var aktualisTanevRendje = importCo.TanevrendOsztalyokkalNaptipusTulajdonsagokkalCOs.Where(tr =>
                    // globális tanévrendi esemény
                    !tr.OsztalyCsoportId.IsEntityId()
                    // osztályra vonatkozó tanévrendi esemény
                    || (tr.OsztalyCsoportId.IsEntityId() && tr.OsztalyCsoportId == osztalyCsoportId)).ToList();

                var napraTanitasiOratTanoranKivulitLehetRogziteni = aktualisTanevRendje.Where(tr => (tr.Datum == importItemCo.OraErvenyessegKezdete) && (tr.IsTanitasi || tr.IsTanoranKivuli)).ToList();
                if (napraTanitasiOratTanoranKivulitLehetRogziteni.Any())
                {
                    // ha az osztálynak van olyan tanévrendi eseménye az adott napra, ahol lehet rögzíteni tanítási órát vagy tanórán kívüli foglalkozást, akkor
                    if (napraTanitasiOratTanoranKivulitLehetRogziteni.Any(x => !x.Globalis && !x.OrarendiNap))
                    {
                        //ha van benne az osztályra szabott tiltás
                        return;
                    }

                    if (napraTanitasiOratTanoranKivulitLehetRogziteni.Any(x => !x.Globalis && x.OrarendiNap))
                    {
                        //ha van benne az osztályra szabott engedélyezés, akkor nem érdekes a rendszerbeállítás
                        importItemCo.FoglalkozasokRogziteseHetvegereId = (int)FoglalkozasokRogziteseHetvegere.Engedelyezett;
                        return;
                    }

                    if (napraTanitasiOratTanoranKivulitLehetRogziteni.Any(x => x.Globalis && !x.OrarendiNap))
                    {
                        //ha van benne globalis tiltás
                        return;
                    }

                    if (napraTanitasiOratTanoranKivulitLehetRogziteni.Any(x => x.Globalis && x.OrarendiNap))
                    {
                        //ha van benne globalis engedélyezés, akkor nem érdekes a rendszerbeállítás
                        importItemCo.FoglalkozasokRogziteseHetvegereId = (int)FoglalkozasokRogziteseHetvegere.Engedelyezett;
                    }
                }
            }
        }

        private double GetOraszam(OrarendImportItemCo importItem, List<OrarendImportItemCo> orarendImportItemCoList, Dictionary<int, int?> csoportTipusOraPercDict)
        {
            int orahosszPerc = 45;

            if (importItem.IsCsoport)
            {
                if (csoportTipusOraPercDict.TryGetValue(importItem.CsoportTipusId.Value, out int? csoportTipusOraPerc) && csoportTipusOraPerc.HasValue)
                {
                    orahosszPerc = csoportTipusOraPerc.Value;
                }
            }
            else
            {
                var ds = new OsztalyCsoportHelper(ConnectionType).GetOsztalyCsoportNev(importItem.OsztalyNev, null);

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0 && ds.Tables[0].Rows[0].Field<int>("KategoriaId") == (int)OktNevelesiKategoriaEnum.Kollegium)
                {
                    orahosszPerc = 60;
                }
                else
                {
                    orahosszPerc = 45;
                }
            }

            double idotartam = 0;
            double hetirendOszto = importItem.HetirendTipusDictionary.Count(x => x.Key != (int)HetiRendTipusEnum.MindegyikHet);
            double oraszamHetiAtlag = 1;

            if (hetirendOszto != 0)
            {
                oraszamHetiAtlag = 1 / hetirendOszto;
            }

            foreach (OrarendImportItemCo orarendImportItemCo in orarendImportItemCoList)
            {
                if (orarendImportItemCo.HetirendTipusId == (int)HetiRendTipusEnum.MindegyikHet)
                {
                    idotartam += orarendImportItemCo.CsengetesiRendId.HasValue ? orahosszPerc : orarendImportItemCo.OraVege.Value.Subtract(orarendImportItemCo.OraKezdete.Value).TotalMinutes;
                }
                else
                {
                    idotartam += oraszamHetiAtlag * (orarendImportItemCo.CsengetesiRendId.HasValue ? orahosszPerc : orarendImportItemCo.OraVege.Value.Subtract(orarendImportItemCo.OraKezdete.Value).TotalMinutes);
                }
            }

            double result = Math.Round(idotartam / orahosszPerc, 2);
            return result;
        }

        public Dictionary<string, IList<string>> GetDefaultDropDownColumnSourceDictionary(bool filterBySzervezetTipus, bool isSzakkepzo = false, int ? szervezetTipus = null, int? szervezetId = null)
        {
            //NOTE: Create dropdown lists
            var dropDownColumnSourceDictionary = new Dictionary<string, IList<string>>();

            Dal.CustomConnection.Run(ConnectionType, dalHandler =>
            {
                var helper = new ImportExportHelper(new DalHandlerConnectionType(ConnectionType, dalHandler));
                dropDownColumnSourceDictionary.Add(ImportExportOrarendResource.ImportHeaderNameHetirend, helper.GetHetiRendTipusList());
                dropDownColumnSourceDictionary.Add(ImportExportOrarendResource.ImportHeaderNameNap, helper.GetHetNapjaTipusList());
                dropDownColumnSourceDictionary.Add(ImportExportTantargyfelosztasResource.ImportHeaderNameOsztaly, helper.GetOsztalyList());
                dropDownColumnSourceDictionary.Add(ImportExportTantargyfelosztasResource.ImportHeaderNameCsoport, !filterBySzervezetTipus ? helper.GetCsoportList() : helper.GetCsoportListBySzervezet(szervezetTipus, szervezetId));
                dropDownColumnSourceDictionary.Add(ImportExportTantargyfelosztasResource.ImportHeaderNameTanar, !filterBySzervezetTipus ? helper.GetTanarList(true) : helper.GetTanarListBySzervezet(true, szervezetTipus, szervezetId));
                dropDownColumnSourceDictionary.Add(ImportExportOrarendResource.ImportHeaderNameHelyiseg, !filterBySzervezetTipus ? helper.GetTeremList() : helper.GetTeremListBySzervezet(szervezetTipus, szervezetId));
                dropDownColumnSourceDictionary.Add(ImportExportTantargyfelosztasResource.ImportHeaderNameTantargy, !filterBySzervezetTipus ? helper.GetTantargyList() : helper.GetTantargyListBySzervezet(szervezetId == null ? false : true, isSzakkepzo));
            });

            return dropDownColumnSourceDictionary;
        }
    }
}