using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Xml.Serialization;
using Kreta.BusinessLogic.Classes;
using Kreta.BusinessLogic.HelperClasses;
using Kreta.BusinessLogic.Helpers.SystemSettings;
using Kreta.BusinessLogic.Utils;
using Kreta.Core;
using Kreta.Core.ConnectionType;
using Kreta.DataAccess.Interfaces;
using Kreta.DataAccessManual;
using Kreta.DataAccessManual.Interfaces;
using Kreta.DataAccessManual.Util;
using Kreta.Enums;
using Kreta.Enums.ManualEnums;
using Kreta.Enums.ManualEnums.SystemSettings;
using Kreta.Framework;
using Kreta.Framework.Security.PasswordCrypting;
using Kreta.Resources;

namespace Kreta.BusinessLogic.Helpers
{
    public class HozzaferesGeneralasaHelper : LogicBase
    {
        public HozzaferesGeneralasaHelper(IConnectionType connectionType) : base(connectionType) { }

        #region Tanuló azonosító generálás

        public BelepesiAdatokListCO TanuloAzonositoGeneralas(List<int> tanuloIdList, bool isPasswordReset, int modositoUserId, bool csakAkiknekNincsAzonositojuk = true, bool emailKuldesSzukseges = false, bool toroltFelhasznaloBelepes = false)
        {
            var belepesiAdatokPdfGeneralasList = new BelepesiAdatokListCO();
            var belepesiAdatokList = new BelepesiAdatokListCO();

            var felhasznaloNevGeneralasModja = (int)FelhasznaloiNevGeneralasModjaEnum.Oktatasi_azonosito_alapjan;
            var felhasznaloNevGeneralasAlap = "C_OKTATASIAZONOSITO";

            return Dal.CustomConnection.Run(ConnectionType, h =>
            {
                var tanuloGondviseloBelepesList = new List<DataRow>();

                if (tanuloIdList != null && tanuloIdList.Count > 0)
                {
                    tanuloGondviseloBelepesList = h.Tanulo(GridParameters).GetTanulokForBelepesiAzonositoGeneralas(IntezmenyId, TanevId, tanuloIdList, false, false, toroltFelhasznaloBelepes).Tables[0].AsEnumerable().OrderBy(x => x.Field<string>(felhasznaloNevGeneralasAlap)).ToList();
                }
                else
                {
                    tanuloGondviseloBelepesList = h.Tanulo(GridParameters).GetTanulokForBelepesiAzonositoGeneralas(IntezmenyId, TanevId, tanuloIdList, false, csakAkiknekNincsAzonositojuk && !isPasswordReset, toroltFelhasznaloBelepes).Tables[0].AsEnumerable().OrderBy(x => x.Field<string>(felhasznaloNevGeneralasAlap)).ToList();
                }

                var jelszoGeneralasModja = (int)new SystemSettingsHelper(new DalHandlerConnectionType(ConnectionType, h)).GetSystemSettingValue<JelszoGeneralasModjaEnum>(RendszerBeallitasTipusEnum.Tanuloi_jelszavak_generalasa_az_alabbi_ertek_alapjan);

                if ((felhasznaloNevGeneralasModja == (int)FelhasznaloiNevGeneralasModjaEnum.Egyeni) || jelszoGeneralasModja == (int)JelszoGeneralasModjaEnum.Egyeni)
                {
                    belepesiAdatokPdfGeneralasList.ErrorList.Add("-1");
                    belepesiAdatokPdfGeneralasList.ErrorList.Add(FelhasznaloBelepesResource.EgyeniMegadasSzerepelARendszerbeallitasoknalIgyAFelhasznalonevetEsJelszotATanuloknalAllithatjaBe);
                }
                else
                {
                    var tanulok = isPasswordReset
                        ? tanuloGondviseloBelepesList.Where(x =>
                            (!string.IsNullOrWhiteSpace(x.Field<string>("C_BEJELENTKEZESINEV")) &&
                             (x.Field<int?>("C_GONDVISELOID") == null)))
                        : tanuloGondviseloBelepesList.Where(x => x.Field<int?>("C_GONDVISELOID") == null);
                    List<DataRow> tanulokList = tanulok.ToList();

                    var uresBejelentkezesiNevesTanulok = new List<string>();
                    if (isPasswordReset)
                    {
                        uresBejelentkezesiNevesTanulok.AddRange(tanuloGondviseloBelepesList.Where(x => string.IsNullOrWhiteSpace(x.Field<string>("C_BEJELENTKEZESINEV")) && (x.Field<int?>("C_GONDVISELOID") == null))
                            .Select(x => x.Field<string>("C_TANULONEV")));
                    }

                    if (uresBejelentkezesiNevesTanulok.Any())
                    {
                        var msg = string.Format(ErrorResource.TanulokNemRendelkeznekFelhasznalonevvelJelszoUjrageneralashoz, string.Join(", ", uresBejelentkezesiNevesTanulok));
                        belepesiAdatokPdfGeneralasList.ErrorList.Add(msg);
                        belepesiAdatokPdfGeneralasList.IsUresFelhasznaloNevError = true;
                        return belepesiAdatokPdfGeneralasList;
                    }

                    if (!isPasswordReset)
                    {
                        var oktatasiAzonositoNelkuliTanulok = new List<string>();
                        oktatasiAzonositoNelkuliTanulok.AddRange(tanuloGondviseloBelepesList.Where(x => string.IsNullOrWhiteSpace(x.Field<string>("C_OKTATASIAZONOSITO")) && (x.Field<int?>("C_GONDVISELOID") == null))
                            .Select(x => x.Field<string>("C_TANULONEV")));
                        if (oktatasiAzonositoNelkuliTanulok.Any())
                        {
                            var msg = string.Format(ErrorResource.FelhasznalonevGeneralasNemLehetsegesMertNincsMegadvaOktatasiAzonositoTanuloNeveOktatasiAzonosito, string.Join(", ", oktatasiAzonositoNelkuliTanulok));
                            belepesiAdatokPdfGeneralasList.ErrorList.Add(msg);
                            belepesiAdatokPdfGeneralasList.IsUresOktatasiAzonositoError = true;
                            return belepesiAdatokPdfGeneralasList;
                        }
                    }

                    var intezmenyCo = new IntezmenyHelper(new DalHandlerConnectionType(ConnectionType, h)).GetAktivIntezmenyNevCim();
                    JelszoModositasLinkHelper jelszoModositasLinkHelper = new JelszoModositasLinkHelper(new DalHandlerConnectionType(ConnectionType, h));
                    foreach (var tanulo in tanulok)
                    {
                        string currentError = string.Empty;
                        if (!isPasswordReset)
                        {
                            currentError = CheckTanuloAdatok(tanulo, tanulokList, felhasznaloNevGeneralasModja, true,
                                tanuloGondviseloBelepesList);
                        }

                        var belepesAdat = new BelepesiAdatok
                        {
                            Id = tanulo.Field<int>("C_TANULOID"),
                            Password = jelszoGeneralasModja == (int)JelszoGeneralasModjaEnum.Veletlenszeru
                                ? CommonUtils.GenerateJelszo()
                                : tanulo.Field<DateTime>("C_SZULETESIDATUM").Date.ToString("yyyy'-'MM'-'dd"),
                            GondviseloId = -1,
                            NemGeneralhato = "F",
                            Osztaly = tanulo.Field<string>("C_OSZTALYNEV"),
                            TanuloNev = tanulo.Field<string>("C_TANULONEV"),
                            UserName = tanulo.Field<string>("C_BEJELENTKEZESINEV")
                        };
                        if (!isPasswordReset)
                        {
                            belepesAdat.UserName = tanulo.Field<string>(felhasznaloNevGeneralasAlap);
                        }

                        if (!string.IsNullOrWhiteSpace(currentError))
                        {
                            belepesAdat.NemGeneralhato = "T";
                            belepesiAdatokPdfGeneralasList.ErrorList.Add(currentError);
                        }

                        belepesiAdatokPdfGeneralasList.BelepesiAdatokList.Add(belepesAdat);

                        if (emailKuldesSzukseges)
                        {
                            var tanuloEntity = h.Tanulo().Get(belepesAdat.Id);
                            var email = tanuloEntity.Email.FirstOrDefault(x => !x.Torolt && !x.IsHibasanMegadva && x.Alapertelmezett && x.Gondviselo == null);
                            if (email != null && !string.IsNullOrWhiteSpace(email.EmailCim))
                            {
                                var message = string.Format(EmailResource.UjTanuloBelepesiAdatokGeneralasErtesitesEmail, tanuloEntity.NyomtatasiNev, tanuloEntity.NyomtatasiNev,
                                    tanuloEntity.OktatasiAzonosito, CommonUtils.GetIntezmenyUrl(IntezmenyAzonosito), intezmenyCo.Nev, intezmenyCo.IntezmenyCim, "{0}");
                                jelszoModositasLinkHelper.FelhasznaloBelepesLinkGeneralasEsKuldes(tanuloEntity.ID,
                                    null, email.EmailCim, message, email.Guid);
                            }
                            else
                            {
                                belepesiAdatokPdfGeneralasList.EmailErrors +=
                                    $"{tanuloEntity.NyomtatasiNev} - {tanuloEntity.OktatasiAzonosito}{Constants.General.Sortores}";
                            }
                        }
                    }

                    if (csakAkiknekNincsAzonositojuk && !isPasswordReset)
                    {
                        // kiszedni azokat amelyeknek nincs felhasznalojuk de van gondviselofelhasznalojuk
                        var tanulokWithOutBelepesWithGondviseloList = h.Tanulo(GridParameters)
                                    .GetTanulokWithOutBelepesWithGondviselo(IntezmenyId,
                                        TanevId, tanuloIdList, false).Tables[0].AsEnumerable()
                                    .OrderBy(x => x.Field<string>(felhasznaloNevGeneralasAlap)).ToList();

                        foreach (DataRow tanuloWithOutBelepesWithGondviselo in tanulokWithOutBelepesWithGondviseloList)
                        {
                            if (!tanulok.Select(x => x.Field<int>("C_TANULOID"))
                                .Contains(tanuloWithOutBelepesWithGondviselo.Field<int>("C_TANULOID")))
                            {
                                string currentError = string.Empty;
                                currentError = CheckTanuloAdatok(tanuloWithOutBelepesWithGondviselo, tanulokList,
                                    felhasznaloNevGeneralasModja, true, tanuloGondviseloBelepesList);
                                var belepesAdat = new BelepesiAdatok
                                {
                                    Id = tanuloWithOutBelepesWithGondviselo.Field<int>("C_TANULOID"),
                                    Password = jelszoGeneralasModja == (int)JelszoGeneralasModjaEnum.Veletlenszeru
                                        ? CommonUtils.GenerateJelszo()
                                        : tanuloWithOutBelepesWithGondviselo.Field<DateTime>("C_SZULETESIDATUM").Date
                                            .ToString("yyyy'-'MM'-'dd"),
                                    GondviseloId = -1,
                                    NemGeneralhato = "F",
                                    Osztaly = tanuloWithOutBelepesWithGondviselo.Field<string>("C_OSZTALYNEV"),
                                    TanuloNev = tanuloWithOutBelepesWithGondviselo.Field<string>("C_TANULONEV"),
                                    UserName = tanuloWithOutBelepesWithGondviselo
                                        .Field<string>(felhasznaloNevGeneralasAlap).ToString()
                                };
                                if (!string.IsNullOrWhiteSpace(currentError))
                                {
                                    belepesAdat.NemGeneralhato = "T";
                                    belepesiAdatokPdfGeneralasList.ErrorList.Add(currentError);
                                }

                                belepesiAdatokPdfGeneralasList.BelepesiAdatokList.Add(belepesAdat);
                            }
                        }
                    }
                }

                foreach (var belepes in belepesiAdatokPdfGeneralasList.BelepesiAdatokList)
                {
                    var salt = SaltGenerator.GenerateSalt();
                    if (belepes.NemGeneralhato == "F")
                    {
                        belepesiAdatokList.BelepesiAdatokList.Add(
                            new BelepesiAdatok
                            {
                                Id = belepes.Id,
                                UserName = belepes.UserName,
                                Password = BasePasswordCrypter.EncodePasswordSHA1(belepes.Password, salt),
                                GondviseloId = -1,
                                NemGeneralhato = "F",
                                Salt = salt
                            });
                    }
                }
                if (isPasswordReset && tanuloIdList.Count == 0)
                {
                    JelszoFrissites(h, belepesiAdatokList, true, modositoUserId);
                }
                else
                {
                    HozzaferesGeneralasa(h, belepesiAdatokList);
                }
                if (belepesiAdatokPdfGeneralasList.BelepesiAdatokList.Count == 0)
                {
                    if (!isPasswordReset && tanuloIdList.Count == 0)
                    {
                        belepesiAdatokPdfGeneralasList.ErrorList.Add(TanuloResource.TanuloAzonositoGeneralasUresDokumentum);
                    }
                }
                return belepesiAdatokPdfGeneralasList;
            });
        }

        #endregion Tanuló azonosító generálás

        #region Gondviselő  azonosító generálás

        public BelepesiAdatokListCO GondviseloAzonositoGeneralas(List<int> tanuloIdList, bool isPasswordReset, int modositoUserId, bool csakAkiknekNincsAzonositojuk = true)
        {
            var belepesiAdatokPdfGeneralasList = new BelepesiAdatokListCO();
            var belepesiAdatokList = new BelepesiAdatokListCO();

            var felhasznaloNevGeneralasModja = (int)FelhasznaloiNevGeneralasModjaEnum.Oktatasi_azonosito_alapjan;
            var jelszoGeneralasModja = (int)JelszoGeneralasModjaEnum.Veletlenszeru;

            var felhasznaloNevGeneralasAlap = "C_OKTATASIAZONOSITO";

            return Dal.CustomConnection.Run(ConnectionType, h =>
            {
                var tanuloList = h.Tanulo(GridParameters).GetTanulokGondviseloIdvalForBelepesiAzonositoGeneralas(IntezmenyId, TanevId, tanuloIdList, false, csakAkiknekNincsAzonositojuk && !isPasswordReset && tanuloIdList.Count == 0).Tables[0].AsEnumerable().OrderBy(x => x.Field<string>(felhasznaloNevGeneralasAlap)).ToList();

                if ((felhasznaloNevGeneralasModja == (int)FelhasznaloiNevGeneralasModjaEnum.Egyeni) || jelszoGeneralasModja == (int)JelszoGeneralasModjaEnum.Egyeni)
                {
                    belepesiAdatokPdfGeneralasList.ErrorList.Add("-1");
                    belepesiAdatokPdfGeneralasList.ErrorList.Add(StringResourcesUtil.GetString(5404));
                }
                else
                {
                    var felhasznaloBelepesDal = h.FelhasznaloBelepes();
                    var tanulok = isPasswordReset ? tanuloList.Where(x => !string.IsNullOrWhiteSpace(x.Field<string>("C_BEJELENTKEZESINEV"))) : tanuloList;
                    var gondviseloIndex = 1;
                    var tanuloId = 0;
                    foreach (var tanulo in tanulok.Where(x => x.Field<int?>("C_BELEPESGONDVISELOID") == null || isPasswordReset || tanuloIdList != null && tanuloIdList.Contains(x.Field<int>("C_TANULOID"))))
                    {
                        if (tanuloId != tanulo.Field<int>("C_TANULOID"))
                        { gondviseloIndex = 1; }

                        var currentError = CheckTanuloAdatok(tanulo, tanuloList, felhasznaloNevGeneralasModja, false);
                        var salt = SaltGenerator.GenerateSalt();
                        var belepesAdat = new BelepesiAdatok
                        {
                            Id = tanulo.Field<int>("C_TANULOID"),
                            Password = jelszoGeneralasModja == (int)JelszoGeneralasModjaEnum.Veletlenszeru ? CommonUtils.GenerateJelszo() : (tanulo.Field<DateTime>("C_SZULETESIDATUM").Date.ToString("yyyy'-'MM'-'dd")),
                            GondviseloId = tanulo.Field<int>("C_GONDVISELOID"),
                            NemGeneralhato = "F",
                            UserName = isPasswordReset ? tanulo.Field<string>(8) : tanulo.Field<string>(felhasznaloNevGeneralasAlap),
                            Salt = salt,
                            Osztaly = tanulo.Field<string>("C_OSZTALYNEV"),
                            TanuloNev = tanulo.Field<string>("C_TANULONEV"),
                            GondviseloNev = tanulo.Field<string>("C_GONDVISELONEV")
                        };
                        if (!isPasswordReset)
                        {
                            belepesAdat.UserName = CommonUtils.GenerateGondviseloBejelentkezesiNev(felhasznaloBelepesDal, belepesAdat.UserName, ref gondviseloIndex, TanevId);
                        }

                        if (!string.IsNullOrWhiteSpace(currentError))
                        {
                            belepesAdat.NemGeneralhato = "T";
                            belepesiAdatokPdfGeneralasList.ErrorList.Add(currentError);
                        }
                        belepesiAdatokPdfGeneralasList.BelepesiAdatokList.Add(belepesAdat);
                        tanuloId = belepesAdat.Id;
                    }

                    foreach (var belepes in belepesiAdatokPdfGeneralasList.BelepesiAdatokList)
                    {
                        var salt = SaltGenerator.GenerateSalt();
                        belepesiAdatokList.BelepesiAdatokList.Add(
                            new BelepesiAdatok
                            {
                                Id = belepes.Id,
                                UserName = belepes.UserName,
                                Password = BasePasswordCrypter.EncodePasswordSHA1(belepes.Password, salt),
                                GondviseloId = belepes.GondviseloId,
                                NemGeneralhato = "F",
                                Salt = salt
                            });
                    }
                }

                if (isPasswordReset && tanuloIdList.Count == 0)
                {
                    JelszoFrissites(h, belepesiAdatokList, false, modositoUserId);
                }
                else
                {
                    HozzaferesGeneralasa(h, belepesiAdatokList);
                }
                if (belepesiAdatokPdfGeneralasList.BelepesiAdatokList.Count == 0)
                {
                    if (!isPasswordReset)
                    {
                        belepesiAdatokPdfGeneralasList.ErrorList.Add(tanuloIdList.Count == 0 ?
                            TanuloResource.GondviselpAzonositoGeneralasUresDokumentum :
                            TanuloResource.TanulokhozNemTartozikGondviselo);
                    }
                }
                return belepesiAdatokPdfGeneralasList;
            });
        }

        private string GetNumberOfGondviselo(BelepesiAdatok belepesAdat, List<BelepesiAdatok> belepesiAdatokList, List<string> letezo)
        {
            string result;
            var num = 0;
            do
            {
                num++;
                result = num < 10 ? "0" + num : num.ToString();
            } while (letezo.Contains(belepesAdat.UserName + result) || belepesiAdatokList.Select(x => x.UserName).ToList().Contains(belepesAdat.UserName + result));
            return result;
        }

        #endregion Gondviselő  azonosító generálás

        private string CheckTanuloAdatok(DataRow aktTanulo, List<DataRow> tanuloList, int felhasznaloNevGeneralasModja, bool isTanulo, List<DataRow> tanuloGondviseloBelepesList = null)
        {
            var oktatasiAzonosito = aktTanulo.Field<string>("C_OKTATASIAZONOSITO");
            //NOTE: Megvizsgálja, hogy tanulónak van-e oktatási azonosítója, ha az alapján generáljuk a hozzáféréseket.
            if (felhasznaloNevGeneralasModja == (int)FelhasznaloiNevGeneralasModjaEnum.Oktatasi_azonosito_alapjan &&
                string.IsNullOrWhiteSpace(oktatasiAzonosito))
            {
                return StringResourcesUtil.GetString(5401) + " " + Environment.NewLine + TanuloErrorListBuilder(aktTanulo, isTanulo);
            }

            //NOTE: Megvizsgálja, hogy tanuló oktatási azonosítója szerepel-e más tanulónál, ha az alapján generáljuk a hozzáféréseket.
            if (isTanulo &&
                felhasznaloNevGeneralasModja == (int)FelhasznaloiNevGeneralasModjaEnum.Oktatasi_azonosito_alapjan &&
                tanuloList.Any(x => x.Field<string>("C_OKTATASIAZONOSITO") == oktatasiAzonosito && x.Field<int>("C_TANULOID") != aktTanulo.Field<int>("C_TANULOID")))
            {
                return StringResourcesUtil.GetString(5402) + " " + Environment.NewLine + TanuloErrorListBuilder(aktTanulo, true);
            }

            //NOTE: Megvizsgálja, hogy gondviselő tanulójának az oktatási azonosítója szerepel-e más tanulónál, ha az alapján generáljuk a hozzáféréseket.
            if (!isTanulo &&
                felhasznaloNevGeneralasModja == (int)FelhasznaloiNevGeneralasModjaEnum.Oktatasi_azonosito_alapjan &&
                tanuloList.Any(x => x.Field<string>("C_OKTATASIAZONOSITO") == oktatasiAzonosito && x.Field<int>("C_TANULOID") != aktTanulo.Field<int>("C_TANULOID")))
            {
                return StringResourcesUtil.GetString(5402) + " " + Environment.NewLine + TanuloErrorListBuilder(aktTanulo, false);
            }

            if (tanuloGondviseloBelepesList != null)
            {
                //NOTE: Megvizsgálja, hogy gondviselő tanulójának az oktatási azonosítója szerepel-e más gondviselőnél, ha az alapján generáljuk a hozzáféréseket.
                if (isTanulo &&
                    felhasznaloNevGeneralasModja == (int)FelhasznaloiNevGeneralasModjaEnum.Oktatasi_azonosito_alapjan &&
                    tanuloGondviseloBelepesList.Any(x => x.Field<string>("C_BEJELENTKEZESINEV") == oktatasiAzonosito && x.Field<int?>("C_GONDVISELOID") != null))
                {
                    return StringResourcesUtil.GetString(2680) + " " + Environment.NewLine + TanuloErrorListBuilder(aktTanulo, isTanulo, true);
                }
            }
            return "";
        }

        public string TanuloErrorListBuilder(DataRow tanuloDataRow, bool isTanulo, bool csakTanuloNev = false)
        {
            string ret;
            if (csakTanuloNev == true)
            {
                ret = "\t" + StringResourcesUtil.GetString(455) + ": " /*Tanuló neve*/+ tanuloDataRow.Field<string>("C_TANULONEV") + Environment.NewLine;
            }
            else
            {
                ret = "\t" + StringResourcesUtil.GetString(455) + ": " /*Tanuló neve*/+ tanuloDataRow.Field<string>("C_TANULONEV") + Environment.NewLine +
                      "\t" + StringResourcesUtil.GetString(32) + ": " /*Oktatási azonosító*/+ tanuloDataRow.Field<string>("C_OKTATASIAZONOSITO") + Environment.NewLine;
            }
            return isTanulo ? ret : ret + "\t" + StringResourcesUtil.GetString(75) + ": " + tanuloDataRow.Field<string>("C_GONDVISELONEV") + Environment.NewLine;
        }

        public static class RandomGeneretator
        {
            private static readonly Random GlobalRandom = new Random(Environment.TickCount);

            [ThreadStatic]
            private static Random localRandom;

            public static int Next(int maxValue)
            {
                if (localRandom == null)
                {
                    int seed;
                    lock (GlobalRandom)
                    {
                        seed = GlobalRandom.Next();
                    }
                    localRandom = new Random(seed);
                }

                return localRandom.Next(maxValue);
            }
        }

        private void HozzaferesGeneralasa(IDalHandler h, BelepesiAdatokListCO belepesiAdatokList)
        {
            if (belepesiAdatokList.BelepesiAdatokList.Count == 0)
            {
                return;
            }

            string belepesiAdatokXml;
            var serializer = new XmlSerializer(typeof(BelepesiAdatokListCO));
            using (var stream = new StringWriter())
            {
                serializer.Serialize(stream, belepesiAdatokList);
                belepesiAdatokXml = stream.ToString();
            }

            h.Felhasznalo(GridParameters).HozzaferesGeneralas(IntezmenyId, TanevId, FelhasznaloId, belepesiAdatokXml);
        }

        private void JelszoFrissites(IDalHandler h, BelepesiAdatokListCO belepesiAdatokList, bool isTanulo, int modositoUserId)
        {
            if (belepesiAdatokList.BelepesiAdatokList.Count == 0)
            {
                return;
            }

            string belepesiAdatokXml;
            var serializer = new XmlSerializer(typeof(BelepesiAdatokListCO));
            using (var stream = new StringWriter())
            {
                serializer.Serialize(stream, belepesiAdatokList);
                belepesiAdatokXml = stream.ToString();
            }

            h.Felhasznalo(GridParameters).JelszoFrissites(IntezmenyId, TanevId, FelhasznaloId, belepesiAdatokXml, isTanulo, modositoUserId);
        }

        public DataSet ConvertBelepesiAdatokCoToDataset(BelepesiAdatokListCO belepesiAdatokListCo, bool isTanulo)
        {
            var intezmenyiAdatok = new IntezmenyHelper(ConnectionType).GetIntezmenyiAdatok();
            var intezmenyAlternativAzonositio = intezmenyiAdatok.AlternativAzonosito;
            string link = string.IsNullOrWhiteSpace(intezmenyAlternativAzonositio) ? IntezmenyAzonosito : intezmenyAlternativAzonositio;

            var ds = new DataSet();
            var dataTable = new DataTable();

            var rendezettLista = belepesiAdatokListCo.BelepesiAdatokList.OrderBy(x => x.Osztaly).ThenBy(x => x.TanuloNev);

            dataTable.Columns.Add(new DataColumn("Osztaly"));
            dataTable.Columns.Add(new DataColumn("Intezmeny"));
            dataTable.Columns.Add(new DataColumn("TanuloNev"));
            dataTable.Columns.Add(new DataColumn("Azonosito"));
            dataTable.Columns.Add(new DataColumn("Jelszo"));
            dataTable.Columns.Add(new DataColumn("Link"));
            if (!isTanulo)
            {
                dataTable.Columns.Add(new DataColumn("Gondviselo"));
            }
            foreach (var belepes in rendezettLista)
            {
                var row = dataTable.NewRow();

                if (belepes.NemGeneralhato == "F" || string.IsNullOrWhiteSpace(belepes.NemGeneralhato))
                {
                    row["Osztaly"] = belepes.Osztaly;
                    row["Intezmeny"] = intezmenyiAdatok.Nev;
                    row["TanuloNev"] = belepes.TanuloNev;
                    row["Azonosito"] = belepes.UserName;
                    row["Jelszo"] = belepes.Password;
                    row["Link"] = $"https://{link.ToLower()}.e-kreta.hu";
                    if (!isTanulo)
                    {
                        row["Gondviselo"] = belepes.GondviseloNev;
                    }
                    dataTable.Rows.Add(row);
                }
            }

            ds.Tables.Add(dataTable);
            ds.Tables[0].TableName = "Table";
            return ds;
        }

        public FelhasznalonevUjrageneralasModel TanuloFelhasznalonevGeneralas(int tanuloId, int? gondviseloId)
        {
            var felhasznaloBelepesModel = new FelhasznalonevUjrageneralasModel
            {
                TanuloId = tanuloId,
                GondviseloId = gondviseloId
            };

            var gondviseloFelhasznalonevGeneralasTipus = SystemSettingFelhasznalonevGeneralas.OktatasiAzonosito; //RendszerBeallitasTipusEnum.Gondviselo_felhasznalonev_generalasa_az_alabbi_ertek_alapjan
            var tanuloFelhasznalonevGeneralasTipus = SystemSettingFelhasznalonevGeneralas.OktatasiAzonosito; //RendszerBeallitasTipusEnum.Tanulo_felhasznaloi_nev_generalas_modja

            string oktatasiAzonosito = string.Empty;

            return Dal.CustomConnection.Run(ConnectionType, h =>
            {
                IFelhasznaloDal dal = h.Felhasznalo();
                var tanulo = dal.Get(tanuloId);

                oktatasiAzonosito = tanulo.OktatasiAzonosito;

                if (gondviseloId.HasValue)
                {
                    string currentGondviseloName = string.Empty;
                    List<string> gondviselonevList = new List<string>();

                    ITanuloDal tanuloDal = h.Tanulo();
                    IEnumerable<DataRow> gondviseloData = tanuloDal.GetTanuloGondviseloListData(IntezmenyId, TanevId, tanuloId).Tables[0].AsEnumerable();
                    gondviselonevList = gondviseloData.Select(x => SDAConvert.ToString(x["BelepesiNev"])).Where(x => !string.IsNullOrWhiteSpace(x)).ToList();
                    currentGondviseloName = gondviseloData.FirstOrDefault(x => x.Field<int>("ID") == gondviseloId)?.Field<string>("BelepesiNev");
                    felhasznaloBelepesModel.IsNewFelhasznaloBelepes = string.IsNullOrWhiteSpace(currentGondviseloName);

                    if (gondviseloFelhasznalonevGeneralasTipus == SystemSettingFelhasznalonevGeneralas.OktatasiAzonosito)
                    {
                        felhasznaloBelepesModel.FelhasznaloNev = GetGondviseloFelhasznalonev(gondviselonevList, currentGondviseloName, oktatasiAzonosito);
                    }
                }
                else
                {
                    felhasznaloBelepesModel.IsNewFelhasznaloBelepes = !tanulo.FelhasznaloBelepes.Any(x => !x.Torolt && !x.GondviseloId.IsEntityId());
                    if (tanuloFelhasznalonevGeneralasTipus == SystemSettingFelhasznalonevGeneralas.OktatasiAzonosito)
                    {
                        felhasznaloBelepesModel.FelhasznaloNev = oktatasiAzonosito;
                    }
                }
                return felhasznaloBelepesModel;
            });
        }

        private string GetGondviseloFelhasznalonev(List<string> gondviselonevList, string currentGondviseloName, string belepesiNevGeneralasAlap)
        {
            string result;
            if (!string.IsNullOrWhiteSpace(currentGondviseloName) && gondviselonevList.Count(x => x.Equals(currentGondviseloName, StringComparison.OrdinalIgnoreCase)) == 1)
            {
                gondviselonevList.Remove(currentGondviseloName);
            }

            var sorszam = 0;
            do
            {
                sorszam++;
                result = $"{(sorszam < 10 ? "0" + sorszam : sorszam.ToString())}";
            } while (gondviselonevList.Any(x => x.Equals($"{belepesiNevGeneralasAlap}{result}", StringComparison.OrdinalIgnoreCase)));
            return $"{belepesiNevGeneralasAlap}{result}";
        }

        public void FelhasznalonevUpdate(int tanuloId, int? gondviseloId, string felhasznalonev)
        {
            Dal.CustomConnection.Run(ConnectionType, h =>
            {
                IFelhasznaloBelepesDal dal = h.FelhasznaloBelepes();
                dal.UpdateFelhasznalonev(IntezmenyId, TanevId, FelhasznaloId, tanuloId, gondviseloId, felhasznalonev);
            });
        }

        public FelhasznaloBelepesModel GenerateNewFelhasznaloBelepes(int jelszoGeneralasModja, string oktatasiAzonosito, DateTime szuletesiDatum)
        {
            var felhasznaloBelepes = new FelhasznaloBelepesModel();

            felhasznaloBelepes.So = SaltGenerator.GenerateSalt();
            felhasznaloBelepes.BejelentkezesiNev = oktatasiAzonosito;
            var jelszo = jelszoGeneralasModja == (int)JelszoGeneralasModjaEnum.Veletlenszeru ? CommonUtils.GenerateJelszo() : szuletesiDatum.ToString("yyyy'-'MM'-'dd");
            felhasznaloBelepes.Jelszo = BasePasswordCrypter.EncodePasswordSHA1(jelszo, felhasznaloBelepes.So);

            return felhasznaloBelepes;
        }

        public BelepesiAdatokListCO SetKijeloltTanulokGondviseloiToBovitett(List<int> tanuloIdList, bool emailKuldesSzukseges)
        {
            List<int> distinctTanuloIdList = tanuloIdList
                                            .Distinct()
                                            .ToList();

            var belepesiAdatokPdfGeneralasList = new BelepesiAdatokListCO();
            Dal.CustomConnection.Run(ConnectionType, h =>
            {
                var tanuloDal = h.Tanulo();
                var gondviseloDal = h.Gondviselo();
                var felhasznaloBelepesDal = h.FelhasznaloBelepes();

                foreach (var tanuloId in distinctTanuloIdList)
                {
                    var tanulo = tanuloDal.Get(tanuloId);
                    foreach (var gondviselo in tanulo.Gondviselo.Where(x => !x.Torolt))
                    {
                        GondviseloToBovitett(gondviseloDal, felhasznaloBelepesDal, tanulo, gondviselo, emailKuldesSzukseges, belepesiAdatokPdfGeneralasList, h);
                    }
                }
            });

            return belepesiAdatokPdfGeneralasList;
        }

        public BelepesiAdatokListCO SetGondviseloToBovitett(List<int> gondviseloIdList, bool emailKuldesSzukseges)
        {
            var belepesiAdatokPdfGeneralasList = new BelepesiAdatokListCO();
            Dal.CustomConnection.Run(ConnectionType, h =>
            {
                var tanuloDal = h.Tanulo();
                var gondviseloDal = h.Gondviselo();
                var felhasznaloBelepesDal = h.FelhasznaloBelepes();

                foreach (var gondviseloId in gondviseloIdList)
                {
                    var gondviselo = gondviseloDal.Get(gondviseloId);
                    var tanulo = tanuloDal.Get(gondviselo.TanuloId);

                    GondviseloToBovitett(gondviseloDal, felhasznaloBelepesDal, tanulo, gondviselo, emailKuldesSzukseges, belepesiAdatokPdfGeneralasList, h);
                }
            });

            return belepesiAdatokPdfGeneralasList;
        }

        public void UjGondviseloBelepesiAdatokPdfGeneralasEsEmailKuldes(int tanuloId, int gondviseloId, bool emailKuldesSzukseges, BelepesiAdatokListCO belepesiAdatokPdfGeneralasList, string gondviseloBelepesiNeve, string gondviseloJelszava)
        {
            Dal.CustomConnection.Run(ConnectionType, h =>
            {
                var tanulo = h.Tanulo().Get(tanuloId);
                var gondviselo = h.Gondviselo().Get(gondviseloId);

                UjGondviseloBelepesiAdatokPdfGeneralasEsEmailKuldes(tanulo, gondviselo, emailKuldesSzukseges, belepesiAdatokPdfGeneralasList, gondviseloBelepesiNeve, gondviseloJelszava, h);
            });
        }

        private void UjGondviseloBelepesiAdatokPdfGeneralasEsEmailKuldes(ITanulo tanulo, IGondviselo gondviselo, bool emailKuldesSzukseges, BelepesiAdatokListCO belepesiAdatokPdfGeneralasList, string gondviseloBelepesiNeve, string gondviseloJelszava, IDalHandler h)
        {
            var intezmenyCo = new IntezmenyHelper(new DalHandlerConnectionType(ConnectionType, h)).GetAktivIntezmenyNevCim();
            var message = string.Format(EmailResource.UjGondviseloBelepesiAdatokGeneralasErtesitesEmail, gondviselo.Nev, tanulo.NyomtatasiNev, tanulo.OktatasiAzonosito, CommonUtils.GetIntezmenyUrl(IntezmenyAzonosito), intezmenyCo.Nev, intezmenyCo.IntezmenyCim, "{0}");

            GondviseloBelepesiAdatokPdfGeneralasEsEmailKuldes(tanulo, gondviselo, emailKuldesSzukseges, belepesiAdatokPdfGeneralasList, gondviseloBelepesiNeve, gondviseloJelszava, message, h);
        }

        private void GondviseloBelepesiAdatokPdfGeneralasEsEmailKuldes(ITanulo tanulo, IGondviselo gondviselo, bool emailKuldesSzukseges, BelepesiAdatokListCO belepesiAdatokPdfGeneralasList, string gondviseloBelepesiNeve, string gondviseloJelszava, string message, IDalHandler h)
        {
            if (emailKuldesSzukseges)
            {
                var gondviseloEmail = gondviselo.Email.SingleOrDefault(x => !x.Torolt && !x.IsHibasanMegadva && x.Alapertelmezett);
                if (gondviseloEmail != null && !string.IsNullOrWhiteSpace(gondviseloEmail.EmailCim))
                {
                    new JelszoModositasLinkHelper(new DalHandlerConnectionType(ConnectionType, h)).BeazonositottGondvilseoLinkGeneralasEsKuldes(tanulo.ID, gondviselo.ID, gondviseloEmail.EmailCim, message, gondviseloEmail.Guid);
                }
                else
                {
                    belepesiAdatokPdfGeneralasList.EmailErrors += $"{gondviselo.Nev} - {tanulo.NyomtatasiNev} - {tanulo.OktatasiAzonosito}{Core.Constants.General.Sortores}";
                }
            }

            var osztalyNev = new TanuloHelper(new DalHandlerConnectionType(ConnectionType, h)).GetTanuloOsztalyokNevei(tanulo.ID);
            belepesiAdatokPdfGeneralasList.BelepesiAdatokList.Add(ConvertToBelepesiAdat(gondviseloBelepesiNeve, gondviselo.Nev, tanulo.NyomtatasiNev, osztalyNev, gondviseloJelszava));
        }

        private BelepesiAdatok ConvertToBelepesiAdat(string bejelentkezesiNev, string gondviseloNev, string tanuloNev, string osztalyNev, string jelszo)
        {
            var belepesiAdat = new BelepesiAdatok();
            belepesiAdat.GondviseloNev = gondviseloNev;
            belepesiAdat.TanuloNev = tanuloNev;
            belepesiAdat.Osztaly = osztalyNev ?? string.Empty;
            belepesiAdat.Password = jelszo;
            belepesiAdat.UserName = bejelentkezesiNev;

            return belepesiAdat;
        }

        private void GondviseloToBovitett(IGondviseloDal gondviseloDal, IFelhasznaloBelepesDal felhasznaloBelepesDal, ITanulo tanulo, IGondviselo gondviselo, bool emailKuldesSzukseges, BelepesiAdatokListCO belepesiAdatokPdfGeneralasList, IDalHandler h)
        {
            var message = string.Empty;

            var connectionType = new DalHandlerConnectionType(ConnectionType, h);
            var felhasznaloBelepesHelper = new FelhasznaloBelepesHelper(connectionType);

            var intezmenyCo = new IntezmenyHelper(connectionType).GetAktivIntezmenyNevCim();
            var belepes = gondviselo.FelhasznaloBelepes.SingleOrDefault(x => !x.Torolt);
            if (belepes != null && belepes.ID.IsEntityId())
            {
                /*if (gondviselo.IsCsokkentettGondviselo) {*/
                message = EmailResource.BovitettGondviseloBelepesiAdatokErtesitesEmail;
                /*} else { message = EmailResource.GondviseloUjJelszoErtesitesEmail; }*/

                gondviselo.IsCsokkentettGondviselo = false;
                gondviseloDal.Update(gondviselo);

                var bejelentkezesiNev = belepes.BejelentkezesiNev;
                var ujJelszo = CommonUtils.GenerateJelszo();

                felhasznaloBelepesHelper.ChangeUserPassword(bejelentkezesiNev, ujJelszo, kotelezoValtoztatni: true);

                message = string.Format(message, gondviselo.Nev, CommonUtils.GetIntezmenyUrl(IntezmenyAzonosito), intezmenyCo.Nev, intezmenyCo.IntezmenyCim, "{0}", tanulo.OktatasiAzonosito);

                GondviseloBelepesiAdatokPdfGeneralasEsEmailKuldes(tanulo, gondviselo, emailKuldesSzukseges, belepesiAdatokPdfGeneralasList, bejelentkezesiNev, ujJelszo, message, h);
            }
            else
            {
                gondviselo.IsCsokkentettGondviselo = false;
                gondviseloDal.Update(gondviselo);

                int gondviseloIndex = 1;
                var bejelentkezesiNev = CommonUtils.GenerateGondviseloBejelentkezesiNev(felhasznaloBelepesDal, tanulo.OktatasiAzonosito, ref gondviseloIndex, TanevId);
                var jelszo = CommonUtils.GenerateJelszo();

                felhasznaloBelepesHelper.GrantLogin(gondviselo.TanuloId, bejelentkezesiNev, jelszo, gondviselo.ID, kotelezoValtoztatni: true);

                message = string.Format(EmailResource.BovitettGondviseloBelepesiAdatokErtesitesEmail, gondviselo.Nev, CommonUtils.GetIntezmenyUrl(IntezmenyAzonosito), intezmenyCo.Nev, intezmenyCo.IntezmenyCim, "{0}", tanulo.OktatasiAzonosito);

                GondviseloBelepesiAdatokPdfGeneralasEsEmailKuldes(tanulo, gondviselo, emailKuldesSzukseges, belepesiAdatokPdfGeneralasList, bejelentkezesiNev, jelszo, message, h);
            }
        }
    }
}