using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using Kreta.BusinessLogic.Classes;
using Kreta.BusinessLogic.Validation;
using Kreta.Core;
using Kreta.Core.CustomAttributes;
using Kreta.Enums;
using Kreta.Framework.Util;
using Kreta.Resources;
using Newtonsoft.Json;

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

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

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

        [JsonIgnore]
        public List<EszkozItemCo> EszkozCoList { get; set; }

        [JsonIgnore]
        public List<AlkalmazottItemCo> FelelosCoList { get; set; }

        [JsonIgnore]
        public List<TeremItemCo> TeremCoList { get; set; }

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

            foreach (EszkozImportItemCo 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);
                }

                var teremNevToCompare = importItem.TeremNev?.ToComparableString();
                if (!string.IsNullOrWhiteSpace(teremNevToCompare))
                {
                    if (TeremCoList.All(x => x.NevComparableString != teremNevToCompare))
                    {
                        validationResultList.Add(new ValidationResult(string.Format(ImportExportEszkozResource.TeremIsNotInDatabase, importItem.TeremNev)));
                    }
                }

                //NOTE: Levalidáljuk, hogy a felelős szerepel-e az adatbázisban, ha nem üres string(illetve, ha több ugyanolyan nevű felelős szerepel, akkor megnézzük születési idő alapján is).
                //      Azért nem BlValidator-ban, mert így csak egyszer kell lekérni a tanárlistát!
                var felelosNevToCompare = importItem.FelelosNev?.ToComparableString();
                if (!string.IsNullOrWhiteSpace(felelosNevToCompare))
                {
                    if (!importItem.FelelosSzuletesiIdo.HasValue && FelelosCoList.All(x => x.FelhasznaloNyomtatasiNevComparableString != felelosNevToCompare) ||
                        importItem.FelelosSzuletesiIdo.HasValue && !FelelosCoList.Any(x => x.FelhasznaloNyomtatasiNevComparableString == felelosNevToCompare && x.FelhasznaloSzuletesiIdo == importItem.FelelosSzuletesiIdo))
                    {
                        validationResultList.Add(new ValidationResult(string.Format(ImportExportCommonResource.TanarIsNotInDatabase, importItem.EszkozSzemelyiFeleloseImportData)));
                    }

                    if (!importItem.FelelosSzuletesiIdo.HasValue && FelelosCoList.Count(x => x.FelhasznaloNyomtatasiNevComparableString == felelosNevToCompare) > 1)
                    {
                        validationResultList.Add(new ValidationResult(string.Format(ImportExportCommonResource.TanarExistsMoreTimesInDatabase, importItem.EszkozSzemelyiFeleloseImportData)));
                    }
                }

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

            Dictionary<int, string> lineNumberCompareHashDictionary = MainImportItemList.ToDictionary(x => x.LineNumber, x => x.CompareHash);
            var duplicatedRowConditonTextList = new List<string>
            {
                ImportExportEszkozResource.ImportHeaderNameEszkozNeve
            };
            ValidateDuplicatedRows(validationResultDictionary, lineNumberCompareHashDictionary, duplicatedRowConditonTextList);
            return validationResultDictionary;
        }
    }

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

        private EszkozImportItemCo() { }

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

        #region Fields

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

        #endregion Fields

        [SimpleExportColumn(NemImportalhatoSorokExportAttributeId, 00, nameof(ImportExportEszkozResource.ImportHeaderNameEszkozNeve), typeof(ImportExportEszkozResource))]
        [Required(ErrorMessageResourceName = nameof(ErrorResource.Required), ErrorMessageResourceType = typeof(ErrorResource))]
        [MaxLength(255, ErrorMessageResourceName = nameof(CommonResource.MaxLengthValidation), ErrorMessageResourceType = typeof(CommonResource))]
        [Display(Name = nameof(ImportExportEszkozResource.ImportHeaderNameEszkozNeve), ResourceType = typeof(ImportExportEszkozResource))]
        public string EszkozNeveImportData { get; set; }

        [SimpleExportColumn(NemImportalhatoSorokExportAttributeId, 01, nameof(ImportExportEszkozResource.ImportHeaderNameHelyiseg), typeof(ImportExportEszkozResource))]
        [Required(ErrorMessageResourceName = nameof(ErrorResource.Required), ErrorMessageResourceType = typeof(ErrorResource))]
        [MaxLength(255, ErrorMessageResourceName = nameof(CommonResource.MaxLengthValidation), ErrorMessageResourceType = typeof(CommonResource))]
        [Display(Name = nameof(ImportExportEszkozResource.ImportHeaderNameHelyiseg), ResourceType = typeof(ImportExportEszkozResource))]
        public string HelyisegImportData { get; set; }

        [SimpleExportColumn(NemImportalhatoSorokExportAttributeId, 02, nameof(ImportExportEszkozResource.ImportHeaderNameEszkozTipus), typeof(ImportExportEszkozResource))]
        [MaxLength(255, ErrorMessageResourceName = nameof(CommonResource.MaxLengthValidation), ErrorMessageResourceType = typeof(CommonResource))]
        [Display(Name = nameof(ImportExportEszkozResource.ImportHeaderNameEszkozTipus), ResourceType = typeof(ImportExportEszkozResource))]
        public string EszkozTipusImportData { get; set; }

        [SimpleExportColumn(NemImportalhatoSorokExportAttributeId, 03, nameof(ImportExportEszkozResource.ImportHeaderNameMennyiseg), typeof(ImportExportEszkozResource))]
        [MaxLength(5, ErrorMessageResourceName = nameof(CommonResource.MaxLengthValidation), ErrorMessageResourceType = typeof(CommonResource))]
        [Display(Name = nameof(ImportExportEszkozResource.ImportHeaderNameMennyiseg), ResourceType = typeof(ImportExportEszkozResource))]
        public string DarabszamImportData { get; set; }

        [SimpleExportColumn(NemImportalhatoSorokExportAttributeId, 04, nameof(ImportExportEszkozResource.ImportHeaderNameEszkozSzemelyiFelelose), typeof(ImportExportEszkozResource))]
        [MaxLength(255, ErrorMessageResourceName = nameof(CommonResource.MaxLengthValidation), ErrorMessageResourceType = typeof(CommonResource))]
        [Display(Name = nameof(ImportExportEszkozResource.ImportHeaderNameEszkozSzemelyiFelelose), ResourceType = typeof(ImportExportEszkozResource))]
        public string EszkozSzemelyiFeleloseImportData { get; set; }

        [SimpleExportColumn(NemImportalhatoSorokExportAttributeId, 05, nameof(ImportExportEszkozResource.ImportHeaderNameLeltariSzam), typeof(ImportExportEszkozResource))]
        [MaxLength(20, ErrorMessageResourceName = nameof(CommonResource.MaxLengthValidation), ErrorMessageResourceType = typeof(CommonResource))]
        [Display(Name = nameof(ImportExportEszkozResource.ImportHeaderNameLeltariSzam), ResourceType = typeof(ImportExportEszkozResource))]
        public string LeltariSzamImportData { get; set; }

        public string Nev => GetStringValue(EszkozNeveImportData);

        public string TeremNev => GetStringValue(HelyisegImportData);

        public int TipusId => ((int)GeneratedAdatszotarTipusEnum.EszkozTipus).GetItemIdByTypeAndName(EszkozTipusImportData, _tanevId) ?? (int)EszkozTipusEnum.na;

        public int? Darabszam => GetIntValue(DarabszamImportData, 0);

        public DateTime? FelelosSzuletesiIdo => GetSzuletesIdoFromNev(EszkozSzemelyiFeleloseImportData);

        public string FelelosNev => GetNev(EszkozSzemelyiFeleloseImportData, FelelosSzuletesiIdo);

        public string LeltariSzam => GetStringValue(LeltariSzamImportData);

        #region Validate

        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
        {
            //NOTE: Ha van megadva bármilyen érték az import data-ban, meg kell vizsgálni, hogy sikerült-e átkonvertálni a megfelelő típusra.
            if (!string.IsNullOrWhiteSpace(DarabszamImportData))
            {
                //NOTE: Ha az érték null, akkor a bejövő adat nem megfelelő formátumú!
                if (!Darabszam.HasValue)
                {
                    yield return new ValidationResult(string.Format(ImportExportCommonResource.InvalidNumberFormat, ImportExportEszkozResource.ImportHeaderNameMennyiseg.ToLowerInvariant(), DarabszamImportData));
                }
                else
                {
                    if (Darabszam < 0 || Darabszam > 99999)
                    {
                        yield return new ValidationResult(ErrorResource.ADarabszamCsakEgy0Es99999KozottiEgeszSzamLehet);
                    }
                }
            }
        }

        #endregion Validate
    }

    public class EszkozImportJsonItemCo : BaseImportJsonItemCo
    {
        public EszkozImportJsonItemCo(EszkozImportItemCo importItemCo, List<TeremItemCo> teremCoList, List<AlkalmazottItemCo> felelosCoList, int tanevId, int intezmenyId, int felhasznaloId) : base(tanevId, intezmenyId, felhasznaloId)
        {
            Nev = importItemCo.Nev;
            TeremNev = importItemCo.TeremNev;
            TeremId = teremCoList.Single(x => x.NevComparableString == importItemCo.TeremNev?.ToComparableString()).Id;
            TipusId = importItemCo.TipusId;
            //NOTE: Az Darabszam.Value nem lehet null, mert ide már csak olyan elem jön be, aminek van darabszáma!
            Darabszam = importItemCo.Darabszam.Value;
            LeltariSzam = importItemCo.LeltariSzam;
            if (!string.IsNullOrWhiteSpace(importItemCo.FelelosNev))
            {
                if (importItemCo.FelelosSzuletesiIdo.HasValue)
                {
                    FelelosNev = $"{importItemCo.FelelosNev} ({importItemCo.FelelosSzuletesiIdo.Value.ToString(Constants.ToStringPattern.HungarianDate)})";
                    FelelosId = felelosCoList.Single(x => x.FelhasznaloNyomtatasiNevComparableString == importItemCo.FelelosNev?.ToComparableString() && x.FelhasznaloSzuletesiIdo == importItemCo.FelelosSzuletesiIdo).Id;
                }
                else
                {
                    FelelosNev = importItemCo.FelelosNev;
                    FelelosId = felelosCoList.Single(x => x.FelhasznaloNyomtatasiNevComparableString == importItemCo.FelelosNev?.ToComparableString()).Id;
                }
            }
            else
            {
                FelelosNev = null;
                FelelosId = null;
            }

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

        #region Import Json Properties

        [JsonProperty("C_NEV")]
        public string Nev { get; set; }

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

        [JsonProperty("C_TEREMID")]
        public int TeremId { get; set; }

        [JsonProperty("C_TIPUS")]
        public int TipusId { get; set; }

        [JsonProperty("C_DARABSZAM")]
        public int Darabszam { get; set; }

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

        [JsonProperty("C_FELELOSID")]
        public int? FelelosId { get; set; }

        [JsonProperty("C_LELTARISZAM")]
        public string LeltariSzam { get; set; }

        #region Default Required Import Json Properties

        [JsonProperty("C_BERELT")]
        public string IsBerelt => SDAConvert.ToSDABoolean(false);

        [JsonProperty("C_HALOZATIKAPCSOLAT")]
        public string IsHalozatiKapcsolat => SDAConvert.ToSDABoolean(false);

        [JsonProperty("C_HORDOZHATO")]
        public string IsHordozhato => SDAConvert.ToSDABoolean(false);

        [JsonProperty("C_INTERNETKAPCSOLAT")]
        public string IsInternetKapcsolat => SDAConvert.ToSDABoolean(false);

        [JsonProperty("C_MULTIMEDIAS")]
        public string IsMultimedias => SDAConvert.ToSDABoolean(false);

        [JsonProperty("C_PEDAGOGUSHOZZAFERHET")]
        public string IsPedagogusHozzaferhet => SDAConvert.ToSDABoolean(false);

        [JsonProperty("C_TANULOHOZZAFERHET")]
        public string IsTanuloHozzaferhet => SDAConvert.ToSDABoolean(false);

        [JsonProperty("C_TARTOZEK")]
        public string IsTartozek => SDAConvert.ToSDABoolean(false);

        [JsonProperty("C_NEMMUKODIK")]
        public string IsNemMukodik => SDAConvert.ToSDABoolean(false);

        [JsonProperty("C_KATEGORIA")]
        public int KategoriaId => (int)EszkozKategoriaEnum.na;

        [JsonProperty("C_CELJA")]
        public int CeljaId => (int)EszkozCelEnum.na;

        [JsonProperty("C_JELLEGE")]
        public int JellegeId => (int)EszkozJellegEnum.egyedi;

        [JsonProperty("C_MENNYISEGIEGYSEG")]
        public int MennyisegiEgysegId => (int)MertekegysegTipusEnum.darab;

        #endregion Default Required Import Json Properties

        #endregion Import Json Properties
    }
}