using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Text.RegularExpressions;
using Kreta.BusinessLogic.Classes;
using Kreta.BusinessLogic.Helpers;
using Kreta.BusinessLogic.Validation;
using Kreta.Core;
using Kreta.Core.ConnectionType;
using Kreta.Core.CustomAttributes;
using Kreta.Enums;
using Kreta.Enums.ManualEnums;
using Kreta.Framework;
using Kreta.Framework.Security.PasswordCrypting;
using Kreta.Framework.Util;
using Kreta.Resources;
using Newtonsoft.Json;

namespace Kreta.BusinessLogic.HelperClasses.ImportCo
{
    public class FelhasznaloBelepesImportCo : BaseImportCo
    {
        [JsonIgnore]
        public List<FelhasznaloBelepesImportItemCo> MainImportItemList { get; set; } = new List<FelhasznaloBelepesImportItemCo>();

        [JsonIgnore]
        public List<FelhasznaloBelepesImportItemCo> NemImportalhatoItemList { get; set; } = new List<FelhasznaloBelepesImportItemCo>();

        [JsonProperty("T_FELHASZNALOBELEPES_OSSZES")]
        public List<FelhasznaloBelepesImportJsonItemCo> MainImportJsonItemList { get; set; }

        [JsonIgnore]
        public List<FelhasznaloBelepesItemCo> FelhasznaloBelepesCoList { get; set; }

        [JsonIgnore]
        public FelhasznaloBelepesExportImportTipusEnum TipusEnum { get; set; }

        [JsonIgnore]
        public bool IsGeneraltFileLetoltes { get; set; }

        [JsonIgnore]
        public bool IsEmailKuldes { get; set; }

        public Dictionary<int, List<ValidationResult>> Validate(IConnectionType connectionType, bool isSzakkepzoIntezmeny)
        {
            var validationResultDictionary = new Dictionary<int, List<ValidationResult>>();

            foreach (FelhasznaloBelepesImportItemCo importItem in MainImportItemList)
            {
                var validationResultList = new List<ValidationResult>();
                //NOTE: Az import item-eket egyesével levalidáljuk!
                var blValidator = new BlValidator(importItem);
                if (!blValidator.IsValid)
                {
                    validationResultList.AddRange(blValidator.ErrorList);
                }

                if (!string.IsNullOrWhiteSpace(importItem.BejelentkezesiNev))
                {
                    string bejelentkezesiNevToCompare = importItem.BejelentkezesiNev.ToComparableString();
                    //NOTE: Levalidáljuk, hogy létezik-e a bejelentkezesi név a db-ben, de nem saját maga(azaz csak jelszót változtat)!
                    var utkozoNevek = FelhasznaloBelepesCoList.Where(x =>
                            (importItem.FelhasznaloBelepes == null || x.Id != importItem.FelhasznaloBelepes.Id) &&
                            x.BejelentkezesiNevComparableString == bejelentkezesiNevToCompare);

                    FelhasznalonevValidacio(validationResultList, utkozoNevek);

                    OktatasiAzonositoValidacio(validationResultList, importItem.OktatasiAzonosito?.ToComparableString(), isSzakkepzoIntezmeny);

                    //NOTE: Levalidáljuk, hogy ugyanazzal a bejelentkezesi névvel csak egyszer szerepeljen tanuló a dokumnetumban!
                    if (MainImportItemList.Count(x => x.BejelentkezesiNev.ToComparableString() == bejelentkezesiNevToCompare) > 1)
                    {
                        validationResultList.Add(new ValidationResult(string.Format(ImportExportFelhasznaloBelepesResource.AMegadottFelhasznalonev0TobbSorbanIsSzerepel, importItem.BejelentkezesiNev)));
                    }
                }

                if (TipusEnum == FelhasznaloBelepesExportImportTipusEnum.Gondviselo)
                {
                    if (importItem.GondviseloRokonsagiFokId.HasValue && importItem.TanuloId.HasValue)
                    {
                        var helper = new TanuloHelper(connectionType);
                        if (helper.HasDuplicatedGondviselo(importItem.TanuloId.Value))
                        {
                            validationResultList.Add(new ValidationResult(ImportExportFelhasznaloBelepesResource.ATanulohozTobbAzonosNevuEsRokonsagiFokuGondviseloVanFelveve));
                        }
                    }
                }

                if (validationResultList.Count > 0)
                {
                    validationResultDictionary.Add(importItem.LineNumber, validationResultList);
                }
            }

            Dictionary<int, string> lineNumberCompareHashDictionary = MainImportItemList.ToDictionary(x => x.LineNumber, x => x.CompareHash);
            List<string> duplicatedRowConditonTextList;
            switch (TipusEnum)
            {
                case FelhasznaloBelepesExportImportTipusEnum.Alkalmazott:
                    duplicatedRowConditonTextList = new List<string>
                    {
                        ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottNeve,
                        ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottOktatasiAzonosito,
                        ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottSzuletesiDatuma
                    };
                    break;

                case FelhasznaloBelepesExportImportTipusEnum.Tanulo:
                    duplicatedRowConditonTextList = new List<string>
                    {
                        ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloNevSzulidoOktazon,
                        ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloOktatasiAzonosito,
                        ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloSzuletesiDatuma
                    };
                    break;

                case FelhasznaloBelepesExportImportTipusEnum.Gondviselo:
                    duplicatedRowConditonTextList = new List<string>
                    {
                        ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloNeve,
                        ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloOktatasiAzonosito,
                        ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloSzuletesiDatuma,
                        ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloNeve,
                        ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloRokonsagiFoka
                    };
                    break;

                default:
                    throw new Exception();
            }

            ValidateDuplicatedRows(validationResultDictionary, lineNumberCompareHashDictionary, duplicatedRowConditonTextList);
            return validationResultDictionary;
        }

        private static void FelhasznalonevValidacio(List<ValidationResult> validationResultList, IEnumerable<FelhasznaloBelepesItemCo> utkozoNevek)
        {
            var nincsGondviseloUtkozoNevek = utkozoNevek.Where(x => x.GondviseloId == null);

            if (nincsGondviseloUtkozoNevek.Any())
            {
                var tanevMegnevezes = nincsGondviseloUtkozoNevek.All(x => string.IsNullOrWhiteSpace(x.AnotherYearTanevMegnevezes)) ? string.Empty : nincsGondviseloUtkozoNevek.First().AnotherYearTanevMegnevezes;

                var errorMsg = string.Format(ErrorResource.FelhasznalonevFoglaltAltal, string.Join(", ", nincsGondviseloUtkozoNevek.Select(x => x.FelhasznaloNyomtatasiNev)), tanevMegnevezes);

                validationResultList.Add(new ValidationResult(errorMsg));
            }

            var vanGondviseloUtkozoNevek = utkozoNevek.Where(x => x.GondviseloId != null);

            if (vanGondviseloUtkozoNevek.Any())
            {
                var tanevMegnevezes = vanGondviseloUtkozoNevek.All(x => string.IsNullOrWhiteSpace(x.AnotherYearTanevMegnevezes)) ? string.Empty : vanGondviseloUtkozoNevek.First().AnotherYearTanevMegnevezes;

                var errorMsg = string.Format(ErrorResource.FelhasznalonevFoglaltAltalGondviselo, string.Join(", ", vanGondviseloUtkozoNevek.Select(x => x.FelhasznaloNyomtatasiNev)), tanevMegnevezes);

                validationResultList.Add(new ValidationResult(errorMsg));
            }
        }

        private static void OktatasiAzonositoValidacio(List<ValidationResult> validationResultList, string oktatasiAzonosito, bool isSzakkepzoIntezmeny)
        {
            if (isSzakkepzoIntezmeny && !string.IsNullOrWhiteSpace(oktatasiAzonosito) && !Extensions.FelhasznaloExtensions.IsValidOktatasiAzonosito(oktatasiAzonosito))
            {
                validationResultList.Add(new ValidationResult(ErrorResource.AMegadottOktatasiAzonositoHibas));
            }
        }
    }

    public class FelhasznaloBelepesImportItemCo : BaseImportItemCo, IValidatableObject
    {
        private readonly int _tanevId;

        private FelhasznaloBelepesImportItemCo() { }

        public FelhasznaloBelepesImportItemCo(int tanevId)
        {
            _tanevId = tanevId;
        }

        #region Fields

        /// <summary>
        /// Technikai paraméter(ek) a reflection-ös exporthoz.
        /// </summary>
        public const string AlkalmazottNemImportalhatoSorokExportAttributeId = nameof(AlkalmazottNemImportalhatoSorokExportAttributeId);

        public const string TanuloNemImportalhatoSorokExportAttributeId = nameof(TanuloNemImportalhatoSorokExportAttributeId);
        public const string GondviseloNemImportalhatoSorokExportAttributeId = nameof(GondviseloNemImportalhatoSorokExportAttributeId);

        #endregion Fields

        [SimpleExportColumn(AlkalmazottNemImportalhatoSorokExportAttributeId, 00, nameof(ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottNeve), typeof(ImportExportFelhasznaloBelepesResource))]
        [SimpleExportColumn(GondviseloNemImportalhatoSorokExportAttributeId, 00, nameof(ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloNeve), typeof(ImportExportFelhasznaloBelepesResource))]
        [MaxLength(255, ErrorMessageResourceName = nameof(CommonResource.MaxLengthValidation), ErrorMessageResourceType = typeof(CommonResource))]
        public string NeveImportData { get; set; }

        [SimpleExportColumn(AlkalmazottNemImportalhatoSorokExportAttributeId, 01, nameof(ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottOktatasiAzonosito), typeof(ImportExportFelhasznaloBelepesResource))]
        [SimpleExportColumn(GondviseloNemImportalhatoSorokExportAttributeId, 01, nameof(ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloOktatasiAzonosito), typeof(ImportExportFelhasznaloBelepesResource))]
        [MaxLength(20, ErrorMessageResourceName = nameof(CommonResource.MaxLengthValidation), ErrorMessageResourceType = typeof(CommonResource))]
        public string OktatasiAzonositoImportData { get; set; }

        [SimpleExportColumn(AlkalmazottNemImportalhatoSorokExportAttributeId, 02, nameof(ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottSzuletesiDatuma), typeof(ImportExportFelhasznaloBelepesResource))]
        [SimpleExportColumn(GondviseloNemImportalhatoSorokExportAttributeId, 02, nameof(ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloSzuletesiDatuma), typeof(ImportExportFelhasznaloBelepesResource))]
        [MaxLength(20, ErrorMessageResourceName = nameof(CommonResource.MaxLengthValidation), ErrorMessageResourceType = typeof(CommonResource))]
        public string SzuletesiDatumaImportData { get; set; }

        [SimpleExportColumn(GondviseloNemImportalhatoSorokExportAttributeId, 03, nameof(ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloNeve), typeof(ImportExportFelhasznaloBelepesResource))]
        [MaxLength(255, ErrorMessageResourceName = nameof(CommonResource.MaxLengthValidation), ErrorMessageResourceType = typeof(CommonResource))]
        public string GondviseloNeveImportData { get; set; }

        [SimpleExportColumn(GondviseloNemImportalhatoSorokExportAttributeId, 04, nameof(ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloRokonsagiFoka), typeof(ImportExportFelhasznaloBelepesResource))]
        [MaxLength(250, ErrorMessageResourceName = nameof(CommonResource.MaxLengthValidation), ErrorMessageResourceType = typeof(CommonResource))]
        public string GondviseloRokonsagiFokaImportData { get; set; }

        [SimpleExportColumn(AlkalmazottNemImportalhatoSorokExportAttributeId, 03, nameof(ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottFelhasznaloneve), typeof(ImportExportFelhasznaloBelepesResource))]
        [SimpleExportColumn(TanuloNemImportalhatoSorokExportAttributeId, 01, nameof(ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloFelhasznaloneve), typeof(ImportExportFelhasznaloBelepesResource))]
        [SimpleExportColumn(GondviseloNemImportalhatoSorokExportAttributeId, 05, nameof(ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloFelhasznaloneve), typeof(ImportExportFelhasznaloBelepesResource))]
        [MaxLength(255, ErrorMessageResourceName = nameof(CommonResource.MaxLengthValidation), ErrorMessageResourceType = typeof(CommonResource))]
        public string FelhasznaloNeveImportData { get; set; }

        [SimpleExportColumn(AlkalmazottNemImportalhatoSorokExportAttributeId, 04, nameof(ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottJelszava), typeof(ImportExportFelhasznaloBelepesResource))]
        [SimpleExportColumn(TanuloNemImportalhatoSorokExportAttributeId, 02, nameof(ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloJelszava), typeof(ImportExportFelhasznaloBelepesResource))]
        [SimpleExportColumn(GondviseloNemImportalhatoSorokExportAttributeId, 06, nameof(ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloJelszava), typeof(ImportExportFelhasznaloBelepesResource))]
        [StringLength(Constants.General.JelszoMaximumKarakterekSzama, MinimumLength = Constants.General.JelszoMinimumKarakterekSzama, ErrorMessageResourceName = nameof(ErrorResource.AJelszonakMin0Max0KarakterbolKellAllnia), ErrorMessageResourceType = typeof(ErrorResource))]
        public string JelszavaImportData { get; set; }

        [SimpleExportColumn(TanuloNemImportalhatoSorokExportAttributeId, 00, nameof(ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloNevSzulidoOktazon), typeof(ImportExportFelhasznaloBelepesResource), nameof(ImportExportFelhasznaloBelepesResource.ImportSheetNameTanuloNevSzulidoOktazon), typeof(ImportExportFelhasznaloBelepesResource))]
        public string TanuloNevOktAzonSzulDatumImportData { get; set; }

        public string Elotag => GetElotagFromTeljesNev(NeveImportData);

        public string Vezeteknev => GetVezeteknevFromTeljesNev(NeveImportData);

        public string Keresztnev => GetKeresztnevekFromTeljesNev(NeveImportData);

        public string OktatasiAzonosito => GetStringValue(OktatasiAzonositoImportData);

        public DateTime? SzuletesiIdo => GetDateTimeValue(SzuletesiDatumaImportData);

        public string SzuletesiIdoString => GetDateTimeString(SzuletesiIdo);

        public string GondviseloNev => GetStringValue(GondviseloNeveImportData);

        public int? GondviseloRokonsagiFokId => ((int)GeneratedAdatszotarTipusEnum.RokonsagiFok).GetItemIdByTypeAndName(GondviseloRokonsagiFokaImportData, _tanevId);

        public string BejelentkezesiNev => GetStringValue(FelhasznaloNeveImportData);

        public string JelszoPlainText => GetStringValue(JelszavaImportData);

        public FelhasznaloBelepesItemCo FelhasznaloBelepes { get; set; }

        public int? AlkalmazottId => FelhasznaloBelepes?.AlkalmazottId;

        public int? TanuloId => FelhasznaloBelepes?.TanuloId;

        public int? GondviseloId => FelhasznaloBelepes?.GondviseloId;

        public FelhasznaloBelepesExportImportTipusEnum TipusEnum { get; set; }

        #region Validate

        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
        {
            string nevError;
            string oktatasiAzonositoError;
            string szuletesiDatumaError;
            string felhasznaloNeveText;
            string jelszavaText;
            switch (TipusEnum)
            {
                case FelhasznaloBelepesExportImportTipusEnum.Alkalmazott:
                    nevError = string.Format(ErrorResource.Required, ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottNeve);
                    oktatasiAzonositoError = string.Format(ErrorResource.Required, ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottOktatasiAzonosito);
                    szuletesiDatumaError = string.Format(ErrorResource.Required, ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottSzuletesiDatuma);
                    felhasznaloNeveText = ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottFelhasznaloneve;
                    jelszavaText = ImportExportFelhasznaloBelepesResource.ImportHeaderNameAlkalmazottJelszava;
                    break;

                case FelhasznaloBelepesExportImportTipusEnum.Tanulo:
                    nevError = $"{ImportExportFelhasznaloBelepesResource.HianyosTanuloNevAdat} ({ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloOktatasiAzonosito})";
                    oktatasiAzonositoError = $"{ImportExportFelhasznaloBelepesResource.HianyosTanuloNevAdat} ({ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloOktatasiAzonosito})";
                    szuletesiDatumaError = $"{ImportExportFelhasznaloBelepesResource.HianyosTanuloNevAdat} ({ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloOktatasiAzonosito})";
                    felhasznaloNeveText = ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloFelhasznaloneve;
                    jelszavaText = ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloJelszava;
                    break;

                case FelhasznaloBelepesExportImportTipusEnum.Gondviselo:
                    nevError = string.Format(ErrorResource.Required, ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloNeve);
                    oktatasiAzonositoError = string.Format(ErrorResource.Required, ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloOktatasiAzonosito);
                    szuletesiDatumaError = string.Format(ErrorResource.Required, ImportExportFelhasznaloBelepesResource.ImportHeaderNameTanuloSzuletesiDatuma);
                    felhasznaloNeveText = ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloFelhasznaloneve;
                    jelszavaText = ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloJelszava;
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
            }

            if (string.IsNullOrWhiteSpace(NeveImportData))
            {
                yield return new ValidationResult(nevError);
            }

            if (!string.IsNullOrWhiteSpace(NeveImportData) && (string.IsNullOrWhiteSpace(Vezeteknev) || string.IsNullOrWhiteSpace(Keresztnev)))
            {
                switch (TipusEnum)
                {
                    case FelhasznaloBelepesExportImportTipusEnum.Alkalmazott:
                        yield return new ValidationResult(ImportExportFelhasznaloBelepesResource.AzAlkalmazottNeveFormatumaNemMegfelelo);
                        break;

                    case FelhasznaloBelepesExportImportTipusEnum.Gondviselo:
                    case FelhasznaloBelepesExportImportTipusEnum.Tanulo:
                        yield return new ValidationResult(ImportExportFelhasznaloBelepesResource.ATanuloNeveFormatumaNemMegfelelo);
                        break;
                }
            }

            if (string.IsNullOrWhiteSpace(OktatasiAzonositoImportData))
            {
                yield return new ValidationResult(oktatasiAzonositoError);
            }
            else
            {
                switch (TipusEnum)
                {
                    case FelhasznaloBelepesExportImportTipusEnum.Tanulo:
                    case FelhasznaloBelepesExportImportTipusEnum.Gondviselo:
                        {
                            if (!Regex.Match(OktatasiAzonosito, Constants.RegularExpressions.OktatasiAzonositoTanulo).Success)
                            {
                                yield return new ValidationResult(ErrorResource.OktatasiAzonositoFormatumaNemMegfeleloTanulo);
                            }

                            break;
                        }
                    case FelhasznaloBelepesExportImportTipusEnum.Alkalmazott:
                        {
                            if (!Regex.Match(OktatasiAzonosito, Constants.RegularExpressions.OktatasiAzonosito).Success)
                            {
                                yield return new ValidationResult(ErrorResource.OktatasiAzonositoFormatumaNemMegfelelo);
                            }

                            break;
                        }
                    default:
                        throw new ArgumentOutOfRangeException();
                }
            }

            if (string.IsNullOrWhiteSpace(SzuletesiDatumaImportData))
            {
                yield return new ValidationResult(szuletesiDatumaError);
            }
            else
            {
                //NOTE: Ha az érték null, akkor a bejövő adat nem megfelelő formátumú!
                if (!SzuletesiIdo.HasValue)
                {
                    yield return new ValidationResult(string.Format(ImportExportCommonResource.InvalidDatumFormat, szuletesiDatumaError.ToLowerInvariant(), SzuletesiDatumaImportData));
                }
                else
                {
                    var minimumDate = new DateTime(Now.Date.Year - 123, 1, 1);
                    var maximumDate = new DateTime(Now.Date.Year, 1, 1);
                    var minOk = SzuletesiIdo >= minimumDate;
                    var maxOk = SzuletesiIdo <= maximumDate;
                    if (!minOk || !maxOk)
                    {
                        yield return new ValidationResult(
                            string.Format(ImportExportCommonResource.ASzuletesiIdoCsakKozeEshet,
                                minimumDate.ToString(Constants.ToStringPattern.HungarianDate),
                                maximumDate.ToString(Constants.ToStringPattern.HungarianDate)));
                    }
                }
            }

            if (TipusEnum == FelhasznaloBelepesExportImportTipusEnum.Gondviselo)
            {
                if (string.IsNullOrWhiteSpace(GondviseloNeveImportData))
                {
                    yield return new ValidationResult(string.Format(ErrorResource.Required, ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloNeve));
                }

                if (!string.IsNullOrWhiteSpace(GondviseloNeveImportData) && (string.IsNullOrWhiteSpace(GetVezeteknevFromTeljesNev(GondviseloNev)) || string.IsNullOrWhiteSpace(GetKeresztnevekFromTeljesNev(GondviseloNev))))
                {
                    yield return new ValidationResult(ImportExportFelhasznaloBelepesResource.AGondviseloNeveFormatumaNemMegfelelo);
                }

                if (string.IsNullOrWhiteSpace(GondviseloRokonsagiFokaImportData))
                {
                    yield return new ValidationResult(string.Format(ErrorResource.Required, ImportExportFelhasznaloBelepesResource.ImportHeaderNameGondviseloRokonsagiFoka));
                }
                else
                {
                    if (!GondviseloRokonsagiFokId.IsEntityId())
                    {
                        yield return new ValidationResult(string.Format(ImportExportFelhasznaloBelepesResource.NincsIlyenRokonsagiFok, GondviseloRokonsagiFokaImportData));
                    }
                }
            }

            if (string.IsNullOrWhiteSpace(FelhasznaloNeveImportData))
            {
                yield return new ValidationResult(string.Format(ErrorResource.Required, felhasznaloNeveText));
            }

            if (string.IsNullOrWhiteSpace(JelszavaImportData))
            {
                yield return new ValidationResult(string.Format(ErrorResource.Required, jelszavaText));
            }

            //NOTE: Ha van megadva bármilyen érték az import data-ban, hogy ne legyen dupla validálás a required miatt.
            if (!string.IsNullOrWhiteSpace(NeveImportData) &&
                !string.IsNullOrWhiteSpace(OktatasiAzonositoImportData) &&
                !string.IsNullOrWhiteSpace(SzuletesiDatumaImportData))
            {
                switch (TipusEnum)
                {
                    case FelhasznaloBelepesExportImportTipusEnum.Alkalmazott:
                        if (!AlkalmazottId.IsEntityId() || TanuloId.IsEntityId() || GondviseloId.IsEntityId())
                        {
                            yield return new ValidationResult(ImportExportFelhasznaloBelepesResource.AzAlkalmazottNemSzerepelAzAdatbazisban);
                        }

                        break;

                    case FelhasznaloBelepesExportImportTipusEnum.Tanulo:
                        if (AlkalmazottId.IsEntityId() || !TanuloId.IsEntityId() || GondviseloId.IsEntityId())
                        {
                            yield return new ValidationResult(ImportExportFelhasznaloBelepesResource.ATanuloNemSzerepelAzAdatbazisban);
                        }

                        break;

                    case FelhasznaloBelepesExportImportTipusEnum.Gondviselo:
                        if (AlkalmazottId.IsEntityId() || !TanuloId.IsEntityId() && !string.IsNullOrWhiteSpace(GondviseloNeveImportData) && !string.IsNullOrWhiteSpace(GondviseloRokonsagiFokaImportData) && !GondviseloId.IsEntityId())
                        {
                            yield return new ValidationResult(ImportExportFelhasznaloBelepesResource.AGondviseloNemSzerepelAzAdatbazisban);
                        }

                        break;

                    default:
                        throw new Exception();
                }
            }
        }

        #endregion Validate
    }

    public class FelhasznaloBelepesImportJsonItemCo : BaseImportJsonItemCo
    {
        public FelhasznaloBelepesImportJsonItemCo(FelhasznaloBelepesImportItemCo importItemCo, int tanevId, int intezmenyId, int felhasznaloId) : base(tanevId, intezmenyId, felhasznaloId)
        {
            string jelszoPlainText = importItemCo.JelszoPlainText;
            string salt = SaltGenerator.GenerateSalt();
            string jelszo = BasePasswordCrypter.EncodePasswordSHA1(jelszoPlainText, salt);

            Id = importItemCo.Id;

            Elotag = importItemCo.Elotag;
            Vezeteknev = importItemCo.Vezeteknev;
            Keresztnev = importItemCo.Keresztnev;
            OktatasiAzonosito = importItemCo.OktatasiAzonositoImportData;
            //NOTE: Az SzuletesiIdo.Value nem lehet null, mert ide már csak olyan elem jön be, aminek van születési ideje!
            SzuletesiIdo = importItemCo.SzuletesiIdo.Value;
            BejelentkezesiNev = importItemCo.BejelentkezesiNev;
            Jelszo = jelszo;
            JelszoPlainText = jelszoPlainText;
            Salt = salt;

            AlkalmazottId = importItemCo.AlkalmazottId;
            TanuloId = importItemCo.TanuloId;
            GondviseloId = importItemCo.GondviseloId;

            switch (importItemCo.TipusEnum)
            {
                case FelhasznaloBelepesExportImportTipusEnum.Alkalmazott:
                    //NOTE: Az AlkalmazottId.Value nem lehet null, mert ide már csak olyan elem jön be, aminek van id-ja!
                    FelhasznaloId = importItemCo.AlkalmazottId.Value;
                    IsKotelezoValtoztatni = SDAConvert.ToSDABoolean(false);
                    break;

                case FelhasznaloBelepesExportImportTipusEnum.Tanulo:
                    //NOTE: Az TanuloId.Value nem lehet null, mert ide már csak olyan elem jön be, aminek van id-ja!
                    FelhasznaloId = importItemCo.TanuloId.Value;
                    IsKotelezoValtoztatni = SDAConvert.ToSDABoolean(true);
                    break;

                case FelhasznaloBelepesExportImportTipusEnum.Gondviselo:
                    //NOTE: Az TanuloId.Value nem lehet null, mert ide már csak olyan elem jön be, aminek van id-ja!
                    FelhasznaloId = importItemCo.TanuloId.Value;
                    GondviseloNev = importItemCo.GondviseloNev;
                    GondviseloRokonsagiFokId = importItemCo.GondviseloRokonsagiFokId;
                    IsKotelezoValtoztatni = SDAConvert.ToSDABoolean(true);
                    break;
            }

            LineNumber = importItemCo.LineNumber;
            Operation = importItemCo.Operation;
        }

        #region Import Json Properties

        [JsonIgnore]
        public string Elotag { get; set; }

        [JsonIgnore]
        public string Vezeteknev { get; set; }

        [JsonIgnore]
        public string Keresztnev { get; set; }

        [JsonIgnore]
        public string GondviseloNev { get; set; }

        [JsonIgnore]
        public int? GondviseloRokonsagiFokId { get; set; }

        [JsonIgnore]
        public string OktatasiAzonosito { get; set; }

        [JsonIgnore]
        public string JelszoPlainText { get; set; }

        [JsonIgnore]
        public int? AlkalmazottId { get; set; }

        [JsonIgnore]
        public int? TanuloId { get; set; }

        [JsonIgnore]
        public DateTime SzuletesiIdo { get; set; }

        [JsonProperty("C_BEJELENTKEZESINEV")]
        public string BejelentkezesiNev { get; set; }

        [JsonProperty("C_JELSZO")]
        public string Jelszo { get; set; }

        [JsonProperty("C_FELHASZNALOID")]
        public int FelhasznaloId { get; set; }

        [JsonProperty("C_GONDVISELOID")]
        public int? GondviseloId { get; set; }

        [JsonProperty("C_SO")]
        public string Salt { get; set; }

        [JsonProperty("C_KOTELEZOVALTOZTATNI")]
        public string IsKotelezoValtoztatni { get; set; }

        #region Default Required Import Json Properties

        [JsonProperty("C_MEGHIUSULTBELEPESEK")]
        public int MeghiusultBelepesek => 0;

        [JsonProperty("C_UTOLSOBELEPES")]
        public string UtolsoBelepes => null;

        [JsonProperty("C_JELSZOVALTOZTATASIDEJE")]
        public string JelszovaltoztatasIdeje => null;

        [JsonProperty("C_NEPTUNNAPLOJELSZO")]
        public string NeptunNaploJelszo => null;

        #endregion Default Required Import Json Properties

        #endregion Import Json Properties
    }
}