using System;
using System.Collections.Generic;
using System.Security.Claims;
using System.Web;
using Kreta.BusinessLogic.HelperClasses;
using Kreta.BusinessLogic.Helpers;
using Kreta.BusinessLogic.Security;
using Kreta.Core.ConnectionType;
using Kreta.Enums;
using Kreta.Enums.ManualEnums;
using Kreta.Framework;
using Kreta.Framework.Util;
using Newtonsoft.Json;

namespace Kreta.Web.Security
{
    public static class ClaimData
    {
        public static string SessionId
        {
            get
            {
                return GetClaimValue(KretaClaimTypes.SessionId);
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.SessionId, value);
            }
        }

        public static bool JelszotKotelezoValtoztatni
        {
            get
            {
                var result = false;
                var val = GetClaimValue(KretaClaimTypes.JelszotKotelezoValtoztatni);
                if (bool.TryParse(val, out result))
                {
                    return result;
                }
                return result;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.JelszotKotelezoValtoztatni, value.ToString());
            }
        }

        public static string FelhasznaloNev
        {
            get
            {
                return GetClaimValue(KretaClaimTypes.FelhasznaloNev);
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.FelhasznaloNev, value);
            }
        }

        public static string Utonev
        {
            get
            {
                return GetClaimValue(KretaClaimTypes.Utonev);
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.Utonev, value);
            }
        }

        public static string Vezeteknev
        {
            get
            {
                return GetClaimValue(KretaClaimTypes.VezetekNev);
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.VezetekNev, value);
            }
        }

        public static string SzuletesiDatum
        {
            get
            {
                return GetClaimValue(KretaClaimTypes.SzuletesiDatum);
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.SzuletesiDatum, value);
            }
        }

        public static string SzuletesiHely
        {
            get
            {
                return GetClaimValue(KretaClaimTypes.SzuletesiHely);
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.SzuletesiHely, value);
            }
        }

        public static string AnyjaNeve
        {
            get
            {
                return GetClaimValue(KretaClaimTypes.AnyjaNeve);
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.AnyjaNeve, value);
            }
        }

        public static string BelepesiNev
        {
            get
            {
                return GetClaimValue(KretaClaimTypes.BelepesiNev);
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.BelepesiNev, value);
            }
        }

        public static bool IsDefaultAdminUser => string.Equals(BelepesiNev, "admin", StringComparison.OrdinalIgnoreCase);

        public static bool IsKretaTechnicalUser => string.Equals(BelepesiNev, Core.Constants.SpecialUserName.KretaTechnicalUserName, StringComparison.OrdinalIgnoreCase);

        public static string OrganizationName
        {
            get
            {
                return GetClaimValue(KretaClaimTypes.OrganizationName);
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.OrganizationName, value);
            }
        }

        public static string OrganizationShortName
        {
            get
            {
                return GetClaimValue(KretaClaimTypes.OrganizationShortName);
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.OrganizationShortName, value ?? string.Empty);
            }
        }

        public static string OrganizationCode
        {
            get
            {
                return GetClaimValue(KretaClaimTypes.OrganizationCode);
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.OrganizationCode, value);
            }
        }

        public static string OrganizationFullAddress
        {
            get
            {
                return GetClaimValue(KretaClaimTypes.OrganizationFullAddress);
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.OrganizationFullAddress, value ?? string.Empty);
            }
        }

        public static void RefreshOrganizationFullAddress(IntezmenyCO co)
        {
            if (SelectedTanevID.HasValue)
            {
                var intezmenyiAdatok = co ?? new IntezmenyHelper(new SessionConnectionType(SessionId, FelhasznaloId, IntezmenyId, IntezmenyAzonosito, SelectedTanevID.Value)).GetIntezmenyiAdatok();
                OrganizationFullAddress = string.Format("{0}{1}{2}{3}",
                !string.IsNullOrWhiteSpace(intezmenyiAdatok.Varos) ? intezmenyiAdatok.Varos : string.Empty,
                !string.IsNullOrWhiteSpace(intezmenyiAdatok.Kozterulet) ? " " + intezmenyiAdatok.Kozterulet : string.Empty,
                !string.IsNullOrWhiteSpace(intezmenyiAdatok.KozteruletJellegNev) ? " " + intezmenyiAdatok.KozteruletJellegNev : string.Empty,
                !string.IsNullOrWhiteSpace(intezmenyiAdatok.Hazszam) ? " " + intezmenyiAdatok.Hazszam : string.Empty);
            }
        }

        public static string LicenceDatum
        {
            get
            {
                return GetClaimValue(KretaClaimTypes.LicenceDatum);
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.LicenceDatum, value);
            }
        }

        public static int FelhasznaloId
        {
            get
            {
                int result = 0;
                string id = GetClaimValue(KretaClaimTypes.FelhasznaloId);
                if (int.TryParse(id, out result))
                {
                    return result;
                }
                return -1;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.FelhasznaloId, value.ToString());
            }
        }

        public static Guid FelhasznaloGuid
        {
            get
            {
                string val = GetClaimValue(KretaClaimTypes.FelhasznaloGuid);
                return !string.IsNullOrWhiteSpace(val) ? Guid.Parse(val) : Guid.Empty;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.FelhasznaloGuid, value.ToString());
            }
        }

        public static Guid FelhasznaloIdpEgyediAzonosito
        {
            get
            {
                string val = GetClaimValue(KretaClaimTypes.FelhasznaloIdpEgyediAzonosito);
                return !string.IsNullOrWhiteSpace(val) ? Guid.Parse(val) : Guid.Empty;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.FelhasznaloIdpEgyediAzonosito, value.ToString());
            }
        }

        public static Guid GondviseloIdpEgyediAzonosito
        {
            get
            {
                string val = GetClaimValue(KretaClaimTypes.GondviseloIdpEgyediAzonosito);
                return !string.IsNullOrWhiteSpace(val) ? Guid.Parse(val) : Guid.Empty;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.GondviseloIdpEgyediAzonosito, value.ToString());
            }
        }

        public static int? GondviseloId
        {
            get
            {
                int result = 0;
                string id = GetClaimValue(KretaClaimTypes.GondviseloId);
                if (int.TryParse(id, out result))
                {
                    return result;
                }
                return new int?();
            }
            set
            {
                if (value.HasValue)
                {
                    ClaimManager.AddClaim(KretaClaimTypes.GondviseloId, value.ToString());
                }
            }
        }

        public static string GondviseloNeve
        {
            get
            {
                return GetClaimValue(KretaClaimTypes.GondviseloNeve);
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.GondviseloNeve, value);
            }
        }

        public static int IntezmenyId
        {
            get
            {
                int result = 0;
                string id = GetClaimValue(KretaClaimTypes.IntezmenyId);
                if (int.TryParse(id, out result))
                {
                    return result;
                }
                return -1;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.IntezmenyId, value.ToString());
            }
        }

        public static bool IntezmenytValasztott
        {
            get
            {
                bool result = false;
                string id = GetClaimValue(KretaClaimTypes.IntezmenytValasztott);
                if (bool.TryParse(id, out result))
                {
                    return result;
                }
                return false;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.IntezmenytValasztott, value.ToString());
            }
        }

        public static string IntezmenyAzonosito
        {
            get
            {
                return GetClaimValue(KretaClaimTypes.IntezmenyAzonosito);
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.IntezmenyAzonosito, value);
            }
        }

        public static bool IsKlebelsberg
        {
            get
            {
                bool result = false;
                string isKlebelsberg = GetClaimValue(KretaClaimTypes.IsKlebelsberg);
                if (bool.TryParse(isKlebelsberg, out result))
                {
                    return result;
                }
                return false;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.IsKlebelsberg, value.ToString());
            }
        }

        public static Guid? IntezmenyGuid
        {
            get
            {
                string val = GetClaimValue(KretaClaimTypes.IntezmenyGuid);
                return !string.IsNullOrWhiteSpace(val) ? (Guid?)Guid.Parse(val) : null;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.IntezmenyGuid, value.ToString());
            }
        }

        public static int? AktivTanevID
        {
            get
            {
                int result = 0;
                string id = GetClaimValue(KretaClaimTypes.AktivTanevID);
                if (int.TryParse(id, out result))
                {
                    return result;
                }
                return (int?)null;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.AktivTanevID, value.ToString());
            }
        }

        public static string AktivTanevNev
        {
            get
            {
                return GetClaimValue(KretaClaimTypes.AktivTanevNev);
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.AktivTanevNev, value.ToString());
            }
        }

        public static int? KovTanevID
        {
            get
            {
                int result = 0;
                string id = GetClaimValue(KretaClaimTypes.KovTanevID);
                if (int.TryParse(id, out result))
                {
                    return result;
                }
                return (int?)null;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.KovTanevID, value.ToString());
            }
        }

        public static int? PrevTanevID
        {
            get
            {
                int result = 0;
                string id = GetClaimValue(KretaClaimTypes.PrevTanevID);
                if (int.TryParse(id, out result))
                {
                    return result;
                }
                return (int?)null;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.PrevTanevID, value.ToString());
            }
        }

        public static int LanguageIndex
        {
            get
            {
                int result = 0;
                string id = GetClaimValue(KretaClaimTypes.LanguageIndex);
                int.TryParse(id, out result);
                return result;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.LanguageIndex, value.ToString());
            }
        }

        public static int LCID
        {
            get
            {
                int result = 0;
                string id = GetClaimValue(KretaClaimTypes.LCID);
                int.TryParse(id, out result);
                return result > 0 ? result : 1038;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.LCID, value.ToString());
            }
        }

        public static string LanguageCode
        {
            get
            {
                return GetClaimValue(KretaClaimTypes.LanguageCode);
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.LanguageCode, value.ToString());
            }
        }

        public static bool? isBlindMode
        {
            get
            {
                var result = false;
                var val = GetClaimValue(KretaClaimTypes.IsBlindMode);
                if (bool.TryParse(val, out result))
                {
                    return result;
                }
                return new bool?();
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.IsBlindMode, value.ToString());
            }
        }

        public static bool JustLEPOrganization
        {
            get
            {
                bool result = false;
                string id = GetClaimValue(KretaClaimTypes.JustLEPOrganization);
                if (bool.TryParse(id, out result))
                {
                    return result;
                }
                return false;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.JustLEPOrganization, value.ToString());
            }
        }

        public static Dictionary<SzerepkorTipusEnum, string> FelhasznaloSzerepkorok
        {
            get
            {
                var roles = GetClaimValue(KretaClaimTypes.FelhasznaloSzerepkorok);
                Dictionary<SzerepkorTipusEnum, string> result = null;
                if (string.IsNullOrWhiteSpace(roles))
                {
                    var helper = new FelhasznaloHelper(new SessionConnectionType(SessionId, FelhasznaloId, IntezmenyId, IntezmenyAzonosito, AktivTanevID.Value));
                    result = helper.GetFelhasznaloiSzerepkorok(IntezmenyiDictionaryEnvironmentName);
                    ClaimManager.AddClaim(KretaClaimTypes.FelhasznaloSzerepkorok, JsonConvert.SerializeObject(result));

                }
                else
                {
                    result = JsonConvert.DeserializeObject<Dictionary<SzerepkorTipusEnum, string>>(roles);
                }

                return result;
            }
        }

        public static List<string> FelhasznaloSzerepCsomagok
        {
            get
            {
                var packages = GetClaimValue(KretaClaimTypes.Package);
                if (string.IsNullOrWhiteSpace(packages))
                {
                    return new List<string>();
                }

                return JsonConvert.DeserializeObject<List<string>>(packages);
            }
        }

        private static List<OktNevelesiKategoriaEnum> FeladatKategoriakAktiv
        {
            get
            {
                var packages = GetClaimValue(KretaClaimTypes.FeladatKategoriakAktiv);
                if (string.IsNullOrWhiteSpace(packages))
                {
                    return new List<OktNevelesiKategoriaEnum>();
                }

                return JsonConvert.DeserializeObject<List<OktNevelesiKategoriaEnum>>(packages);
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.FeladatKategoriakAktiv, JsonConvert.SerializeObject(value));
            }
        }

        private static List<OktNevelesiKategoriaEnum> FeladatKategoriakKovetkezo
        {
            get
            {
                var packages = GetClaimValue(KretaClaimTypes.FeladatKategoriakKovetkezo);
                if (string.IsNullOrWhiteSpace(packages))
                {
                    return new List<OktNevelesiKategoriaEnum>();
                }

                return JsonConvert.DeserializeObject<List<OktNevelesiKategoriaEnum>>(packages);
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.FeladatKategoriakKovetkezo, JsonConvert.SerializeObject(value));
            }
        }

        public static SzerepkorTipusEnum FelhasznaloSzerepkor
        {
            get
            {
                var szerepkorszoveg = GetClaimValue(KretaClaimTypes.KretaFelhasznaloSzerepkor);
                if (string.IsNullOrWhiteSpace(szerepkorszoveg))
                    return SzerepkorTipusEnum.Nincs_beallitva;

                return szerepkorszoveg.EnumParse<SzerepkorTipusEnum>();
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.KretaFelhasznaloSzerepkor, value.ToString());
            }
        }

        public static int PackageCacheHash
        {
            get
            {
                int result = 0;
                string id = GetClaimValue(KretaClaimTypes.PackageCacheHash);
                int.TryParse(id, out result);
                return result;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.PackageCacheHash, value.ToString());
            }
        }

        private static string GetClaimValue(string type)
        {
            var identity = Identity;
            if (identity == null)
                return null;
            if (!identity.IsAuthenticated)
                return null;

            string result = null;
            identity.TryGetClaimValue(type, out result);

            return result;
        }

        public static ClaimsIdentity Identity
        {
            get
            {
                if (HttpContext.Current == null)
                    return null;
                if (HttpContext.Current.User == null)
                    return null;
                var identity = ClaimManager.GetClaimIdentity();
                return identity;
            }
        }

        public static bool IsAuthenticated
        {
            get
            {
                var identity = Identity;
                if (identity == null)
                    return false;
                return identity.IsAuthenticated;
            }
        }

        public static KliensTipusEnum KliensTipusa
        {
            get
            {
                var klienstipusszovege = GetClaimValue(KretaClaimTypes.KliensTipus);
                if (string.IsNullOrWhiteSpace(klienstipusszovege))
                    return KliensTipusEnum.Browser;

                return klienstipusszovege.EnumParse<KliensTipusEnum>();
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.KliensTipus, value.ToString());
            }
        }

        public static bool IsOsztalyfonok
        {
            get
            {
                var role = FelhasznaloSzerepkor;
                var package = FelhasznaloSzerepCsomagok;

                if (role.Equals(SzerepkorTipusEnum.Naplo))
                {
                    if (package.Contains(KretaClaimPackages.Osztalyfonok.ClaimValue) || package.Contains(KretaClaimPackages.SzuperOsztalyfonok.ClaimValue))
                    {
                        return true;
                    }
                }

                return false;
            }
        }

        public static bool IsOnlyTanar
        {
            get
            {
                var role = FelhasznaloSzerepkor;
                var package = FelhasznaloSzerepCsomagok;

                if (role.Equals(SzerepkorTipusEnum.Naplo))
                {
                    if (package.Contains(KretaClaimPackages.Tanar.ClaimValue) && !(package.Contains(KretaClaimPackages.Osztalyfonok.ClaimValue) || package.Contains(KretaClaimPackages.SzuperOsztalyfonok.ClaimValue)))
                    {
                        return true;
                    }
                }

                return false;
            }
        }

        public static bool IsOnlyAlkalmazott
        {
            get
            {
                var role = FelhasznaloSzerepkor;
                var package = FelhasznaloSzerepCsomagok;

                if (role.Equals(SzerepkorTipusEnum.alkalmazott))
                {
                    return true;
                }

                return false;
            }
        }

        public static bool IsTanuloOrGondviselo
        {
            get
            {
                var package = FelhasznaloSzerepCsomagok;

                if (package.Contains(KretaClaimPackages.Tanulo.ClaimValue) || package.Contains(KretaClaimPackages.Gondviselo.ClaimValue))
                {
                    return true;
                }

                return false;
            }
        }

        public static bool IsSzuperOsztalyfonok
        {
            get
            {
                var role = FelhasznaloSzerepkor;
                var package = FelhasznaloSzerepCsomagok;

                if (role.Equals(SzerepkorTipusEnum.Naplo))
                {
                    if (package.Contains(KretaClaimPackages.SzuperOsztalyfonok.ClaimValue))
                    {
                        return true;
                    }
                }

                return false;
            }
        }

        public static bool IsNaploAdministrator
        {
            get
            {
                var role = FelhasznaloSzerepkor;
                var package = FelhasznaloSzerepCsomagok;

                if (role.Equals(SzerepkorTipusEnum.Naplo))
                {
                    if (package.Contains(KretaClaimPackages.Adminisztrator.ClaimValue) || package.Contains(KretaClaimPackages.Szuperadmin.ClaimValue))
                    {
                        return true;
                    }
                }

                return false;
            }
        }

        public static bool IsAdministrator
        {
            get
            {
                var package = FelhasznaloSzerepCsomagok;
                if (package.Contains(KretaClaimPackages.Adminisztrator.ClaimValue) || package.Contains(KretaClaimPackages.Szuperadmin.ClaimValue))
                {
                    return true;
                }
                return false;
            }
        }

        public static bool IsSzuperadmin
        {
            get
            {
                var package = FelhasznaloSzerepCsomagok;
                if (package.Contains(KretaClaimPackages.Szuperadmin.ClaimValue))
                {
                    return true;
                }
                return false;
            }
        }

        public static bool IsKretaAdministrator
        {
            get
            {
                var package = FelhasznaloSzerepCsomagok;
                if (FelhasznaloNev == Core.Constants.SpecialUserName.KretaAdminisztrator &&
                    package.Contains(KretaClaimPackages.Adminisztrator.ClaimValue) &&
                    package.Contains(KretaClaimPackages.Szuperadmin.ClaimValue))
                {
                    return true;
                }
                return false;
            }
        }

        public static bool IsGazdasagiUgyintezo
        {
            get
            {
                var roles = FelhasznaloSzerepkorok;
                var package = FelhasznaloSzerepCsomagok;

                if (roles.ContainsKey(SzerepkorTipusEnum.GazdasagiUgyintezo))
                {
                    if (package.Contains(KretaClaimPackages.GazdasagiUgyintezo.ClaimValue))
                    {
                        return true;
                    }
                }

                return false;
            }
        }

        public static bool IsModosithatjaOsztfoMulasztasokat
        {
            get
            {
                var package = FelhasznaloSzerepCsomagok;
                return package.Contains(KretaClaimPackages.IsModosithatjaOsztfoMulasztasokat.ClaimValue);
            }
        }

        public static bool IsFullKretaVerzio
        {
            get
            {
                bool result = false;
                string id = GetClaimValue(KretaClaimTypes.IsFullKretaVerzio);
                if (bool.TryParse(id, out result))
                {
                    return result;
                }
                return false;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.IsFullKretaVerzio, value.ToString());
            }
        }

        public static bool IsAlkalmazottPedagogus
        {
            get
            {
                string boolString = GetClaimValue(KretaClaimTypes.IsAlkalmazottPedagogus);
                bool isAlkalmazottPedagogusClaim;
                bool.TryParse(boolString, out isAlkalmazottPedagogusClaim);
                var package = FelhasznaloSzerepCsomagok;
                bool result = isAlkalmazottPedagogusClaim && (package.Contains(KretaClaimPackages.Tanar.ClaimValue) || package.Contains(KretaClaimPackages.Osztalyfonok.ClaimValue) || package.Contains(KretaClaimPackages.SzuperOsztalyfonok.ClaimValue));
                return result;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.IsAlkalmazottPedagogus, value.ToString());
            }
        }

        public static int? FelhelySzuro
        {
            get
            {
                int result = 0;
                string id = GetClaimValue(KretaClaimTypes.FelhelySzuro);
                if (int.TryParse(id, out result))
                {
                    return result;
                }
                return (int?)null;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.FelhelySzuro, value.ToString());
            }
        }

        public static bool IsBeiratkozasVeglegesitve
        {
            get
            {
                bool result;
                string boolString = GetClaimValue(KretaClaimTypes.IsBeiratkozasVeglegesitve);
                if (bool.TryParse(boolString, out result))
                {
                    return result;
                }
                return false;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.IsBeiratkozasVeglegesitve, value.ToString());
            }
        }

        public static int? SelectedTanevID
        {
            get
            {
                int result = 0;
                string id = GetClaimValue(KretaClaimTypes.SelectedTanevID);
                if (int.TryParse(id, out result))
                {
                    return result;
                }
                return (int?)null;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.SelectedTanevID, value.ToString());
            }
        }

        public static bool IsActivTanev
        {
            get
            {
                return SelectedTanevID == AktivTanevID;
            }

        }

        public static bool IsKovTanev
        {
            get
            {
                return SelectedTanevID == KovTanevID;
            }

        }

        public static List<OktNevelesiKategoriaEnum> FeladatKategoriak
        {
            get
            {
                if (IsActivTanev)
                {
                    if (FeladatKategoriakAktiv == null || FeladatKategoriakAktiv.Count == 0)
                    {
                        FeladatKategoriakAktiv = new FeladatEllatasiHelyHelper(new SessionConnectionType(SessionId, FelhasznaloId, IntezmenyId, IntezmenyAzonosito, AktivTanevID.Value)).GetFeladatKategoriak();
                    }

                    return FeladatKategoriakAktiv;
                }

                if (KovTanevID.HasValue && KovTanevID == SelectedTanevID)
                {
                    if (FeladatKategoriakKovetkezo == null || FeladatKategoriakKovetkezo.Count == 0)
                    {
                        FeladatKategoriakKovetkezo = new FeladatEllatasiHelyHelper(new SessionConnectionType(SessionId, FelhasznaloId, IntezmenyId, IntezmenyAzonosito, KovTanevID.Value)).GetFeladatKategoriak();
                    }

                    return FeladatKategoriakKovetkezo;
                }

                return new FeladatEllatasiHelyHelper(new SessionConnectionType(SessionId, FelhasznaloId, IntezmenyId, IntezmenyAzonosito, SelectedTanevID.Value)).GetFeladatKategoriak();
            }
        }

        public static bool IsVegyes
        {
            get
            {
                return FeladatKategoriak.Count > 1;
            }
        }

        public static bool HasAmi
        {
            get
            {
                return FeladatKategoriak.Contains(OktNevelesiKategoriaEnum.AlapfokuMuveszetoktatas);
            }
        }

        public static bool HasKollegium
        {
            get
            {
                return FeladatKategoriak.Contains(OktNevelesiKategoriaEnum.Kollegium);
            }
        }

        public static bool HasFelnottkepzes
        {
            get
            {
                return FeladatKategoriak.Contains(OktNevelesiKategoriaEnum.Felnottkepzes);
            }
        }

        public static bool HasEGYMI
        {
            get
            {
                return FeladatKategoriak.Contains(OktNevelesiKategoriaEnum.EGYMI);
            }
        }

        public static int NemNaplozottTanorakCount
        {
            get
            {
                string count = GetClaimValue(KretaClaimTypes.NemNaplozottTanorakCount);
                if (int.TryParse(count, out int result))
                {
                    return result;
                }

                var newCount = SetNemNaplozottTanorakCount();
                ClaimManager.AddClaim(KretaClaimTypes.NemNaplozottTanorakCount, newCount.ToString());

                return newCount;
            }
            set
            {
                if (value >= 0)
                {
                    ClaimManager.AddClaim(KretaClaimTypes.NemNaplozottTanorakCount, value.ToString());
                }
            }
        }

        public static int SetNemNaplozottTanorakCount()
        {
            int count = 0;
            try
            {
                var connectionType = new SessionConnectionType(SessionId, FelhasznaloId, IntezmenyId, IntezmenyAzonosito, SelectedTanevID.Value);

                DateTime tanevKezdDatum;
                TanevHelper tanevHelper = new TanevHelper(connectionType);
                tanevKezdDatum = tanevHelper.GetTanevInfo().OraFelvetelKezdete;
                count = new OrarendiOraHelper(connectionType).GetNemNaplozottTanorakCount(tanevKezdDatum, FelhasznaloId);
            }
            catch (Exception e)
            {
                SDAServer.Instance.Logger.ExceptionThrown(e, UserContext.Instance.ClientIP);
            }

            return count;
        }

        public static bool IsAktivUzenetekMenu
        {
            get
            {
                bool result = false;
                string id = GetClaimValue(KretaClaimTypes.IsAktivUzenetekMenu);
                if (bool.TryParse(id, out result))
                {
                    return result;
                }
                return false;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.IsAktivUzenetekMenu, value.ToString());
            }
        }

        public static bool IsCsokkentettTanuloLEP
        {
            get
            {
                var data = GetClaimValue(KretaClaimTypes.CsokkentettTanuloLEP);
                return data != null && data.Contains(IntezmenyAzonosito);
            }
        }

        public static bool IsSzirIntezmeny
        {
            get
            {
                bool result;
                string boolString = GetClaimValue(KretaClaimTypes.IsSzirIntezmeny);
                return bool.TryParse(boolString, out result) && result;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.IsSzirIntezmeny, value.ToString());
            }
        }

        public static bool IsSelectedTanev20_21OrLater
        {
            get
            {
                bool result;
                string boolString = GetClaimValue(KretaClaimTypes.IsSelectedTanev20_21OrLater);
                return bool.TryParse(boolString, out result) && result;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.IsSelectedTanev20_21OrLater, value.ToString());
            }
        }

        public static bool IsSelectedTanev21_22OrLater
        {
            get
            {
                bool result;
                string boolString = GetClaimValue(KretaClaimTypes.IsSelectedTanev21_22OrLater);
                return bool.TryParse(boolString, out result) && result;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.IsSelectedTanev21_22OrLater, value.ToString());
            }
        }

        public static bool IsSelectedTanevIsElozo
        {
            get
            {
                bool result;
                string boolString = GetClaimValue(KretaClaimTypes.IsSelectedTanevIsElozo);
                return bool.TryParse(boolString, out result) && result;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.IsSelectedTanevIsElozo, value.ToString());
            }
        }

        public static bool IsArchivIntezmeny
        {
            get
            {
                bool result;
                string boolString = GetClaimValue(KretaClaimTypes.IsArchivIntezmeny);
                if (bool.TryParse(boolString, out result))
                {
                    return result;
                }
                return false;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.IsArchivIntezmeny, value.ToString());
            }
        }

        public static bool IsArchivAdminUser
        {
            get
            {
                bool result;
                string boolString = GetClaimValue(KretaClaimTypes.IsArchivAdminUser);
                if (bool.TryParse(boolString, out result))
                {
                    return result;
                }
                return false;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.IsArchivAdminUser, value.ToString());
            }
        }

        public static bool IsSzakkepzoIntezmeny
        {
            get
            {
                string boolString = GetClaimValue(KretaClaimTypes.IsSzakkepzoIntezmeny);
                if (bool.TryParse(boolString, out bool result))
                {
                    return result;
                }

                return false;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.IsSzakkepzoIntezmeny, value.ToString());
            }
        }

        public static bool IsNszfhIntezmeny
        {
            get
            {
                string boolString = GetClaimValue(KretaClaimTypes.IsNszfhIntezmeny);
                if (bool.TryParse(boolString, out bool result))
                {
                    return result;
                }

                return false;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.IsNszfhIntezmeny, value.ToString());
            }
        }

        public static string IntezmenyiDictionaryEnvironmentName
        {
            get
            {
                return GetClaimValue(KretaClaimTypes.IntezmenyiDictionaryEnvironmentName);
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.IntezmenyiDictionaryEnvironmentName, value);
            }
        }

        public static bool IsPortas
        {
            get
            {
                string boolString = GetClaimValue(KretaClaimTypes.IsPortas);
                if (bool.TryParse(boolString, out bool result))
                {
                    return result;
                }

                return false;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.IsPortas, value.ToString());
            }
        }

        public static bool EszkozKezelesEnabled
        {
            get
            {
                string eszkozKezelesEnabled = GetClaimValue(KretaClaimTypes.EszkozKezelesEnabled);
                if (bool.TryParse(eszkozKezelesEnabled, out bool result))
                {
                    return result;
                }
                return false;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.EszkozKezelesEnabled, value.ToString());
            }
        }

        public static bool FeltarAlkalmazottEnabled
        {
            get
            {
                string feltarAlkalmazottEnabled = GetClaimValue(KretaClaimTypes.FeltarAlkalmazottEnabled);
                if (bool.TryParse(feltarAlkalmazottEnabled, out bool result))
                {
                    return result;
                }
                return false;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.FeltarAlkalmazottEnabled, value.ToString());
            }
        }

        public static bool FeltarGondviseloEnabled
        {
            get
            {
                string feltarGondviseloEnabled = GetClaimValue(KretaClaimTypes.FeltarGondviseloEnabled);
                if (bool.TryParse(feltarGondviseloEnabled, out bool result))
                {
                    return result;
                }
                return false;
            }
            set
            {
                ClaimManager.AddClaim(KretaClaimTypes.FeltarGondviseloEnabled, value.ToString());
            }
        }

        public static bool ModifyTanuloAlapAdatok
        {
            get
            {
                var identity = ClaimManager.GetClaimIdentity();

                return !IsOsztalyfonok || identity.HasResource(KretaClaimPackages.Osztalyfonok.Resources.Osztalyfonok_modosithatja_osztalyaba_jaro_tanulok_adatait);
            }
        }

        public static bool OfoManageSportoloiAdatok
        {
            get
            {
                var identity = ClaimManager.GetClaimIdentity();

                return IsOsztalyfonok && identity.HasResource(KretaClaimPackages.Osztalyfonok.Resources.Osztalyfonok_megtekintheti_kezelheti_az_osztalyaba_jaro_tanulok_sportoloi_adatait);
            }
        }

        public static bool OfoManageSNIBTMAdatok
        {
            get
            {
                var identity = ClaimManager.GetClaimIdentity();

                return IsOsztalyfonok && identity.HasResource(KretaClaimPackages.Osztalyfonok.Resources.Osztalyfonok_megtekintheti_modosithatja_osztalyaba_jaro_tanulok_szocialis_tanugyi_es_SNI_BTM_adatait);
            }
        }

        public static bool OfoManageVallasiAdatok
        {
            get
            {
                var identity = ClaimManager.GetClaimIdentity();

                return IsOsztalyfonok && identity.HasResource(KretaClaimPackages.Osztalyfonok.Resources.Osztalyfonok_megtekintheti_kezelheti_az_osztalyaba_jaro_tanulok_vallasi_adatait);
            }
        }

        // KRETA2-12558 makkt - később ki kell majd venni ha nem szükségs, de akár még hasznos is lehet!
        public static bool IsDualisOktato
        {
            get
            {
                var isNaplo = ClaimData.FelhasznaloSzerepkor == SzerepkorTipusEnum.Naplo;
                var hasDualisOktatoClaimPackage = ClaimData.FelhasznaloSzerepCsomagok.Contains(KretaClaimPackages.IsDualisKepzohelyiOktato.ClaimValue);
                return isNaplo && hasDualisOktatoClaimPackage;
            }
        }
    }
}