using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Xml.Serialization;
using Aspose.Cells;
using Kreta.BusinessLogic.Classes;
using Kreta.BusinessLogic.HelperClasses;
using Kreta.BusinessLogic.HelperClasses.AscImportExport;
using Kreta.BusinessLogic.Logic;
using Kreta.Core;
using Kreta.Core.ConnectionType;
using Kreta.Core.Exceptions;
using Kreta.Resources;

namespace Kreta.BusinessLogic.Helpers.ImportExport
{
    public class AscImportExportHelper : LogicBase
    {
        #region Fields

        private static readonly AscImport AscImportData = new AscImport();

        #endregion Fields

        #region Properties

        private static List<string> AscEgeszOsztalyNevuCsoportIdList { get; set; } = new List<string>();

        #endregion Properties

        #region Constructors

        public AscImportExportHelper(IConnectionType connectionType) : base(connectionType) { }

        #endregion Constructors

        public static List<List<string>> GetTantargyfelosztasImportDataFromAsc(Stream ascImportFileStream)
        {
            var importData = new List<List<string>>
            {
                TantargyfelosztasImportExportHelper.ImportHeaderListEgyszeru.Select(x => x.Value).ToList()
            };

            timetable ascTimeTable = new XmlSerializer(typeof(timetable)).Deserialize(ascImportFileStream.StripNonValidXmlCharacters()) as timetable;

            ValidateAscFile(ascTimeTable, true);

            List<TantargyfelosztasFromAscModel> tantargyfelosztasFromAscModelList = GetTantargyfelosztasFromAscModelList(ascTimeTable);
            importData.AddRange(tantargyfelosztasFromAscModelList.Select(x =>
                new List<string>
                {
                    x.OsztalyNev.ReplaceMultipleSpacesAndTrim(),
                    x.CsoportNev.ReplaceMultipleSpacesAndTrim(),
                    x.TantargyNev.ReplaceMultipleSpacesAndTrim(),
                    x.Oraszam.ReplaceMultipleSpacesAndTrim(),
                    x.TanarNev.ReplaceMultipleSpacesAndTrim(),
                    0.ToString(),
                    CommonResource.Nem,
                    CommonResource.Nem,
                    0.ToString()
                }));

            return importData;
        }

        public static List<List<string>> GetOrarendImportDataFromAsc(Stream ascImportFileStream, string oraErvenyessegKezdeteString, string oraErvenyessegVegeString)
        {
            var importData = new List<List<string>>
            {
                OrarendImportExportHelper.ImportHeaderListOraErvenyessegiIdovel.Select(x => x.Value).ToList()
            };

            timetable ascTimeTable = new XmlSerializer(typeof(timetable)).Deserialize(ascImportFileStream.StripNonValidXmlCharacters()) as timetable;

            ValidateAscFile(ascTimeTable, false);

            List<OrarendFromAscModel> orarendFromAscModelList = GetOrarendFromAscModelList(ascTimeTable);
            importData.AddRange(orarendFromAscModelList.Select(x =>
                new List<string>
                {
                    oraErvenyessegKezdeteString.ReplaceMultipleSpacesAndTrim(),
                    oraErvenyessegVegeString.ReplaceMultipleSpacesAndTrim(),
                    x.Hetirend.ReplaceMultipleSpacesAndTrim(),
                    x.Nap.ReplaceMultipleSpacesAndTrim(),
                    x.Ora.ReplaceMultipleSpacesAndTrim(),
                    x.OsztalyNev.ReplaceMultipleSpacesAndTrim(),
                    x.CsoportNev.ReplaceMultipleSpacesAndTrim(),
                    x.TantargyNev.ReplaceMultipleSpacesAndTrim(),
                    x.TanarNev.ReplaceMultipleSpacesAndTrim(),
                    x.TeremNev.ReplaceMultipleSpacesAndTrim()
                }));

            return importData;
        }

        private static void ValidateAscFile(timetable ascTimeTable, bool isOnlyTtfImport)
        {
            var errorList = new List<string>();
            if (ascTimeTable.classes?.@class == null && ascTimeTable.groups?.group == null)
            {
                errorList.Add(ImportExportOrarendResource.AzImportalniKivantFileNemTartalmazOsztalyokatEsVagyCsoportokat);
            }

            if (ascTimeTable.subjects?.subject == null)
            {
                errorList.Add(ImportExportOrarendResource.AzImportalniKivantFileNemTartalmazTantargyakat);
            }

            if (ascTimeTable.teachers?.teacher == null)
            {
                errorList.Add(ImportExportOrarendResource.AzImportalniKivantFileNemTartalmazTanarokat);
            }

            if (ascTimeTable.lessons?.lesson == null)
            {
                errorList.Add(ImportExportOrarendResource.AzImportalniKivantFileNemTartalmazFoglalkozasokat);
            }

            if (!isOnlyTtfImport)
            {
                if (ascTimeTable.cards?.card == null)
                {
                    errorList.Add(ImportExportOrarendResource.AzImportalniKivantFileNemTartalmazOrakat);
                }

                if (ascTimeTable.classrooms?.classroom == null)
                {
                    errorList.Add(ImportExportOrarendResource.AzImportalniKivantFileNemTartalmazTermeket);
                }

                //NOTE: Különböző módon kell validálni a 2008-as és az azt követő ASC fájlokat!
                if (ascTimeTable.displayname == null || ascTimeTable.displayname.Contains("2008"))
                {
                    if (ascTimeTable.lessons?.lesson != null)
                    {
                        var lesson = ascTimeTable.lessons.lesson;
                        if (lesson.Any(x => string.IsNullOrWhiteSpace(x.weeks)))
                        {
                            errorList.Add(ImportExportOrarendResource.InvalidHetirendNincsKitoltve);
                        }
                        else if (lesson.Any(x => x.weeks.Length != lesson[0].weeks.Length))
                        {
                            errorList.Add(ImportExportOrarendResource.InvalidHetirendForLesson);
                        }
                    }

                    if (ascTimeTable.days?.days == null)
                    {
                        errorList.Add(ImportExportOrarendResource.AzImportalniKivantFileNemTartalmazNapirendet);
                    }
                }
                else
                {
                    if (ascTimeTable.weeksdefs?.weeksdef == null)
                    {
                        errorList.Add(ImportExportOrarendResource.AzImportalniKivantFileNemTartalmazHetirendet);
                    }
                    else
                    {
                        //NOTE: A hetirendek közül képesek az ASC-vel olyan fájlt generálni, ahol az Id megegyezhet, ezeket meg kell vizsgálnunk, hogy ilyen ne fordulhasson elő!
                        List<AscHetirend> ascHetirendList = GetHetirendListFromAsc(ascTimeTable);

                        Dictionary<string, List<AscHetirend>> duplicatedHetirendByIdIdDictionary = ascHetirendList
                            .GroupBy(x => x.Id)
                            .Where(x => x.Count() > 1)
                            .ToDictionary(x => x.Key, x => x.ToList());

                        foreach (var duplicatedItem in duplicatedHetirendByIdIdDictionary)
                        {
                            List<string> duplacatedItemNevList = duplicatedItem.Value.Select(x => $"\"{x.Nev}\"").ToList();
                            errorList.Add(string.Format(ImportExportOrarendResource.InvalidHetirendEgyezes, string.Join(", ", duplacatedItemNevList)));
                        }
                    }

                    if (ascTimeTable.daysdefs?.daysdef == null)
                    {
                        errorList.Add(ImportExportOrarendResource.AzImportalniKivantFileNemTartalmazNapirendet);
                    }
                }
            }

            if (errorList.Count > 0)
            {
                throw new BlException(string.Join(Constants.General.Sortores, errorList));
            }
        }

        private static List<OrarendFromAscModel> GetOrarendFromAscModelList(timetable ascTimeTable)
        {
            var orarendFromAscModelList = new List<OrarendFromAscModel>();
            List<TantargyfelosztasFromAscModel> tantargyfelosztasFromAscModelList = GetTantargyfelosztasFromAscModelList(ascTimeTable);

            List<AscHetirend> ascHetirendList;
            Dictionary<string, AscNapok> ascNapDictionary;
            List<AscTimeCards> ascTimeCardList;
            if (ascTimeTable.displayname == null || ascTimeTable.displayname.Contains("2008"))
            {
                ascHetirendList = GetHetirendListFromAsc2008(ascTimeTable);
                ascNapDictionary = GetNapDictionaryFromAsc2008(ascTimeTable);
                ascTimeCardList = GetAscTimeCardList2008(ascTimeTable, ascNapDictionary);
            }
            else
            {
                ascHetirendList = GetHetirendListFromAsc(ascTimeTable);
                ascNapDictionary = GetNapDictionaryFromAsc(ascTimeTable);
                ascTimeCardList = GetAscTimeCardList(ascTimeTable, ascNapDictionary);
            }

            List<AscTerem> ascTeremList = GetTeremListFromAsc(ascTimeTable);

            foreach (AscTimeCards ascTimeCard in ascTimeCardList)
            {
                List<TantargyfelosztasFromAscModel> tantargyfelosztasList = tantargyfelosztasFromAscModelList.Where(x => x.Id.Equals(ascTimeCard.LessonId)).ToList();
                if (tantargyfelosztasList.Count > 0)
                {
                    foreach (var tantargyfelosztas in tantargyfelosztasList)
                    {
                        string hetirendId = string.IsNullOrWhiteSpace(ascTimeCard.Het) ? tantargyfelosztas.LessonHetirendIdFromAsc : ascTimeCard.Het;
                        orarendFromAscModelList.Add(new OrarendFromAscModel
                        {
                            Hetirend = ascHetirendList.Single(x => x.Id.Equals(hetirendId)).Nev,
                            Nap = ascTimeCard.Nap,
                            Ora = ascTimeCard.Sorszam,
                            OsztalyNev = tantargyfelosztas.OsztalyNev,
                            CsoportNev = tantargyfelosztas.CsoportNev,
                            TantargyNev = tantargyfelosztas.TantargyNev,
                            TanarNev = tantargyfelosztas.TanarNev,
                            TeremNev = GetTeremNev(ascTimeCard.TeremIdListString, ascTeremList)
                        });
                    }
                }
            }

            return orarendFromAscModelList;
        }

        private static List<AscHetirend> GetHetirendListFromAsc2008(timetable ascTimeTable)
        {
            var ascHetirendList = new List<AscHetirend>();
            var hetirendNevList = new List<string> { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" };
            int hetirendNevIndex = 0;

            List<string> hetirendIdListFromAsc = new List<string>();
            var hetirendCount = ascTimeTable.lessons.lesson[0].weeks.Length;
            hetirendIdListFromAsc.Insert(0, string.Concat(Enumerable.Repeat("1", hetirendCount)));
            var defaultHetirend = string.Concat(Enumerable.Repeat("0", hetirendCount));
            if (hetirendCount > 1)
            {
                for (int i = 0; i < hetirendCount; i++)
                {
                    StringBuilder stringBuilder = new StringBuilder(defaultHetirend)
                    {
                        [i] = '1'
                    };
                    hetirendIdListFromAsc.Add(stringBuilder.ToString());
                }
            }

            foreach (string hetirendIdFromAsc in hetirendIdListFromAsc)
            {
                if (!string.IsNullOrWhiteSpace(hetirendIdFromAsc))
                {
                    string hetNeve;
                    string hetirendId;
                    if (hetirendIdFromAsc.All(x => x.Equals('1')))
                    {
                        hetirendId = hetirendIdFromAsc;
                        hetNeve = $"{CommonResource.MindenHeten}";
                    }
                    else
                    {
                        hetirendId = GenerateHetirendId(hetirendIdListFromAsc, hetirendNevIndex);
                        hetNeve = $"{hetirendNevList[hetirendNevIndex]} {CommonResource.Het}";
                        hetirendNevIndex++;
                    }

                    ascHetirendList.Add(new AscHetirend
                    {
                        Id = hetirendId,
                        Nev = hetNeve
                    });
                }
            }

            return ascHetirendList;
        }

        private static string GenerateHetirendId(List<string> hetirendIdListByLesson, int hetirendNevIndex)
        {
            string tempString = string.Empty;
            tempString = tempString.PadLeft(hetirendIdListByLesson.Count - 1, '0');
            var stringBuilder = new StringBuilder(tempString)
            {
                [hetirendNevIndex] = '1'
            };
            string result = stringBuilder.ToString();
            return result;
        }

        private static List<AscHetirend> GetHetirendListFromAsc(timetable ascTimeTable)
        {
            var ascHetirendList = new List<AscHetirend>();
            foreach (timetableWeeksdefsWeeksdef het in ascTimeTable.weeksdefs.weeksdef)
            {
                ascHetirendList.Add(new AscHetirend
                {
                    Id = het.weeks,
                    Nev = het.name.ReplaceMultipleSpacesAndTrim()
                });
            }

            return ascHetirendList;
        }

        private static Dictionary<string, AscNapok> GetNapDictionaryFromAsc2008(timetable ascTimeTable)
        {
            var ascNapDictionary = new Dictionary<string, AscNapok>();
            foreach (timetableDaysDays nap in ascTimeTable.days.days)
            {
                ascNapDictionary.Add(nap.day,
                    new AscNapok
                    {
                        Id = nap.day,
                        Nev = nap.name.ReplaceMultipleSpacesAndTrim()
                    });
            }

            return ascNapDictionary;
        }

        private static Dictionary<string, AscNapok> GetNapDictionaryFromAsc(timetable ascTimeTable)
        {
            var ascNapDictionary = new Dictionary<string, AscNapok>();
            foreach (timetableDaysdefsDaysdef nap in ascTimeTable.daysdefs.daysdef)
            {
                ascNapDictionary.Add(nap.days,
                    new AscNapok
                    {
                        Id = nap.id,
                        Nev = nap.name.ReplaceMultipleSpacesAndTrim(),
                    });
            }

            return ascNapDictionary;
        }

        //NOTE: Itt a "card.day" kell!
        private static List<AscTimeCards> GetAscTimeCardList2008(timetable ascTimeTable, Dictionary<string, AscNapok> ascNapDictionary)
        {
            var ascTimeCardList = new List<AscTimeCards>();
            foreach (timetableCardsCard card in ascTimeTable.cards.card)
            {
                ascTimeCardList.Add(new AscTimeCards
                {
                    Sorszam = card.period,
                    Het = string.IsNullOrWhiteSpace(card.weeks) ? string.Empty : card.weeks,
                    Nap = ascNapDictionary[card.day].Nev,
                    LessonId = card.lessonid,
                    TeremIdListString = card.classroomids
                });
            }

            return ascTimeCardList;
        }

        //NOTE: Itt a "card.days" kell!
        private static List<AscTimeCards> GetAscTimeCardList(timetable ascTimeTable, Dictionary<string, AscNapok> ascNapDictionary)
        {
            var ascTimeCardList = new List<AscTimeCards>();
            foreach (timetableCardsCard card in ascTimeTable.cards.card)
            {
                if (!ascTimeCardList.Any(x => x.LessonId == card.lessonid && x.Sorszam == card.period && x.Het == card.weeks && x.Nap == ascNapDictionary[card.days].Nev)) //A periodspercard miatt megegyszer ne fusson bele mert elso korben mar letrehozta (online xmlben tombonkent 1 card, dektopban minden ora kulon card)
                {
                    var lesson = ascTimeTable.lessons.lesson.SingleOrDefault(x => x.id == card.lessonid);
                    var periodsPerCard = int.TryParse(lesson.periodspercard, out int result) ? result : 0;

                    for (int i = 0; i < periodsPerCard; i++)
                    {
                        var newCard = new AscTimeCards
                        {
                            Sorszam = int.TryParse(card.period, out int period) ? (period + i).ToString() : card.period,
                            Het = string.IsNullOrWhiteSpace(card.weeks) ? string.Empty : card.weeks,
                            Nap = ascNapDictionary[card.days].Nev,
                            LessonId = card.lessonid,
                            TeremIdListString = card.classroomids
                        };
                        if (!ascTimeCardList.Any(x => x.LessonId == newCard.LessonId && x.Sorszam == newCard.Sorszam && x.Het == newCard.Het && x.Nap == newCard.Nap))
                        {
                            ascTimeCardList.Add(newCard);
                        }
                    }
                }
            }

            return ascTimeCardList;
        }

        private static List<AscTerem> GetTeremListFromAsc(timetable ascTimeTable)
        {
            var ascTeremList = new List<AscTerem>();
            foreach (timetableClassroomsClassroom terem in ascTimeTable.classrooms.classroom)
            {
                ascTeremList.Add(new AscTerem
                {
                    Id = terem.id,
                    Nev = terem.name.ReplaceMultipleSpacesAndTrim()
                });
            }

            return ascTeremList;
        }

        private static string GetTeremNev(string teremIdListString, List<AscTerem> ascTeremList)
        {
            List<string> teremIdList = teremIdListString.Split(',').ToList();
            string teremNev = string.Empty;
            foreach (string teremId in teremIdList)
            {
                if (!string.IsNullOrWhiteSpace(teremId))
                {
                    teremNev += ascTeremList.First(x => x.Id.Equals(teremId)).Nev;
                }
            }

            return teremNev;
        }

        private static List<TantargyfelosztasFromAscModel> GetTantargyfelosztasFromAscModelList(timetable ascTimeTable)
        {
            List<LessonModel> lessonList = CreateLessonListFromAscXml(ascTimeTable);
            var tantargyfelosztasFromAscModelList = new List<TantargyfelosztasFromAscModel>();

            //NOTE: 1A/I
            List<LessonModel> filteredLessonList = GetFilteredLessonList(lessonList, isTobbOsztaly: false, isTobbCsoport: false, isTobbTanar: false, isNincsMegadvaOsztaly: false, isNincsMegadvaCsoport: false);
            tantargyfelosztasFromAscModelList.AddRange(CreateTantargyfelosztasEgyOsztalyEgyCsoportEgyTanar(filteredLessonList));

            //NOTE: 1A/II
            filteredLessonList = GetFilteredLessonList(lessonList, isTobbOsztaly: false, isTobbCsoport: false, isTobbTanar: true, isNincsMegadvaOsztaly: false, isNincsMegadvaCsoport: false);
            tantargyfelosztasFromAscModelList.AddRange(CreateTantargyfelosztasEgyOsztalyEgyCsoportTobbTanar(filteredLessonList));

            //NOTE: 1B/I
            filteredLessonList = GetFilteredLessonList(lessonList, isTobbOsztaly: false, isTobbCsoport: true, isTobbTanar: false, isNincsMegadvaOsztaly: false, isNincsMegadvaCsoport: false);
            tantargyfelosztasFromAscModelList.AddRange(CreateTantargyfelosztasEgyOsztalyTobbCsoportEgyTanar(filteredLessonList));

            //NOTE: 1B/II
            filteredLessonList = GetFilteredLessonList(lessonList, isTobbOsztaly: false, isTobbCsoport: true, isTobbTanar: true, isNincsMegadvaOsztaly: false, isNincsMegadvaCsoport: false);
            tantargyfelosztasFromAscModelList.AddRange(CreateTantargyfelosztasEgyOsztalyTobbCsoportTobbTanar(filteredLessonList));

            //NOTE: 2B/I
            filteredLessonList = GetFilteredLessonList(lessonList, isTobbOsztaly: true, isTobbCsoport: true, isTobbTanar: false, isNincsMegadvaOsztaly: false, isNincsMegadvaCsoport: false);
            tantargyfelosztasFromAscModelList.AddRange(CreateTantargyfelosztasTobbOsztalyTobbCsoportEgyTanar(filteredLessonList));

            //NOTE: 2B/II
            filteredLessonList = GetFilteredLessonList(lessonList, isTobbOsztaly: true, isTobbCsoport: true, isTobbTanar: true, isNincsMegadvaOsztaly: false, isNincsMegadvaCsoport: false);
            tantargyfelosztasFromAscModelList.AddRange(CreateTantargyfelosztasTobbOsztalyTobbCsoportTobbTanar(filteredLessonList));

            //NOTE: 3C/I
            filteredLessonList = GetFilteredLessonList(lessonList, isTobbOsztaly: false, isTobbCsoport: false, isTobbTanar: false, isNincsMegadvaOsztaly: true, isNincsMegadvaCsoport: true);
            tantargyfelosztasFromAscModelList.AddRange(CreateTantargyfelosztasNincsOsztalyNincsCsoportEgyTanar(filteredLessonList));

            //NOTE: 3C/II
            filteredLessonList = GetFilteredLessonList(lessonList, isTobbOsztaly: false, isTobbCsoport: false, isTobbTanar: true, isNincsMegadvaOsztaly: true, isNincsMegadvaCsoport: true);
            tantargyfelosztasFromAscModelList.AddRange(CreateTantargyfelosztasNincsOsztalyNincsCsoportTobbTanar(filteredLessonList));

            return tantargyfelosztasFromAscModelList;
        }

        private static List<LessonModel> GetFilteredLessonList(List<LessonModel> lessonList, bool isTobbOsztaly, bool isTobbCsoport, bool isTobbTanar, bool isNincsMegadvaOsztaly, bool isNincsMegadvaCsoport)
        {
            List<LessonModel> result = lessonList.Where(x =>
                x.IsTobbOsztaly == isTobbOsztaly &&
                x.IsTobbCsoport == isTobbCsoport &&
                x.IsTobbTanar == isTobbTanar &&
                x.IsNincsMegadvaOsztaly == isNincsMegadvaOsztaly &&
                x.IsNincsMegadvaCsoport == isNincsMegadvaCsoport).ToList();
            return result;
        }

        private static List<TantargyfelosztasFromAscModel> CreateTantargyfelosztasEgyOsztalyEgyCsoportEgyTanar(List<LessonModel> filteredLessonList)
        {
            var tantargyfelosztasFromAscModelList = new List<TantargyfelosztasFromAscModel>();
            foreach (LessonModel lesson in filteredLessonList)
            {
                string osztalyNevFromLesson = lesson.OsztalyDictionary.SingleOrDefault().Value;

                string csoportNevFromLesson = GetCsoportNevById(lesson.CsoportDictionary.SingleOrDefault().Key);
                string osztalyCsoportNevFromLesson = $"{osztalyNevFromLesson} {csoportNevFromLesson}";

                string osztalyNev = osztalyNevFromLesson;
                string csoportNev = osztalyNevFromLesson.ToComparableString() == osztalyCsoportNevFromLesson.ToComparableString() ? string.Empty : osztalyCsoportNevFromLesson;
                string tanarNev = lesson.TanarDictionary.SingleOrDefault().Value;
                tantargyfelosztasFromAscModelList.Add(GetTantargyfelosztasFromAscModel(lesson, osztalyNev, csoportNev, tanarNev));
            }

            return tantargyfelosztasFromAscModelList;
        }

        private static List<TantargyfelosztasFromAscModel> CreateTantargyfelosztasEgyOsztalyEgyCsoportTobbTanar(List<LessonModel> filteredLessonList)
        {
            var tantargyfelosztasFromAscModelList = new List<TantargyfelosztasFromAscModel>();
            foreach (LessonModel lesson in filteredLessonList)
            {
                string osztalyNevFromLesson = lesson.OsztalyDictionary.SingleOrDefault().Value;
                string csoportNevFromLesson = GetCsoportNevById(lesson.CsoportDictionary.SingleOrDefault().Key);
                foreach (var tanar in lesson.TanarDictionary)
                {
                    string osztalyNev = osztalyNevFromLesson;
                    string csoportNev = $"{osztalyNevFromLesson} {csoportNevFromLesson} - {lesson.TantargyNev} - {tanar.Value}";
                    string tanarNev = tanar.Value;
                    tantargyfelosztasFromAscModelList.Add(GetTantargyfelosztasFromAscModel(lesson, osztalyNev, csoportNev, tanarNev));
                }
            }

            return tantargyfelosztasFromAscModelList;
        }

        private static List<TantargyfelosztasFromAscModel> CreateTantargyfelosztasEgyOsztalyTobbCsoportEgyTanar(List<LessonModel> filteredLessonList)
        {
            var tantargyfelosztasFromAscModelList = new List<TantargyfelosztasFromAscModel>();
            foreach (LessonModel lesson in filteredLessonList)
            {
                string csoportNevFromLesson = string.Join(", ", lesson.CsoportDictionary.Select(x => GetCsoportNevById(x.Key)).Where(x => !string.IsNullOrWhiteSpace(x)));

                string osztalyNev = lesson.OsztalyDictionary.SingleOrDefault().Value;
                string csoportNev = $"{osztalyNev} {csoportNevFromLesson}";
                string tanarNev = lesson.TanarDictionary.SingleOrDefault().Value;
                tantargyfelosztasFromAscModelList.Add(GetTantargyfelosztasFromAscModel(lesson, osztalyNev, csoportNev, tanarNev));
            }

            return tantargyfelosztasFromAscModelList;
        }

        private static List<TantargyfelosztasFromAscModel> CreateTantargyfelosztasEgyOsztalyTobbCsoportTobbTanar(List<LessonModel> filteredLessonList)
        {
            var tantargyfelosztasFromAscModelList = new List<TantargyfelosztasFromAscModel>();
            foreach (LessonModel lesson in filteredLessonList)
            {
                string csoportNevFromLesson = string.Join(", ", lesson.CsoportDictionary.Select(x => GetCsoportNevById(x.Key)).Where(x => !string.IsNullOrWhiteSpace(x)));

                foreach (var tanar in lesson.TanarDictionary)
                {
                    string osztalyNev = lesson.OsztalyDictionary.SingleOrDefault().Value;
                    string csoportNev = $"{osztalyNev} {csoportNevFromLesson} - {lesson.TantargyNev} - {tanar.Value}";
                    string tanarNev = tanar.Value;
                    tantargyfelosztasFromAscModelList.Add(GetTantargyfelosztasFromAscModel(lesson, osztalyNev, csoportNev, tanarNev));
                }
            }

            return tantargyfelosztasFromAscModelList;
        }

        private static List<TantargyfelosztasFromAscModel> CreateTantargyfelosztasTobbOsztalyTobbCsoportEgyTanar(List<LessonModel> filteredLessonList)
        {
            var tantargyfelosztasFromAscModelList = new List<TantargyfelosztasFromAscModel>();
            foreach (LessonModel lesson in filteredLessonList)
            {
                List<List<string>> osztalyonkentiCsoportNevList = GetCsoportNevekOsztalyonkent(lesson);

                bool isOsztalyonkentAzonosCsoportok = CheckOsztalyonkentAzonosCsoportok(osztalyonkentiCsoportNevList);

                string osztalyCsoportNevFromLesson;
                if (isOsztalyonkentAzonosCsoportok)
                {
                    List<string> osztalyNevList = lesson.OsztalyDictionary.Select(x => x.Value).ToList();
                    string osztalyNevFromLesson = string.Join(", ", osztalyNevList);

                    Dictionary<string, string> uniqueCsoportDictionary = GetDictionaryUniqueItemsByValue(lesson.CsoportDictionary);
                    string csoportNevFromLesson = string.Join(", ", uniqueCsoportDictionary.Select(x => GetCsoportNevById(x.Key)).Where(x => !string.IsNullOrWhiteSpace(x)));

                    osztalyCsoportNevFromLesson = $"{osztalyNevFromLesson} {csoportNevFromLesson}";
                }
                else
                {
                    string csoportNevFromLesson = string.Empty;
                    foreach (var osztaly in lesson.OsztalyDictionary)
                    {
                        IEnumerable<AscCsoport> osztalyhozTartozoCsoportok = AscImportData.CsoportLista.Where(x => x.OsztalyId.Equals(osztaly.Key, StringComparison.OrdinalIgnoreCase) && lesson.CsoportDictionary.Select(c => c.Key).Contains(x.Id) && !AscEgeszOsztalyNevuCsoportIdList.Contains(x.Id));

                        List<string> distinctCsoportNevek = osztalyhozTartozoCsoportok.Select(x => x.Nev).Distinct().ToList();
                        string csoportNevListString = string.Join(", ", distinctCsoportNevek);

                        csoportNevFromLesson += $"{osztaly.Value} {csoportNevListString}; ";
                    }

                    csoportNevFromLesson = csoportNevFromLesson.TrimEnd(' ', ';');

                    osztalyCsoportNevFromLesson = csoportNevFromLesson;
                }

                //NOTE: Az osztály neve itt üres, mert ha több osztály van megadva az ASC-ben, akkor azok nálunk csoportonként jönnek létre pl.:
                //      8.A, 8.B testnevelés, az nálunk egy közös csoport lesz.
                string osztalyNev = string.Empty;
                string csoportNev = osztalyCsoportNevFromLesson;
                string tanarNev = lesson.TanarDictionary.SingleOrDefault().Value;
                tantargyfelosztasFromAscModelList.Add(GetTantargyfelosztasFromAscModel(lesson, osztalyNev, csoportNev, tanarNev));
            }

            return tantargyfelosztasFromAscModelList;
        }

        private static List<TantargyfelosztasFromAscModel> CreateTantargyfelosztasTobbOsztalyTobbCsoportTobbTanar(List<LessonModel> filteredLessonList)
        {
            var tantargyfelosztasFromAscModelList = new List<TantargyfelosztasFromAscModel>();
            foreach (LessonModel lesson in filteredLessonList)
            {
                List<List<string>> osztalyonkentiCsoportNevList = GetCsoportNevekOsztalyonkent(lesson);

                bool isOsztalyonkentAzonosCsoportok = CheckOsztalyonkentAzonosCsoportok(osztalyonkentiCsoportNevList);

                string osztalyCsoportNevFromLesson;
                if (isOsztalyonkentAzonosCsoportok)
                {
                    List<string> osztalyNevList = lesson.OsztalyDictionary.Select(x => x.Value).ToList();
                    string osztalyNevFromLesson = string.Join(", ", osztalyNevList);

                    Dictionary<string, string> uniqueCsoportDictionary = GetDictionaryUniqueItemsByValue(lesson.CsoportDictionary);
                    string csoportNevFromLesson = string.Join(", ", uniqueCsoportDictionary.Select(x => GetCsoportNevById(x.Key)).Where(x => !string.IsNullOrWhiteSpace(x)));

                    osztalyCsoportNevFromLesson = $"{osztalyNevFromLesson} {csoportNevFromLesson} - {lesson.TantargyNev}";
                }
                else
                {
                    string csoportNevFromLesson = string.Empty;
                    foreach (var osztaly in lesson.OsztalyDictionary)
                    {
                        IEnumerable<AscCsoport> osztalyhozTartozoCsoportok = AscImportData.CsoportLista.Where(x => x.OsztalyId.Equals(osztaly.Key, StringComparison.OrdinalIgnoreCase) && lesson.CsoportDictionary.Select(c => c.Key).Contains(x.Id) && !AscEgeszOsztalyNevuCsoportIdList.Contains(x.Id));

                        List<string> distinctCsoportNevek = osztalyhozTartozoCsoportok.Select(x => x.Nev).Distinct().ToList();
                        string csoportNevListString = string.Join(", ", distinctCsoportNevek);

                        csoportNevFromLesson += $"{osztaly.Value} {csoportNevListString}; ";
                    }

                    csoportNevFromLesson = csoportNevFromLesson.TrimEnd(' ', ';');

                    osztalyCsoportNevFromLesson = $"{csoportNevFromLesson} - {lesson.TantargyNev} ";
                }

                foreach (var tanar in lesson.TanarDictionary)
                {
                    //NOTE: Az osztály neve itt üres, mert ha több osztály van megadva az ASC-ben, akkor azok nálunk csoportonként jönnek létre pl.:
                    //      8.A, 8.B testnevelés, az nálunk egy közös csoport lesz.
                    string osztalyNev = string.Empty;
                    string csoportNev = $"{osztalyCsoportNevFromLesson} - {tanar.Value}";
                    string tanarNev = tanar.Value;
                    tantargyfelosztasFromAscModelList.Add(GetTantargyfelosztasFromAscModel(lesson, osztalyNev, csoportNev, tanarNev));
                }
            }

            return tantargyfelosztasFromAscModelList;
        }

        private static List<TantargyfelosztasFromAscModel> CreateTantargyfelosztasNincsOsztalyNincsCsoportEgyTanar(List<LessonModel> filteredLessonList)
        {
            var tantargyfelosztasFromAscModelList = new List<TantargyfelosztasFromAscModel>();
            foreach (LessonModel lesson in filteredLessonList)
            {
                string tanarNevFromLesson = lesson.TanarDictionary.SingleOrDefault().Value;
                int counter = tantargyfelosztasFromAscModelList.Select(x => x.CsoportNev).Count(x => x.Contains($"{lesson.TantargyNev} - {tanarNevFromLesson}")) + 1;

                //NOTE: Az osztály neve itt üres, mert ha több osztály van megadva az ASC-ben, akkor azok nálunk csoportonként jönnek létre pl.:
                //      8.A, 8.B testnevelés, az nálunk egy közös csoport lesz.
                string osztalyNev = string.Empty;
                string csoportNev = $"{lesson.TantargyNev} - {tanarNevFromLesson} {counter}";
                string tanarNev = tanarNevFromLesson;
                tantargyfelosztasFromAscModelList.Add(GetTantargyfelosztasFromAscModel(lesson, osztalyNev, csoportNev, tanarNev));
            }

            return tantargyfelosztasFromAscModelList;
        }

        private static List<TantargyfelosztasFromAscModel> CreateTantargyfelosztasNincsOsztalyNincsCsoportTobbTanar(List<LessonModel> filteredLessonList)
        {
            var tantargyfelosztasFromAscModelList = new List<TantargyfelosztasFromAscModel>();
            foreach (LessonModel lesson in filteredLessonList)
            {
                foreach (var tanar in lesson.TanarDictionary)
                {
                    string tanarNevFromLesson = tanar.Value;

                    int counter = tantargyfelosztasFromAscModelList.Select(x => x.CsoportNev).Count(x => x.Contains($"{lesson.TantargyNev} - {tanarNevFromLesson}")) + 1;

                    //NOTE: Az osztály neve itt üres, mert ha több osztály van megadva az ASC-ben, akkor azok nálunk csoportonként jönnek létre pl.:
                    //      8.A, 8.B testnevelés, az nálunk egy közös csoport lesz.
                    string osztalyNev = string.Empty;
                    string csoportNev = $"{lesson.TantargyNev} - {tanarNevFromLesson} {counter}";
                    string tanarNev = tanarNevFromLesson;
                    tantargyfelosztasFromAscModelList.Add(GetTantargyfelosztasFromAscModel(lesson, osztalyNev, csoportNev, tanarNev));
                }
            }

            return tantargyfelosztasFromAscModelList;
        }

        private static TantargyfelosztasFromAscModel GetTantargyfelosztasFromAscModel(LessonModel lesson, string osztalyNev, string csoportNev, string tanarNev)
        {
            var tantargyfelosztas = new TantargyfelosztasFromAscModel
            {
                Id = lesson.LessonIdFromAscXml.ReplaceMultipleSpacesAndTrim(),
                TantargyNev = lesson.TantargyNev.ReplaceMultipleSpacesAndTrim(),
                Oraszam = lesson.HetiOraszam.ReplaceMultipleSpacesAndTrim(),
                LessonHetirendIdFromAsc = lesson.LessonHetirendId.ReplaceMultipleSpacesAndTrim(),

                OsztalyNev = osztalyNev.ReplaceMultipleSpacesAndTrim(),
                CsoportNev = csoportNev.ReplaceMultipleSpacesAndTrim(),
                TanarNev = tanarNev.ReplaceMultipleSpacesAndTrim()
            };
            return tantargyfelosztas;
        }

        private static List<List<string>> GetCsoportNevekOsztalyonkent(LessonModel lesson)
        {
            var osztalyonkentiCsoportNevList = new List<List<string>>();
            foreach (var osztaly in lesson.OsztalyDictionary)
            {
                IEnumerable<AscCsoport> osztalyhozTartozoCsoportok = AscImportData.CsoportLista.Where(x => x.OsztalyId.Equals(osztaly.Key, StringComparison.OrdinalIgnoreCase) && lesson.CsoportDictionary.Select(c => c.Key).Contains(x.Id));
                osztalyonkentiCsoportNevList.Add(osztalyhozTartozoCsoportok.Select(x => x.Nev).OrderBy(x => x).ToList());
            }

            return osztalyonkentiCsoportNevList;
        }

        private static Dictionary<string, string> GetDictionaryUniqueItemsByValue(Dictionary<string, string> dictionary)
        {
            Dictionary<string, string> result = dictionary
                .GroupBy(x => x.Value)
                .Select(x => x.First())
                .OrderBy(x => x.Value)
                .ToDictionary(x => x.Key, x => x.Value);
            return result;
        }

        private static bool CheckOsztalyonkentAzonosCsoportok(List<List<string>> osztalyonkentiCsoportNevList)
        {
            bool isOsztalyonkentEgyezoCsoport = true;
            for (int i = 1; i < osztalyonkentiCsoportNevList.Count; i++)
            {
                isOsztalyonkentEgyezoCsoport = isOsztalyonkentEgyezoCsoport && osztalyonkentiCsoportNevList[0].ToList().SequenceEqual(osztalyonkentiCsoportNevList[i].ToList());
            }

            return isOsztalyonkentEgyezoCsoport;
        }

        private static string GetCsoportNevById(string csoportId)
        {
            AscCsoport csoport = AscImportData.CsoportLista.SingleOrDefault(x => x.Id.Equals(csoportId));
            string csoportNev = string.Empty;
            if (csoport != null)
            {
                csoportNev = AscEgeszOsztalyNevuCsoportIdList.Contains(csoport.Id) ? string.Empty : csoport.Nev;
            }

            return csoportNev;
        }

        private static List<LessonModel> CreateLessonListFromAscXml(timetable ascTimeTable)
        {
            var lessonList = new List<LessonModel>();

            AscImportData.OsztalyLista = GetOsztalyListFromAsc(ascTimeTable.classes?.@class?.ToList() ?? new List<timetableClassesClass>());
            AscImportData.CsoportLista = GetCsoportListFromAsc(ascTimeTable.groups?.group?.ToList() ?? new List<timetableGroupsGroup>());
            AscImportData.TantargyLista = GetTantargyListFromAsc(ascTimeTable.subjects.subject.ToList());
            AscImportData.TanarLista = GetTanarListFromAsc(ascTimeTable.teachers.teacher.ToList());

            AscEgeszOsztalyNevuCsoportIdList = AscImportData.CsoportLista.Where(x => x.FelosztasId == "0").Select(x => x.Id).ToList();

            foreach (timetableLessonsLesson lessonItem in ascTimeTable.lessons.lesson)
            {
                var tantargy = AscImportData.TantargyLista.SingleOrDefault(x => x.Id == lessonItem.subjectid);
                string tantargyNev = string.Empty;
                if (tantargy != null)
                {
                    tantargyNev = tantargy.Nev;
                }

                var lesson = new LessonModel
                {
                    OsztalyDictionary = GetOsztalyDictionary(lessonItem.classids, AscImportData.OsztalyLista),
                    CsoportDictionary = GetCsoportDictionary(lessonItem.groupids, AscImportData.CsoportLista),
                    TanarDictionary = GetTanarDictionary(lessonItem.teacherids, AscImportData.TanarLista),
                    TantargyNev = tantargyNev,
                    HetiOraszam = lessonItem.periodsperweek,
                    LessonHetirendId = string.IsNullOrWhiteSpace(lessonItem.weeksdefid) ? lessonItem.weeks : lessonItem.weeksdefid,
                    LessonIdFromAscXml = lessonItem.id
                };
                lesson.IsTobbOsztaly = lesson.OsztalyDictionary.Count > 1;
                lesson.IsTobbCsoport = lesson.CsoportDictionary.Count > 1;
                lesson.IsTobbTanar = lesson.TanarDictionary.Count > 1;
                lesson.IsNincsMegadvaOsztaly = lesson.OsztalyDictionary.Count == 0;
                lesson.IsNincsMegadvaCsoport = lesson.CsoportDictionary.Count == 0;

                lessonList.Add(lesson);
            }

            return lessonList;
        }

        private static List<AscOsztaly> GetOsztalyListFromAsc(List<timetableClassesClass> classList)
        {
            var ascOsztalyList = new List<AscOsztaly>();
            foreach (timetableClassesClass osztaly in classList)
            {
                ascOsztalyList.Add(new AscOsztaly
                {
                    Id = osztaly.id,
                    Nev = osztaly.name.ReplaceMultipleSpacesAndTrim()
                });
            }

            return ascOsztalyList;
        }

        private static List<AscCsoport> GetCsoportListFromAsc(List<timetableGroupsGroup> groupList)
        {
            var ascCsoportList = new List<AscCsoport>();
            foreach (timetableGroupsGroup csoport in groupList)
            {
                csoport.divisiontag = string.IsNullOrWhiteSpace(csoport.divisiontag) ? "0" : csoport.divisiontag;
                ascCsoportList.Add(new AscCsoport
                {
                    Id = csoport.id,
                    Nev = csoport.name.ReplaceMultipleSpacesAndTrim(),
                    OsztalyId = csoport.classid,
                    FelosztasId = csoport.divisiontag
                });
            }

            return ascCsoportList;
        }

        private static List<AscTantargy> GetTantargyListFromAsc(List<timetableSubjectsSubject> subjectList)
        {
            var ascTantargyList = new List<AscTantargy>();
            foreach (timetableSubjectsSubject tantargy in subjectList)
            {
                ascTantargyList.Add(new AscTantargy
                {
                    Id = tantargy.id,
                    Nev = tantargy.name.ReplaceMultipleSpacesAndTrim(),
                });
            }

            return ascTantargyList;
        }

        private static List<AscTanar> GetTanarListFromAsc(List<timetableTeachersTeacher> teacherList)
        {
            var ascTanarList = new List<AscTanar>();
            foreach (timetableTeachersTeacher tanar in teacherList)
            {
                ascTanarList.Add(new AscTanar
                {
                    Id = tanar.id,
                    Nev = tanar.name.ReplaceMultipleSpacesAndTrim()
                });
            }

            return ascTanarList;
        }

        private static Dictionary<string, string> GetOsztalyDictionary(string osztalyIdListString, List<AscOsztaly> ascOsztalyList)
        {
            var osztalyDictionary = new Dictionary<string, string>();
            if (!string.IsNullOrWhiteSpace(osztalyIdListString))
            {
                foreach (string osztalyId in osztalyIdListString.Split(',').ToList())
                {
                    var osztaly = ascOsztalyList.SingleOrDefault(x => x.Id.Equals(osztalyId));
                    if (osztaly != null)
                    {
                        osztalyDictionary.Add(osztalyId, osztaly.Nev);
                    }
                }
            }

            return osztalyDictionary;
        }

        private static Dictionary<string, string> GetCsoportDictionary(string csoportIdListString, List<AscCsoport> ascCsoportList)
        {
            var csoportDictionary = new Dictionary<string, string>();
            if (!string.IsNullOrWhiteSpace(csoportIdListString))
            {
                foreach (string csoportId in csoportIdListString.Split(',').ToList())
                {
                    var csoport = ascCsoportList.SingleOrDefault(x => x.Id.Equals(csoportId));
                    if (csoport != null)
                    {
                        csoportDictionary.Add(csoportId, csoport.Nev);
                    }
                }
            }

            return csoportDictionary;
        }

        private static Dictionary<string, string> GetTanarDictionary(string tanarIdListString, List<AscTanar> ascTanarList)
        {
            var tanarDictionary = new Dictionary<string, string>();
            if (!string.IsNullOrWhiteSpace(tanarIdListString))
            {
                foreach (string tanarId in tanarIdListString.Split(',').ToList())
                {
                    var tanar = ascTanarList.SingleOrDefault(x => x.Id.Equals(tanarId));
                    if (tanar != null && !tanarDictionary.ContainsKey(tanar.Id))
                    {
                        tanarDictionary.Add(tanarId, tanar.Nev);
                    }
                }
            }

            return tanarDictionary;
        }

        public MemoryStream ConvertAscXmlToExcel(Stream ascImportFileStream)
        {
            var dropDownColumnSourceDictionary = new OrarendImportExportHelper(ConnectionType).GetDefaultDropDownColumnSourceDictionary(false);
            List<List<string>> importData = GetOrarendImportDataFromAsc(ascImportFileStream, DateTime.Now.ToShortDateString(), DateTime.Now.ToShortDateString());
            using (var workbook = new Workbook())
            {
                List<SimpleExportColumnCo> simpleExportColumnCos = SimpleExportLogic.GetSimpleExportColumnCos(OrarendImportExportHelper.ImportHeaderList, dropDownColumnSourceDictionary);
                Worksheet worksheet = SimpleExportLogic.GetWorksheet(workbook, ImportExportOrarendResource.OrarendImport, simpleExportColumnCos);

                int rowIndex = 1;
                //NOTE: A Skip(1), azért kell, mert az asc-ből generált string listába beletesszük a header-öket az importálásokhoz, de a konvertáláshoz mi saját header-t generálunk!
                foreach (List<string> importDataRow in importData.Skip(1))
                {
                    int columnIndex = 0;
                    //NOTE: A Skip(2), azért kell, mert az óra érvényességi idők(kezdete, vége) nincs benne az xml-ben, viszont, mi belegeneráljuk a string lista első két elemeként!
                    foreach (string importDataCell in importDataRow.Skip(2).ToList())
                    {
                        worksheet.Cells[rowIndex, columnIndex].Value = importDataCell;
                        columnIndex++;
                    }

                    rowIndex++;
                }

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

    public class TantargyfelosztasFromAscModel : BaseTantargyfelosztasFromAscModel
    {
        public string Oraszam { get; set; }

        public string LessonHetirendIdFromAsc { get; set; }
    }

    public class OrarendFromAscModel : BaseTantargyfelosztasFromAscModel
    {
        public string Hetirend { get; set; }

        public string Nap { get; set; }

        public string Ora { get; set; }

        public string TeremNev { get; set; }
    }

    public class BaseTantargyfelosztasFromAscModel
    {
        public string Id { get; set; }

        public string OsztalyNev { get; set; }

        public string CsoportNev { get; set; }

        public string TantargyNev { get; set; }

        public string TanarNev { get; set; }
    }
}