using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using BeWo.Data.Access;
using BeWo.Data.Entities;
using BeWo.Service.DCEntityMapper;
using BeWo.Service.ServiceImplementations;
using BS.Shared;
using BS.Shared.Core;
using BS.Shared.DataContracts;
using BS.Shared.DataContracts.Compact;
using BS.Shared.Extensions;

namespace BeWo.Service.Plugins
{
    public class VacationService : AbstractIDSpecificDefaultClass<VacationService>
    {
        private List<FeiertagDC> databaseFeiertage = null;
        private List<DateTime> _Feiertage { get;set; }
        private string _Bundesland = "NRW";

        public virtual string Bundesland
        {
            get 
            {
                return _Bundesland;
            }
            set 
            {
                _Bundesland = value;
            }
        }

        public virtual bool IstFeiertag(DateTime start)
        {
            List<DateTime> feiertage = GetFeiertage(start.Year);

            foreach (var ft in feiertage)
            {
                if (start.Date == ft)
                    return true;
            }
            return false;
        }

        public virtual List<DateTime> GetFeiertage(int year)
        {
            var list = GetFeiertage(year, Bundesland);

            return list.Select(f => f.Datum).ToList();
        }

        public virtual FeiertagDC GetFeiertag(DateTime start)
        {
            var feiertage = GetFeiertage(start.Year, Bundesland);

            foreach (var ft in feiertage)
            {
                if (start == ft.Datum)
                    return ft;
            }
            return null;
        }

        public virtual FerienDC GetFerien(DateTime start, String bundesland)
        {
            var ferienList = GetFerien(bundesland);

            foreach (var ferien in ferienList)
            {
                if (start >= ferien.Start && start <= ferien.Ende)
                    return ferien;
            }
            return null;
        }

        public virtual List<FeiertagDC> GetFeiertage(int year, String bundesland)
        {
            List<FeiertagDC> list = new List<FeiertagDC>();

            list.Add(new FeiertagDC { Datum = new DateTime(year, 1, 1), Name = "Neujahr" });
            //list.Add(new DateTime(year, 1, 6)); // , "Heilige Drei Könige"));
            list.Add(new FeiertagDC { Datum = new DateTime(year, 5, 1), Name = "Tag der Arbeit" });
            //list.Add(new DateTime(year, 8, 15)); // , "Mariä Himmelfahrt"));
            list.Add(new FeiertagDC { Datum = new DateTime(year, 10, 3), Name = "Tag der Deutschen Einheit" });
            //list.Add(new DateTime(year, 10, 31)); // , "Reformationstag"));

            if (bundesland.ToLower() == "bayern")
            {
                //ACHTUNG nicht überall in Bayern Feiertag!!!
                list.Add(new FeiertagDC { Datum = new DateTime(year, 8, 15), Name = "Mariä Himmelfahrt" });

                list.Add(new FeiertagDC { Datum = new DateTime(year, 1, 6), Name = "Heilige Drei Könige" });
            }

            if (bundesland.ToLower() == "nrw" || bundesland.ToLower() == "bayern" || bundesland.ToLower() == "rheinland-pfalz")
            {
                list.Add(new FeiertagDC { Datum = new DateTime(year, 11, 1), Name = "Allerheiligen" });
            }
            

            list.Add(new FeiertagDC { Datum = new DateTime(year, 12, 24), Name = "Heilig Abend" }); // Eigentlich kein gesetzlicher Feiertag, wird bei uns aber immer als Standard gesetzt, da in der Praxis die meisten Unternehmen einen halben für Heilig Abend und einen halben für Silvester geben.

            list.Add(new FeiertagDC { Datum = new DateTime(year, 12, 25), Name = "1. Weihnachtstag" });
            list.Add(new FeiertagDC { Datum = new DateTime(year, 12, 26), Name = "2. Weihnachtstag" });

            if (year == 2017 || bundesland.ToLower() == "brandenburg" || bundesland.ToLower() == "niedersachsen")
                list.Add(new FeiertagDC { Datum = new DateTime(year, 10, 31), Name = "Reformationstag" });

            DateTime osterSonntag = GetOsterSonntag(year);
            //list.Add(osterSonntag); // , "Ostersonntag"));
            //list.Add(osterSonntag.AddDays(-3)); // , "Gründonnerstag"));	q
            //list.Add(osterSonntag.AddDays(-48)); // , "Rosenmontag"));
            list.Add(new FeiertagDC { Datum = osterSonntag.AddDays(-2), Name = "Karfreitag" });
            list.Add(new FeiertagDC { Datum = osterSonntag.AddDays(1), Name = "Ostermontag" });
            list.Add(new FeiertagDC { Datum = osterSonntag.AddDays(39), Name = "Christi Himmelfahrt" });
            list.Add(new FeiertagDC { Datum = osterSonntag.AddDays(50), Name = "Pfingstmontag" });

            if (bundesland.ToLower() == "nrw" || bundesland.ToLower() == "hessen" || bundesland.ToLower() == "bayern" || bundesland.ToLower() == "rheinland-pfalz")
                list.Add(new FeiertagDC { Datum = osterSonntag.AddDays(60), Name = "Fronleichnam" });


            list.AddRange(GetDBFeiertage(year));
            
            return list;
        }

        //Für zentrale Ablage der Feiertage
        public virtual List<FeiertagDC> GetDBFeiertage(int year)
        {
            if (databaseFeiertage == null)
            {
                var feiertage = DAOFactory.GenericDAO.GetAllActive<Feiertag>();

                databaseFeiertage = MapperFactory.FeiertagDC_Feiertag.MapToNewDCs(feiertage.Where(f => !f.OrganisationOid.HasValue));

            }

            
            return databaseFeiertage.Where(f => f.Datum >= new DateTime(year, 1, 1) && f.Datum < new DateTime(year + 1, 1, 1)).ToList();
        }

        public static DateTime GetOsterSonntag(int year)
        {

            int g, h, c, j, l, i;

            g = year % 19;
            c = year / 100;
            h = ((c - (c / 4)) - (((8 * c) + 13) / 25) + (19 * g) + 15) % 30;
            i = h - (h / 28) * (1 - (29 / (h + 1)) * ((21 - g) / 11));
            j = (year + (year / 4) + i + 2 - c + (c / 4)) % 7;

            l = i - j;
            int month = (int)(3 + ((l + 40) / 44));
            int day = (int)(l + 28 - 31 * (month / 4));

            return new DateTime(year, month, day);

        }

        public virtual List<FerienDC> GetFerien(String bundesland = "nrw")
        {
            List<FerienDC> list = new List<FerienDC>();

            if (bundesland.ToLower() == "nrw")
            {
                list.Add(new FerienDC() { Name = "Sommerferien 2014", Start = new DateTime(2014, 7, 7), Ende = new DateTime(2014, 8, 19) });
                list.Add(new FerienDC() { Name = "Herbstferien 2014", Start = new DateTime(2014, 10, 6), Ende = new DateTime(2014, 10, 18) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2014", Start = new DateTime(2014, 12, 22), Ende = new DateTime(2015, 1, 6) });

                list.Add(new FerienDC() { Name = "Osterferien 2015", Start = new DateTime(2015, 3, 30), Ende = new DateTime(2015, 4, 11) });
                list.Add(new FerienDC() { Name = "Sommerferien 2015", Start = new DateTime(2015, 6, 29), Ende = new DateTime(2015, 8, 11) });
                list.Add(new FerienDC() { Name = "Herbstferien 2015", Start = new DateTime(2015, 10, 5), Ende = new DateTime(2015, 10, 17) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2015", Start = new DateTime(2015, 12, 23), Ende = new DateTime(2016, 1, 6) });

                list.Add(new FerienDC() { Name = "Osterferien 2016", Start = new DateTime(2016, 3, 21), Ende = new DateTime(2016, 4, 2) });
                list.Add(new FerienDC() { Name = "Sommerferien 2016", Start = new DateTime(2016, 7, 11), Ende = new DateTime(2016, 8, 23) });
                list.Add(new FerienDC() { Name = "Herbstferien 2016", Start = new DateTime(2016, 10, 10), Ende = new DateTime(2016, 10, 21) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2016", Start = new DateTime(2016, 12, 23), Ende = new DateTime(2017, 1, 6) });

                list.Add(new FerienDC() { Name = "Osterferien 2017", Start = new DateTime(2017, 4, 10), Ende = new DateTime(2017, 4, 22) });
                list.Add(new FerienDC() { Name = "Sommerferien 2017", Start = new DateTime(2017, 7, 17), Ende = new DateTime(2017, 8, 29) });
                list.Add(new FerienDC() { Name = "Herbstferien 2017", Start = new DateTime(2017, 10, 23), Ende = new DateTime(2017, 11, 4) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2017", Start = new DateTime(2017, 12, 27), Ende = new DateTime(2018, 1, 6) });

                list.Add(new FerienDC() { Name = "Osterferien 2018", Start = new DateTime(2018, 3, 26), Ende = new DateTime(2018, 4, 7) });
                list.Add(new FerienDC() { Name = "Sommerferien 2018", Start = new DateTime(2018, 7, 16), Ende = new DateTime(2018, 8, 28) });
                list.Add(new FerienDC() { Name = "Herbstferien 2018", Start = new DateTime(2018, 10, 15), Ende = new DateTime(2018, 10, 27) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2018", Start = new DateTime(2018, 12, 21), Ende = new DateTime(2019, 1, 4) });

                list.Add(new FerienDC() { Name = "Osterferien 2019", Start = new DateTime(2019, 4, 15), Ende = new DateTime(2019, 4, 27) });
                list.Add(new FerienDC() { Name = "Sommerferien 2019", Start = new DateTime(2019, 7, 15), Ende = new DateTime(2019, 8, 27) });
                list.Add(new FerienDC() { Name = "Herbstferien 2019", Start = new DateTime(2019, 10, 14), Ende = new DateTime(2019, 10, 26) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2019", Start = new DateTime(2019, 12, 23), Ende = new DateTime(2020, 1, 6) });

                list.Add(new FerienDC() { Name = "Osterferien 2020", Start = new DateTime(2020, 4, 6), Ende = new DateTime(2020, 4, 18) });
                list.Add(new FerienDC() { Name = "Sommerferien 2020", Start = new DateTime(2020, 6, 29), Ende = new DateTime(2020, 8, 11) });
                list.Add(new FerienDC() { Name = "Herbstferien 2020", Start = new DateTime(2020, 10, 12), Ende = new DateTime(2020, 10, 24) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2020", Start = new DateTime(2020, 12, 21), Ende = new DateTime(2021, 1, 6) });

                list.Add(new FerienDC() { Name = "Osterferien 2021", Start = new DateTime(2021, 3, 29), Ende = new DateTime(2021, 4, 10) });
                list.Add(new FerienDC() { Name = "Sommerferien 2021", Start = new DateTime(2021, 7, 5), Ende = new DateTime(2021, 8, 17) });
                list.Add(new FerienDC() { Name = "Herbstferien 2021", Start = new DateTime(2021, 10, 11), Ende = new DateTime(2021, 10, 23) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2021", Start = new DateTime(2021, 12, 24), Ende = new DateTime(2022, 1, 8) });

                list.Add(new FerienDC() { Name = "Osterferien 2022", Start = new DateTime(2022, 4, 11), Ende = new DateTime(2022, 4, 23) });
                list.Add(new FerienDC() { Name = "Sommerferien 2022", Start = new DateTime(2022, 6, 27), Ende = new DateTime(2022, 8, 9) });
                list.Add(new FerienDC() { Name = "Herbstferien 2022", Start = new DateTime(2022, 10, 4), Ende = new DateTime(2022, 10, 15) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2022", Start = new DateTime(2022, 12, 23), Ende = new DateTime(2023, 1, 7) });

                list.Add(new FerienDC() { Name = "Osterferien 2023", Start = new DateTime(2023, 4, 3), Ende = new DateTime(2023, 4, 15) });
                list.Add(new FerienDC() { Name = "Sommerferien 2023", Start = new DateTime(2023, 6, 22), Ende = new DateTime(2023, 8, 5) });
                list.Add(new FerienDC() { Name = "Herbstferien 2023", Start = new DateTime(2023, 10, 2), Ende = new DateTime(2023, 10, 14) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2023", Start = new DateTime(2023, 12, 21), Ende = new DateTime(2024, 1, 5) });

                list.Add(new FerienDC() { Name = "Osterferien 2024", Start = new DateTime(2024, 3, 25), Ende = new DateTime(2024, 4, 6) });
                list.Add(new FerienDC() { Name = "Pfingstferien 2024", Start = new DateTime(2024, 5, 21), Ende = new DateTime(2024, 5, 21) });
                list.Add(new FerienDC() { Name = "Sommerferien 2024", Start = new DateTime(2024, 7, 8), Ende = new DateTime(2024, 8, 20) });
                list.Add(new FerienDC() { Name = "Herbstferien 2024", Start = new DateTime(2024, 10, 14), Ende = new DateTime(2024, 10, 26) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2024", Start = new DateTime(2024, 12, 23), Ende = new DateTime(2025, 1, 6) });

                list.Add(new FerienDC() { Name = "Osterferien 2025", Start = new DateTime(2025, 4, 14), Ende = new DateTime(2025, 4, 26) });
                list.Add(new FerienDC() { Name = "Pfingstferien 2025", Start = new DateTime(2025, 6, 10), Ende = new DateTime(2025, 6, 10) });
                list.Add(new FerienDC() { Name = "Sommerferien 2025", Start = new DateTime(2025, 7, 14), Ende = new DateTime(2025, 8, 26) });
                list.Add(new FerienDC() { Name = "Herbstferien 2025", Start = new DateTime(2025, 10, 13), Ende = new DateTime(2025, 10, 25) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2025", Start = new DateTime(2025, 12, 22), Ende = new DateTime(2026, 1, 6) });

                list.Add(new FerienDC() { Name = "Osterferien 2026", Start = new DateTime(2026, 3, 30), Ende = new DateTime(2026, 4, 11) });
                list.Add(new FerienDC() { Name = "Pfingstferien 2026", Start = new DateTime(2026, 5, 26), Ende = new DateTime(2026, 5, 26) });
                list.Add(new FerienDC() { Name = "Sommerferien 2026", Start = new DateTime(2026, 7, 20), Ende = new DateTime(2026, 9, 1) });
                list.Add(new FerienDC() { Name = "Herbstferien 2026", Start = new DateTime(2026, 10, 17), Ende = new DateTime(2026, 10, 31) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2026", Start = new DateTime(2026, 12, 23), Ende = new DateTime(2027, 1, 6) });
            }
            else if (bundesland.ToLower() == "niedersachsen")
            {
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2020", Start = new DateTime(2020, 12, 21), Ende = new DateTime(2021, 1, 8) });

                list.Add(new FerienDC() { Name = "Osterferien 2021", Start = new DateTime(2021, 3, 29), Ende = new DateTime(2021, 4, 09) });
                list.Add(new FerienDC() { Name = "Sommerferien 2021", Start = new DateTime(2021, 7, 22), Ende = new DateTime(2021, 9, 1) });
                list.Add(new FerienDC() { Name = "Herbstferien 2021", Start = new DateTime(2021, 10, 18), Ende = new DateTime(2021, 10, 29) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2021", Start = new DateTime(2021, 12, 23), Ende = new DateTime(2022, 1, 7) });

                list.Add(new FerienDC() { Name = "Winterferien 2022", Start = new DateTime(2022, 1, 31), Ende = new DateTime(2022, 2, 1) });
                list.Add(new FerienDC() { Name = "Osterferien 2022", Start = new DateTime(2022, 4, 4), Ende = new DateTime(2022, 4, 19) });
                list.Add(new FerienDC() { Name = "Pfingstferien 2022", Start = new DateTime(2022, 5, 27), Ende = new DateTime(2022, 5, 27) }); //Brückentag Himmelfahrt
                list.Add(new FerienDC() { Name = "Pfingstferien 2022", Start = new DateTime(2022, 6, 7), Ende = new DateTime(2022, 6, 7) });   //Pfingstdienstag
                list.Add(new FerienDC() { Name = "Sommerferien 2022", Start = new DateTime(2022, 7, 14), Ende = new DateTime(2022, 8, 24) });
                list.Add(new FerienDC() { Name = "Herbstferien 2022", Start = new DateTime(2022, 10, 17), Ende = new DateTime(2022, 10, 28) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2022", Start = new DateTime(2022, 12, 23), Ende = new DateTime(2023, 1, 6) });

                list.Add(new FerienDC() { Name = "Winterferien 2023", Start = new DateTime(2023, 1, 30), Ende = new DateTime(2023, 1, 31) });
                list.Add(new FerienDC() { Name = "Osterferien 2023", Start = new DateTime(2023, 3, 27), Ende = new DateTime(2023, 4, 11) });
                list.Add(new FerienDC() { Name = "Brückentag 2023", Start = new DateTime(2023, 5, 19), Ende = new DateTime(2023, 5, 19) }); //Brückentag Himmelfahrt
                list.Add(new FerienDC() { Name = "Pfingstferien 2023", Start = new DateTime(2023, 5, 30), Ende = new DateTime(2023, 5, 31) }); //Pfingstdienstag
                list.Add(new FerienDC() { Name = "Sommerferien 2023", Start = new DateTime(2023, 7, 6), Ende = new DateTime(2023, 8, 17) });
                list.Add(new FerienDC() { Name = "Brückentag 2023", Start = new DateTime(2023, 10, 2), Ende = new DateTime(2023, 10, 3) });
                list.Add(new FerienDC() { Name = "Herbstferien 2023", Start = new DateTime(2023, 10, 16), Ende = new DateTime(2023, 10, 31) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2023", Start = new DateTime(2023, 12, 27), Ende = new DateTime(2024, 1, 6) });

                list.Add(new FerienDC() { Name = "Winterferien 2024", Start = new DateTime(2024, 2, 1), Ende = new DateTime(2024, 2, 3) });
                list.Add(new FerienDC() { Name = "Osterferien 2024", Start = new DateTime(2024, 3, 18), Ende = new DateTime(2024, 3, 29) });
                list.Add(new FerienDC() { Name = "Brückentag 2024", Start = new DateTime(2024, 5, 10), Ende = new DateTime(2024, 5, 10) }); //Brückentag Himmelfahrt
                list.Add(new FerienDC() { Name = "Pfingstferien 2024", Start = new DateTime(2024, 5, 21), Ende = new DateTime(2024, 5, 21) }); //Pfingstdienstag
                list.Add(new FerienDC() { Name = "Sommerferien 2024", Start = new DateTime(2024, 6, 24), Ende = new DateTime(2024, 8, 3) });
                list.Add(new FerienDC() { Name = "Herbstferien 2024", Start = new DateTime(2024, 10, 4), Ende = new DateTime(2024, 10, 19) });
                list.Add(new FerienDC() { Name = "Brückentag 2024", Start = new DateTime(2024, 11, 1), Ende = new DateTime(2024, 11, 1) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2024", Start = new DateTime(2024, 12, 23), Ende = new DateTime(2025, 1, 4) });

                list.Add(new FerienDC() { Name = "Winterferien 2025", Start = new DateTime(2025, 2, 3), Ende = new DateTime(2025, 2, 4) });
                list.Add(new FerienDC() { Name = "Osterferien 2025", Start = new DateTime(2025, 4, 7), Ende = new DateTime(2025, 4, 19) });
                list.Add(new FerienDC() { Name = "Brückentag 2025", Start = new DateTime(2025, 4, 30), Ende = new DateTime(2025, 4, 30) }); //Brückentag 1.Mai
                list.Add(new FerienDC() { Name = "Brückentag 2025", Start = new DateTime(2025, 5, 2), Ende = new DateTime(2025, 5, 2) }); //Brückentag Himmelfahrt
                list.Add(new FerienDC() { Name = "Brückentag 2025", Start = new DateTime(2025, 5, 30), Ende = new DateTime(2025, 5, 30) });
                list.Add(new FerienDC() { Name = "Pfingstferien 2025", Start = new DateTime(2025, 6, 10), Ende = new DateTime(2025, 6, 10) }); //Pfingstdienstag
                list.Add(new FerienDC() { Name = "Sommerferien 2025", Start = new DateTime(2025, 7, 3), Ende = new DateTime(2025, 8, 13) });
                list.Add(new FerienDC() { Name = "Herbstferien 2025", Start = new DateTime(2025, 10, 13), Ende = new DateTime(2025, 10, 25) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2025", Start = new DateTime(2025, 12, 22), Ende = new DateTime(2026, 1, 5) });

                list.Add(new FerienDC() { Name = "Winterferien 2026", Start = new DateTime(2026, 2, 2), Ende = new DateTime(2026, 2, 3) });
                list.Add(new FerienDC() { Name = "Osterferien 2026", Start = new DateTime(2026, 3, 23), Ende = new DateTime(2026, 4, 7) });
                list.Add(new FerienDC() { Name = "Brückentag 2026", Start = new DateTime(2026, 5, 15), Ende = new DateTime(2026, 5, 15) }); //Brückentag Himmelfahrt
                list.Add(new FerienDC() { Name = "Brückentag 2026", Start = new DateTime(2026, 5, 26), Ende = new DateTime(2026, 5, 26) }); 
                list.Add(new FerienDC() { Name = "Sommerferien 2026", Start = new DateTime(2026, 7, 2), Ende = new DateTime(2026, 8, 12) });
                list.Add(new FerienDC() { Name = "Herbstferien 2026", Start = new DateTime(2026, 10, 16), Ende = new DateTime(2026, 10, 30) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2026", Start = new DateTime(2026, 12, 23), Ende = new DateTime(2027, 1, 9) });

            }

            else if (bundesland.ToLower() == "hessen")
            {
                list.Add(new FerienDC() { Name = "Osterferien 2021", Start = new DateTime(2021, 4, 6), Ende = new DateTime(2021, 4, 16) });
                list.Add(new FerienDC() { Name = "Sommerferien 2021", Start = new DateTime(2021, 7, 19), Ende = new DateTime(2021, 8, 27) });
                list.Add(new FerienDC() { Name = "Herbstferien 2021", Start = new DateTime(2021, 10, 11), Ende = new DateTime(2021, 10, 23) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2021", Start = new DateTime(2021, 12, 23), Ende = new DateTime(2022, 1, 8) });

                list.Add(new FerienDC() { Name = "Osterferien 2022", Start = new DateTime(2022, 4, 11), Ende = new DateTime(2022, 4, 23) });
                list.Add(new FerienDC() { Name = "Sommerferien 2022", Start = new DateTime(2022, 7, 25), Ende = new DateTime(2022, 9, 2) });
                list.Add(new FerienDC() { Name = "Herbstferien 2022", Start = new DateTime(2022, 10, 24), Ende = new DateTime(2022, 10, 29) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2022", Start = new DateTime(2022, 12, 22), Ende = new DateTime(2023, 1, 7) });

                list.Add(new FerienDC() { Name = "Osterferien 2023", Start = new DateTime(2023, 4, 3), Ende = new DateTime(2023, 4, 22) });
                list.Add(new FerienDC() { Name = "Sommerferien 2023", Start = new DateTime(2023, 7, 24), Ende = new DateTime(2023, 9, 1) });
                list.Add(new FerienDC() { Name = "Herbstferien 2023", Start = new DateTime(2023, 10, 23), Ende = new DateTime(2023, 10, 28) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2023", Start = new DateTime(2023, 12, 27), Ende = new DateTime(2024, 1, 13) });

                list.Add(new FerienDC() { Name = "Osterferien 2024", Start = new DateTime(2024, 3, 25), Ende = new DateTime(2024, 4, 13) });
                list.Add(new FerienDC() { Name = "Sommerferien 2024", Start = new DateTime(2024, 7, 15), Ende = new DateTime(2024, 8, 23) });
                list.Add(new FerienDC() { Name = "Herbstferien 2024", Start = new DateTime(2024, 10, 14), Ende = new DateTime(2024, 10, 25) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2024", Start = new DateTime(2024, 12, 23), Ende = new DateTime(2025, 1, 10) });

                list.Add(new FerienDC() { Name = "Osterferien 2025", Start = new DateTime(2025, 4, 7), Ende = new DateTime(2025, 4, 21) });
                list.Add(new FerienDC() { Name = "Sommerferien 2025", Start = new DateTime(2025, 7, 7), Ende = new DateTime(2025, 8, 15) });
                list.Add(new FerienDC() { Name = "Herbstferien 2025", Start = new DateTime(2025, 10, 6), Ende = new DateTime(2025, 10, 18) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2025", Start = new DateTime(2025, 12, 22), Ende = new DateTime(2026, 1, 10) });

                list.Add(new FerienDC() { Name = "Osterferien 2026", Start = new DateTime(2026, 3, 30), Ende = new DateTime(2026, 4, 10) });
                list.Add(new FerienDC() { Name = "Sommerferien 2026", Start = new DateTime(2026, 6, 29), Ende = new DateTime(2026, 8, 7) });
                list.Add(new FerienDC() { Name = "Herbstferien 2026", Start = new DateTime(2026, 10, 5), Ende = new DateTime(2026, 10, 17) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2026", Start = new DateTime(2026, 12, 23), Ende = new DateTime(2027, 1, 12) });
            }
            else if (bundesland.ToLower() == "rheinland-pfalz")
            {
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2023", Start = new DateTime(2023, 12, 27), Ende = new DateTime(2024, 1, 5) });
                
                list.Add(new FerienDC() { Name = "Osterferien 2024", Start = new DateTime(2024, 3, 25), Ende = new DateTime(2024, 4, 2) });
                list.Add(new FerienDC() { Name = "Pfingstferien 2024", Start = new DateTime(2024, 5, 21), Ende = new DateTime(2024, 5, 29) });
                list.Add(new FerienDC() { Name = "Sommerferien 2024", Start = new DateTime(2024, 7, 15), Ende = new DateTime(2024, 8, 23) });
                list.Add(new FerienDC() { Name = "Herbstferien 2024", Start = new DateTime(2024, 10, 14), Ende = new DateTime(2024, 10, 25) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2024", Start = new DateTime(2024, 12, 23), Ende = new DateTime(2025, 1, 8) });

                list.Add(new FerienDC() { Name = "Osterferien 2025", Start = new DateTime(2025, 4, 14), Ende = new DateTime(2025, 4, 25) });
                list.Add(new FerienDC() { Name = "Sommerferien 2025", Start = new DateTime(2025, 7, 7), Ende = new DateTime(2025, 8, 15) });
                list.Add(new FerienDC() { Name = "Herbstferien 2025", Start = new DateTime(2025, 10, 13), Ende = new DateTime(2025, 10, 24) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2025", Start = new DateTime(2025, 12, 22), Ende = new DateTime(2026, 1, 7) });

                list.Add(new FerienDC() { Name = "Osterferien 2026", Start = new DateTime(2026, 3, 30), Ende = new DateTime(2026, 4, 10) });
                list.Add(new FerienDC() { Name = "Sommerferien 2026", Start = new DateTime(2026, 6, 29), Ende = new DateTime(2026, 8, 7) });
                list.Add(new FerienDC() { Name = "Herbstferien 2026", Start = new DateTime(2026, 10, 5), Ende = new DateTime(2026, 10, 16) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2026", Start = new DateTime(2026, 12, 23), Ende = new DateTime(2027, 1, 8) });
            }
            else if (bundesland.ToLower() == "brandenburg")
            {
                list.Add(new FerienDC() { Name = "Winterferien 2025", Start = new DateTime(2025, 2, 3), Ende = new DateTime(2025, 2, 8) });
                list.Add(new FerienDC() { Name = "Osterferien 2025", Start = new DateTime(2025, 4, 14), Ende = new DateTime(2025, 4, 25) });
                list.Add(new FerienDC() { Name = "Sommerferien 2025", Start = new DateTime(2025, 7, 24), Ende = new DateTime(2025, 9, 6) });
                list.Add(new FerienDC() { Name = "Herbstferien 2025", Start = new DateTime(2025, 10, 20), Ende = new DateTime(2025, 11, 1) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2025", Start = new DateTime(2025, 12, 22), Ende = new DateTime(2026, 1, 2) });

                list.Add(new FerienDC() { Name = "Winterferien 2026", Start = new DateTime(2026, 2, 2), Ende = new DateTime(2026, 2, 7) });
                list.Add(new FerienDC() { Name = "Osterferien 2026", Start = new DateTime(2026, 3, 30), Ende = new DateTime(2026, 4, 10) });
                list.Add(new FerienDC() { Name = "Sommerferien 2026", Start = new DateTime(2026, 7, 9), Ende = new DateTime(2026, 8, 22) });
                list.Add(new FerienDC() { Name = "Herbstferien 2026", Start = new DateTime(2026, 10, 19), Ende = new DateTime(2026, 10, 30) });
                list.Add(new FerienDC() { Name = "Weihnachtsferien 2026", Start = new DateTime(2026, 12, 23), Ende = new DateTime(2027, 1, 2) });
            }
            return list;
        }

        

        private void SetLokaleFeiertagListe(int year)
        {
            _Feiertage = GetFeiertage(year);
        }

        public virtual List<long> GetVacationReasonIDs()
        {
            var res = new List<long>();
            var filters = new List<string> { "URLAUB" };
            var reasons = DAOFactory.GenericDAO.GetAll<AbsenceReason>();

            foreach (var reason in reasons)
            {
                var desc = reason.Description.ToUpper();

                foreach (var filter in filters)
                {
                    if (desc.Contains(filter))
                    {
                        res.Add(reason.Oid.Value);
                        break;
                    }
                }
            }

            return res;
        }

        public virtual DateTime GetExpirationDate(int year)
        {
            return new DateTime(year, 3, 31);
        }

        // Faktor bestimmt zu welchem Anteil der übergebene Tag als Feiertag gewertet wird. 1 = ganzer Feiertag, 0 = kein Feiertag.
        // Kann verwendet werden um z.B. halbe Feiertage zu definieren. Dann kann in abgeleiteter Klasse 0.5 zurückgegeben werden
        public virtual decimal GetFeiertagsFaktor(DateTime start)
        {
            if (IstFeiertag(start))
            {
                return 1;
            }
            return 0;
        }



        ////////////////////////////////////////////////////////////////////////////////////////////////////////
        ///////////////////////////////////////////////////////////
        ///////////////////////////////////////////////////////////
        ///////////// URLAUBSKONTO WAS MAN SIEHT///////////////////
        ///////////////////////////////////////////////////////////
        ///////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////
        // ------INHALTSVERZEICHNIS------ 
        // 1. Vetragliche Urlaubstage für´s Jahr
        // 2. Abzuziehende Tage wegen Vertragsbeginn mitten im Jahr
        // 3. Geschenkte Urlaubstage im Jahr
        // 4. Verfallener Resturlaub
        // 5. Alle Urlaube, die Anfang oder Ende im gewählten Jahr haben
        // 6. Anzahl der aus 1.-5. resultierenden Resturlaubstage fürs Jahr, also Resturlaub vom Urlaubskonto
        // 7. Liste der DCs nach Datum sortieren, um eine zeitliche Hierarchie zu schaffen

        public virtual List<UrlaubskontoDarstellungDC> BerechneUrlaubskontoZurDarstellung(EmployeeDC emp, int year, DateTime? endeDerBerechnung = null)
        {
            List<UrlaubskontoDarstellungDC> dcs = new List<UrlaubskontoDarstellungDC>();
            EmployeeServiceImp es = new EmployeeServiceImp();
            
            // Urlaubskonto erstellen
            var ent = DAOFactory.GenericDAO.LoadByID<Employee>((long)emp.EmployeeOid);
            var urlaubskonten = BerechneUrlaubskonto(ent, year);
            var aktuellesKonto = urlaubskonten.First(u => u.Key == year);

            var geschenkteUrlaubstage = es.GetGeschenkteUrlaubstageForEmployee((long)emp.EmployeeOid);
            decimal sonderurlaub = 0;


            // Benötigt werden:
            // 1. Vetragliche Urlaubstage für´s Jahr
            List<ContractDC> contracts = new List<ContractDC>();
            Dictionary<ContractDC, int> contractsAndWeeklyDays = new Dictionary<ContractDC, int>();

            // Vertrag für Jahr raussuchen
            foreach (var c in emp.Contracts) 
            {
                DateTime contractEndDate = new DateTime();
                if (c.ContractEndDate == null)
                    contractEndDate = new DateTime(2099, 12, 31);
                else
                    contractEndDate = c.ContractEndDate.Value;

                DateTime contractStartDate = new DateTime();
                if (c.EntryDate == null)
                    contractStartDate = new DateTime(year, 01, 01);
                else
                    contractStartDate = c.EntryDate.Value;

                if (year >= contractStartDate.Year && year <= contractEndDate.Year) // Wenn das ausgewählte Jahr zwischen Vertragsbeginn und -ende liegt
                {
                    contracts.Add(c);
                    contractsAndWeeklyDays.Add(c, c.WeeklyDays);
                }
            }
            if (contracts.Count == 0) // Kein Vertrag = kein Urlaubskonto
                return null;


            // 2. Abzuziehende Tage wegen Vertragsbeginn mitten im Jahr
            foreach (var contractAndWeeklyDays in contractsAndWeeklyDays)
            {
                var contract = contractAndWeeklyDays.Key;
                #region Vielleicht bald unnötig
                // Zahlen für Darstellung in View
                decimal tageNachAbzug = 0;
                decimal abzuziehendeTage = 0;

                int arbeitstage = contract.WeeklyDays; // Vertragliche Arbeitstage
                DateTime? endDate = contract.ContractEndDate == null ? new DateTime(year, 12, 31) : contract.ContractEndDate; // Ende des Vertrags auf letzten Tag des Jahres setzen, wenn kein Ende
                var leaveDays = contract.EmploymentType?.LeaveDays == null ? contract.LeaveDays : contract.EmploymentType.LeaveDays; // Vertragliche Urlaubstage
                if (!leaveDays.HasValue)
                {
                    leaveDays = 0;
                }
                if (contract.EntryDate.HasValue && (contract.EntryDate.Value.Year == year || endDate.Value.Year == year)) // Wenn Vertrag im gewählten Jahr beginnt oder endet
                {
                    if (contract.EntryDate.Value.Year == year) // Wenn Vertrag im gewählten Jahr beginnt
                    {
                        if (endDate >= new DateTime(contract.EntryDate.Value.Year, 12, 31))  // Wenn Vertrag länger gilt als das gewählte Jahr
                        {
                            int restlicheTageImJahr = Convert.ToInt32((new DateTime(contract.EntryDate.Value.Year, 12, 31) - contract.EntryDate.Value.Date).TotalDays);
                            tageNachAbzug = CalcCorrectNumberOfLeaveDaysForSpecialContractSituation((DateTime)contract.EntryDate, null, arbeitstage, restlicheTageImJahr, leaveDays);
                        }
                        else // Wenn Ende des Vertrags im gleichen Jahr vor Jahresende ist
                        {
                            int restlicheTageImJahr = Convert.ToInt32((contract.ContractEndDate.Value.Date - contract.EntryDate.Value.Date).TotalDays);
                            tageNachAbzug = CalcCorrectNumberOfLeaveDaysForSpecialContractSituation((DateTime)contract.EntryDate, contract.ContractEndDate.Value.Date, arbeitstage, restlicheTageImJahr, leaveDays);
                        }
                    }
                    else if (endDate.Value.Year == year) // Wenn Vertrag im gewählten Jahr endet
                    {
                        int restlicheTageImJahr = Convert.ToInt32(((DateTime)endDate - new DateTime(year, 1, 1)).TotalDays);
                        tageNachAbzug = CalcCorrectNumberOfLeaveDaysForSpecialContractSituation((DateTime)contract.EntryDate, endDate, arbeitstage, restlicheTageImJahr, leaveDays);
                    }
                    // Abzuziehende Tage = Vertragliche Urlaubstage - Tage, die nach Abzug der verfallenden Tage übrig bleiben
                    abzuziehendeTage = (decimal)leaveDays - tageNachAbzug;
                }
                #endregion
                if (contract == null || contract != null && !contract.EntryDate.HasValue)
                {
                    continue;
                }
                var contractStart = contract.EntryDate.Value.ToString().Split(' ');
                var contractEnd = contract.ContractEndDate != null ? contract.ContractEndDate.Value.ToString().Split(' ') : null;

                var anzahlTage = leaveDays - abzuziehendeTage;

                var obereZeile = new UrlaubskontoDarstellungDC()
                {
                    AnzahlTage = string.Format("{0:0.00}", anzahlTage),
                    Herkunft = string.Format("EmpOid:{0} ContractOid:{1}", emp.EmployeeOid, contract.ContractOid),
                    Tooltip = null,
                    IsDeletable = false,
                    DatumZurSortierung = null
                };
                obereZeile.Erlaeuterung = contractEnd == null ? "Urlaubstage laut Vertrag vom " + contractStart[0] + ":" : "Urlaubstage laut Vertrag vom " + contractStart[0] + " bis " + contractEnd[0] + ":";
                dcs.Add(obereZeile);

                // Standardmäßig Sonderurlaub bei Schwerbehinderung, aber modifizierbar
                List<UrlaubskontoDarstellungDC> sonderurlaubItems = CreateSonderurlaubItems(emp, contract, es.GetSonderurlaubForEmployee(emp.EmployeeOid.Value, year), dcs);
                //List<UrlaubskontoDarstellungDC> sonderurlaubItems = AddSonderurlaub(emp, contract, year);
                if (sonderurlaubItems.Count > 0)
                {
                    dcs.AddRange(sonderurlaubItems);
                    sonderurlaub += sonderurlaubItems.Sum(s => Convert.ToDecimal(s.AnzahlTage));
                }

                #region Würde Code von 2. sparen, klappt aber leider nur dann, wenn es nicht mehr als einen Vertrag im Jahr gibt
                //decimal anzGeschenkteTage = 0.0m;
                //if (geschenkteUrlaubstage != null)
                //{
                //    foreach (var item in geschenkteUrlaubstage)
                //    {
                //        if (item.Date.Year == year)
                //            anzGeschenkteTage += item.AnzahlTage;
                //    }
                //}
                //var testvar = aktuellesKonto.Value.Urlaubsanspruch - anzGeschenkteTage;
                //var obereZeile = new UrlaubskontoDarstellungDC()
                //{
                //    AnzahlTage = testvar,
                //    Herkunft = string.Format("EmpOid:{0} ContractOid:{1}", emp.EmployeeOid, contract.ContractOid),
                //    Tooltip = null,
                //    IsDeletable = false,
                //    DatumZurSortierung = null
                //};
                //obereZeile.Erlaeuterung = contractEnd == null ? "Urlaubstage laut Vertrag vom " + contractStart[0] + ":" : "Urlaubstage laut Vertrag vom " + contractStart[0] + " bis " + contractEnd[0] + ":";
                //dcs.Add(obereZeile);
                #endregion
            }

            // 3. Geschenkte Urlaubstage im Jahr
            if (geschenkteUrlaubstage.Count > 0 && geschenkteUrlaubstage.Any(g => g.Date.Year == year))
            {
                // Einen Eintrag pro geschenktem Urlaubstag
                foreach (var eintrag in geschenkteUrlaubstage)
                {
                    if (eintrag.Date.Year == year)
                    {
                        var tempDate = eintrag.Date.ToString().Split(' ');
                        dcs.Add(new UrlaubskontoDarstellungDC()
                        {
                            Erlaeuterung = string.Format("Tage geschenkt am {0} von {1} ({2})", tempDate[0], eintrag.InsUser, eintrag.GeschenkterUrlaubstagNotice),
                            AnzahlTage = eintrag.AnzahlTage > 0 ? string.Format("+{0:0.00}", eintrag.AnzahlTage) : string.Format("{0:0.00}", eintrag.AnzahlTage),
                            Herkunft = string.Format("GeschenkterUrlaubstagOid:{0}", eintrag.GeschenkterUrlaubstagOid),
                            Tooltip = eintrag.GeschenkterUrlaubstagNotice,
                            IsDeletable = true,
                            DatumZurSortierung = eintrag.Date
                        });
                    }
                }
            }

            // 4. Verfallener Resturlaub
            // Verfallsdatum der Urlaubstage des letzten Jahres zur Darstellung (also ohne Uhrzeit)
           

            // Resturlaub und den verbleibenden Resturlaub nach Verfall erstellen
            if (aktuellesKonto.Value.ResturlaubVorjahrTotal > 0) // Wenn Urlaub aus dem Vorjahr mitgenommen wurde
            {
                dcs.Add(new UrlaubskontoDarstellungDC()
                {
                    Erlaeuterung = "Resturlaub aus " + (year - 1) + " :",
                    AnzahlTage = string.Format("+{0:0.00}", aktuellesKonto.Value.ResturlaubVorjahrTotal),
                    Herkunft = string.Format("EmpOid:{0} Urlaubskonto:{1}", emp.EmployeeOid, year),
                    Tooltip = null,
                    IsDeletable = false
                });
            }
            else if (urlaubskonten.ContainsKey(year - 1) && urlaubskonten[year - 1].Resturlaub > 0)
            {
                var vorherigesKonto = urlaubskonten[year - 1];
                aktuellesKonto.Value.ResturlaubVorjahrTotal += vorherigesKonto.Resturlaub;
                aktuellesKonto.Value.ResturlaubVorjahr += vorherigesKonto.Resturlaub;

                dcs.Add(new UrlaubskontoDarstellungDC()
                {
                    Erlaeuterung = "Resturlaub aus " + (year - 1) + " :",
                    AnzahlTage = string.Format("+{0:0.00}", aktuellesKonto.Value.ResturlaubVorjahrTotal),
                    Herkunft = string.Format("EmpOid:{0} Urlaubskonto:{1}", emp.EmployeeOid, year),
                    Tooltip = null,
                    IsDeletable = false
                });
            }
            var expDate = GetExpirationDate(year);
            if (expDate != null)
            {
                var expDateString = GetExpirationDate(year).ToString().Split(' ');
               
                if (aktuellesKonto.Value.VerfallenerUrlaub > 0) // Wenn Urlaubstage verfallen sind
                {
                    dcs.Add(new UrlaubskontoDarstellungDC()
                    {
                        Erlaeuterung = string.Format("Urlaub am {0} verfallen: ", expDateString[0]),
                        AnzahlTage = string.Format("-{0:0.00}", aktuellesKonto.Value.VerfallenerUrlaub),
                        DatumZurSortierung = GetExpirationDate(year),
                        Tooltip = null,
                        IsDeletable = false
                    });
                }
            }
          


            // 5. Alle Urlaube, die Anfang oder Ende im gewählten Jahr haben
            var absReason = GetVacationReasonIDs();
            var absences = emp.AbsenceTimes.Where(x => absReason.Contains(x.Reason.AbsenceReasonOid.Value) && (x.Start.HasValue && x.Start.Value.Year == year)
                                                    || absReason.Contains(x.Reason.AbsenceReasonOid.Value) && (x.End.HasValue && x.End.Value.Year == year))
                            .OrderBy(x => x.Start).ToList();

            if (absences.Count > 0) // Wenn es Urlaube in dem Jahr gibt
            {
                // Urlaube durchgehen und die Tage zählen
                foreach (var spanne in absences)
                {
                    // Im Stundenkonto wird auch Resturlaub angezeigt. Geht eine Abwesenheit über das Ende des Stundenkontomonats hinaus,
                    // Abwesenheit auf endeDerBerechnung setzen, damit Urlaubstage vom nachfolgenden Monat nicht zu früh abgezogen werden
                    if (endeDerBerechnung.HasValue && spanne.End.HasValue && spanne.End.Value > endeDerBerechnung.Value)
                        spanne.End = endeDerBerechnung;
                    if (spanne.End.HasValue && spanne.End.Value.Year > year)
                        spanne.End = new DateTime(year, 12, 31);
                    if (spanne.Start.HasValue && spanne.Start.Value.Year < year)
                        spanne.Start = new DateTime(year, 01, 01);

                    decimal summeTage = 0;

                    #region Urlaubstage zählen 
                    if (emp.Arbeitszeiten != null && emp.Arbeitszeiten.Count > 0)
                    {
                        foreach (var az in emp.Arbeitszeiten)
                        {
                            if (az.GueltigVon.HasValue)
                            {
                                var azEnde = !az.GueltigBis.HasValue ? new DateTime(year, 12, 31) : az.GueltigBis.Value;
                                if (new DateTimeSpan(az.GueltigVon.Value, azEnde).ContainsDate(spanne.AbsenceSpan.StartDate) && az.Eintraege != null && az.Eintraege.Count > 0)
                                {
                                    summeTage = CountUrlaubstageArbeitszeiten(spanne, year, az);
                                    break;
                                }
                                else
                                    summeTage = CountUrlaubstageStandard(spanne, year, contractsAndWeeklyDays);
                            }
                            else
                                summeTage = CountUrlaubstageStandard(spanne, year, contractsAndWeeklyDays);
                        }
                    }
                    else
                        summeTage = CountUrlaubstageStandard(spanne, year, contractsAndWeeklyDays);

                    
                    #endregion

                    // Start- und Enddatum des Urlaubs für Darstellung vorbereiten
                    var startAsArray = spanne.Start.Value.ToString().Split(' ');
                    var endAsArray = spanne.End.Value.ToString().Split(' ');
                    // Eintrag für Urlaubstag setzen (Erläuterung abhängig davon, ob Urlaub nur ein Tag geht oder über mehrere
                    dcs.Add(new UrlaubskontoDarstellungDC()
                    {
                        Erlaeuterung = startAsArray[0] == endAsArray[0] ? string.Format("Urlaub genommen am {0}", startAsArray[0]) :
                                                                            string.Format("Urlaub genommen vom {0} bis {1}", startAsArray[0], endAsArray[0]),
                        AnzahlTage = string.Format("-{0:0.00}", summeTage),
                        AnzahlTageUrlaub = summeTage,
                        Herkunft = string.Format("AbsenceOid: {0}", spanne.AbsenceTimeOid),
                        Tooltip = spanne.Notice,
                        IsDeletable = false,
                        DatumZurSortierung = spanne.Start.Value
                    });
                }
            }

            // 6. Anzahl der aus 1.-5. resultierenden Resturlaubstage fürs Jahr, also Resturlaub vom Urlaubskonto
            var anzTage = aktuellesKonto.Value.ResturlaubVorjahrTotal > 0 && aktuellesKonto.Value.VerfallenerUrlaub <= 0 ? aktuellesKonto.Value.Resturlaub + aktuellesKonto.Value.ResturlaubVorjahr + sonderurlaub : aktuellesKonto.Value.Resturlaub + sonderurlaub;
            dcs.Add(new UrlaubskontoDarstellungDC()
            {
                AnzahlTage = string.Format("{0:0.00}", anzTage),
                Erlaeuterung = "Summe der verbleibenden Urlaubstage: ",
                Herkunft = "UrlaubskontoEmpOid" + aktuellesKonto.Value.EmployeeOid,
                Tooltip = null,
                IsDeletable = false,
                DatumZurSortierung = new DateTime(2999, 12, 31)
            });

            // 7. Liste der DCs nach Datum sortieren, um eine zeitliche Hierarchie zu schaffen
            var sortierteDCs = dcs.OrderBy(dc => dc.DatumZurSortierung).ToList();

            return sortierteDCs;
        }

        public virtual List<UrlaubskontoDarstellungDC> CreateSonderurlaubItems(EmployeeDC emp, ContractDC contract, Dictionary<string, decimal> sonderurlaubDict, List<UrlaubskontoDarstellungDC> darstellungList)
        {
            List<UrlaubskontoDarstellungDC> sonderurlaubItems = new List<UrlaubskontoDarstellungDC>();

            // Standardmäßig ist nur ein Eintrag drin, nämlich Sonderurlaub bei Schwerbeinderung (5 Tage), kann aber ergänzt werden (hier oder EmployeeServiceImp)
            foreach (var item in sonderurlaubDict)
            {
                var sonderurlaub = new UrlaubskontoDarstellungDC()
                {
                    AnzahlTage = string.Format("{0:0.00}", 5), // Standardmäßig 5 Tage
                    Herkunft = string.Format("EmpOid:{0} ContractOid:{1}", emp.EmployeeOid, contract.ContractOid),
                    Tooltip = "",
                    IsDeletable = false,
                    DatumZurSortierung = null,
                    Erlaeuterung = item.Key
                };
                sonderurlaubItems.Add(sonderurlaub);
            }

            return sonderurlaubItems;
        }

        public virtual List<UrlaubskontoDarstellungDC> AddSonderurlaub(EmployeeDC emp, ContractDC contract, int year)
        {
            List<UrlaubskontoDarstellungDC> sonderurlaub = new List<UrlaubskontoDarstellungDC>();

            // Wenn eine Behinderung von mind. 50 vorliegt stehen standardmäßig 5 Sonderurlaubstage zu
            if (emp.AusweisGueltigVon.HasValue && emp.AusweisGueltigVon.Value.Year >= contract.EntryDate.Value.Year && emp.AusweisGueltigVon.Value.Year <= emp.AusweisGueltigVon.Value.Year ||
                emp.AusweisGueltigBis.HasValue && emp.AusweisGueltigBis.Value.Year >= contract.EntryDate.Value.Year && emp.AusweisGueltigBis.Value.Year <= emp.AusweisGueltigBis.Value.Year)
            {
                if (emp.GradDerBehinderung.IsNotNullOrEmpty())
                {
                    int.TryParse(emp.GradDerBehinderung, out int grad);
                    if (grad >= 50)
                    {
                        var sonderurlaubBeiSchwerbehinderung = new UrlaubskontoDarstellungDC()
                        {
                            AnzahlTage = string.Format("{0:0.00}", 5), // Standardmäßig 5 Tage
                            Herkunft = string.Format("EmpOid:{0} ContractOid:{1}", emp.EmployeeOid, contract.ContractOid),
                            Tooltip = "Sonderurlaub durch Grad der Behinderung über 50 (" + emp.GradDerBehinderung + ")",
                            IsDeletable = false,
                            DatumZurSortierung = null,
                            Erlaeuterung = "Sonderurlaub durch Schwerbehinderung"
                        };
                        sonderurlaub.Add(sonderurlaubBeiSchwerbehinderung);
                    }
                }
            }

            return sonderurlaub;
        }

        public decimal CountUrlaubstageStandard(AbsenceTimeDC spanne, int year, Dictionary<ContractDC, int> contractsAndWeeklyDays)
        {
            var summeTage = 0m; 
            if (spanne.End == null) // Wenn es kein Ende gibt, Ende auf letzten Tag im Jahr setzen
                spanne.End = new DateTime(year, 12, 31);

            if (spanne.Start.Value.Date == spanne.End.Value.Date && spanne.Start.Value.TimeOfDay == spanne.End.Value.TimeOfDay) // ein ganzer Tag Urlaub
            {
                var ff = GetFeiertagsFaktor(spanne.Start.Value);
                summeTage += (1 - ff);
            }
            else if (spanne.Start.Value.Date == spanne.End.Value.Date && spanne.Start.Value.TimeOfDay != spanne.End.Value.TimeOfDay) // ein halber Tag Urlaub
                summeTage += 0.5m;
            else // Mehr als ein Tag Urlaub
            {
                DateTime startForLoop = (spanne.Start.Value.Year == year) ? spanne.Start.Value : new DateTime(year, 1, 1);

                // Tage auf den Zähler addieren, solange das sich erhöhende Datum vor dem Enddatum ist und wenn das Datum kein Wochenend- oder Feiertag ist

                #region neu
                // Variable wird für jeden Tag hochgezählt und resettet, sobald wieder Montag ist. So kann vermieden werden, dass bei einer Arbeitswoche von unter 5 Tagen trotzdem 5 Tage Urlab abgezogen werden
                var tageInDerWoche = 0;
                #endregion
                while (startForLoop <= spanne.End.Value)
                {
                    if (startForLoop.DayOfWeek == DayOfWeek.Monday)
                        tageInDerWoche = 0;

                    var currentContract = contractsAndWeeklyDays.FirstOrDefault(c => startForLoop >= c.Key.EntryDate && startForLoop <= c.Key.ContractEndDate || startForLoop >= c.Key.EntryDate && c.Key.ContractEndDate == null);
                    if (currentContract.Key == null)
                    {
                        if (startForLoop.DayOfWeek != DayOfWeek.Saturday && startForLoop.DayOfWeek != DayOfWeek.Sunday)
                        {
                            var ff = GetFeiertagsFaktor(startForLoop);
                            summeTage += (1 - ff);
                        }
                    }
                    else
                    {
                        if (!CheckIstWochenende(currentContract.Value, startForLoop.DayOfWeek) && tageInDerWoche < currentContract.Value)
                        {
                            var ff = GetFeiertagsFaktor(startForLoop);
                            summeTage += (1 - ff);
                            tageInDerWoche++;
                        }
                        
                    }


                    startForLoop = startForLoop.AddDays(1);
                }
            }

            return summeTage;
        }
        public decimal CountUrlaubstageArbeitszeiten(AbsenceTimeDC spanne, int year, ArbeitszeitDC az)
        {
            //var feiertage = GetFeiertage(year);
            var feiertage = GetFeiertage(year, Bundesland);

            var summeTage = 0m;
            if (spanne.End == null) // Wenn es kein Ende gibt, Ende auf letzten Tag im Jahr setzen
                spanne.End = new DateTime(year, 12, 31);

            if (spanne.Start.Value.Date == spanne.End.Value.Date && spanne.Start.Value.TimeOfDay == spanne.End.Value.TimeOfDay && 
                az.Eintraege.Any(e => e.DayOfWeek == spanne.Start.Value.DayOfWeek)) // ein ganzer Tag Urlaub
            {
                if (!feiertage.Any(f => f.Datum == spanne.Start.Value.Date))
                    summeTage++;
                else
                    summeTage += (1 - GetFeiertagsFaktor(spanne.Start.Value));
            }
            else if (spanne.Start.Value.Date == spanne.End.Value.Date && spanne.Start.Value.TimeOfDay != spanne.End.Value.TimeOfDay && 
                az.Eintraege.Any(e => e.DayOfWeek == spanne.Start.Value.DayOfWeek) && !feiertage.Any(f => f.Datum == spanne.Start.Value.Date)) // ein halber Tag Urlaub
                summeTage += 0.5m;
            else // Mehr als ein Tag Urlaub
            {
                DateTime startForLoop = (spanne.Start.Value.Year == year) ? spanne.Start.Value : new DateTime(year, 1, 1);

                // Tage auf den Zähler addieren, solange das sich erhöhende Datum vor dem Enddatum ist und wenn das Datum kein Wochenend- oder Feiertag ist

                #region neu
                // Variable wird für jeden Tag hochgezählt und resettet, sobald wieder Montag ist. So kann vermieden werden, dass bei einer Arbeitswoche von unter 5 Tagen trotzdem 5 Tage Urlab abgezogen werden
                var tageInDerWoche = 0;
                #endregion
                while (startForLoop <= spanne.End.Value)
                {
                    if (az.Eintraege.Any(e => e.DayOfWeek == startForLoop.DayOfWeek))
                    {
                        if (!feiertage.Any(f => f.Datum == startForLoop.Date) && GetFeiertagsFaktor(startForLoop.Date) == 0)
                            summeTage++;
                        else
                            summeTage += (1 - GetFeiertagsFaktor(startForLoop.Date));
                    }

                    if (startForLoop.DayOfWeek == DayOfWeek.Monday)
                        tageInDerWoche = 0;                 


                    startForLoop = startForLoop.AddDays(1);
                }
            }

            return summeTage;
        }

        ///////////////////////////////////////////////////////////
        ///////////////////////////////////////////////////////////
        ///////////////////////////////////////////////////////////
        ///////////////////////////////////////////////////////////
        ///////////// URLAUBSKONTO IM HINTERGRUND /////////////////
        ///////////////////////////////////////////////////////////
        ///////////////////////////////////////////////////////////
        ///////////////////////////////////////////////////////////
        ///////////////////////////////////////////////////////////
        public virtual Dictionary<int, UrlaubskontoDC> BerechneUrlaubskonto(Employee emp, int year)
        {
            try
            {
                SetLokaleFeiertagListe(year);

                // Alle Abwesenheiten bis zu dem Jahr raussuchen, für das man das Urlaubskonto berechnen will
                var absReason = GetVacationReasonIDs();
                var absences = emp.AbsenceTimes.Where(x => absReason.Contains(x.AbsenceReason.Oid.Value) &&
                                                        (x.Start.HasValue && x.Start.Value.Year <= year))
                                               //(!x.End.HasValue || x.End.Value.Year >= year)
                                               .OrderBy(x => x.Start);

                var empService = new EmployeeServiceImp();

                // Startzeitpunkt für Berechnung berechnen
                var firstContractYear = emp.Contracts?.Min(x => x.EntryDate)?.Year ?? int.MaxValue; // Den Vetrag raussuchen, der am frühesten beginnt
                var firstAbsenceTimeYear = absences.Min(x => x.Start)?.Year ?? int.MaxValue; // Jahr der ersten Abwesenheit
                var firstYear = Math.Min(year, Math.Min(firstContractYear, firstAbsenceTimeYear)); // Erstes, für´s Urlaubskonto relevante Jahr

                // Urlaubskonten erzeugen, eins für jedes Jahr ab dem ersten bis zum ausgewählten Jahr
                var konten = new Dictionary<int, UrlaubskontoDC>();
                for (int i = firstYear; i <= year; i++)
                {
                    konten.Add(i, new UrlaubskontoDC());
                }

                int? workdays = 0;
                List<ArbeitszeitDC> arbeitszeiten = new List<ArbeitszeitDC>();
                Dictionary<ContractDC, int> contractsAndWeeklyDays = new Dictionary<ContractDC, int>();

                // Jahresurlaubanspruch berechnen (noch kein Resturlaub Vorjahr in dieser Schleife, nur Jahresanspruch + Sonderfall Vertragsstart oder -ende mitten im Jahr)
                foreach (var contract in emp.Contracts)
                {
                    contractsAndWeeklyDays.Add(MapperFactory.ContractDC_Contract.MapToNewDC(contract), contract.WeeklyDays.HasValue ? contract.WeeklyDays.Value : 0);

                    var start = contract.EntryDate?.Year ?? firstYear;
                    var end = contract.ContractEndDate?.Year ?? year;

                    if (emp.Arbeitszeiten != null && emp.Arbeitszeiten.Count > 0)
                        arbeitszeiten = MapperFactory.ArbeitszeitDC_Arbeitszeit.MapToNewDCs(emp.Arbeitszeiten);

                    if (year >= start && year <= end)
                        workdays = contract.WeeklyDays;
                    // Durch jedes Jahr des Vertrags gehen und vertr. Urlaubsanspruch setzen. Noch keine Abwesenheiten/ResturlaubVorjahr, nur Urlaubsanspruch
                    for (int i = start; i <= end; i++)
                    { 
                        if (konten.ContainsKey(i))
                        {
                            // Konto für aktuelles Jahr in Schleife auswählen
                            var tmp = konten[i];
                            
                            if (contract.EmploymentType?.LeaveDays != null)
                                contract.LeaveDays = contract.EmploymentType.LeaveDays;
                            
                            //Hier wird nun der Urlaubsanspruch für ein Jahr errechnet, in dem der Vertrag beginnt oder aufhört. (Siehe CalcCorrectNumberOfLeaveDaysForSpecialContractSituation())

                            var urlaubsanspruchFuerVertragInLoop = contract.LeaveDays ?? 0;

                            int arbeitstage = contract.WeeklyDays != null ? (int)contract.WeeklyDays : 0;
                            DateTime? endDate = contract.ContractEndDate == null ? new DateTime(year, 12, 31) : contract.ContractEndDate;

                            if (contract != null && contract.EntryDate != null)
                            {
                                if (contract.EntryDate.Value.Year == i || endDate.Value.Year == i) // Endet oder beginnt Vertrag in gewähltem Jahr // HIER IST DAS PROBLEM
                                {
                                    decimal errechneteTage = 0;
                                    decimal weggefallen = 0;
                                    if (contract.EntryDate.Value.Year == i)
                                    {
                                        if (endDate >= new DateTime(contract.EntryDate.Value.Year, 12, 31))
                                        {
                                            int restlicheTageImJahr = Convert.ToInt32((new DateTime(contract.EntryDate.Value.Year, 12, 31) - contract.EntryDate.Value.Date).TotalDays);
                                            errechneteTage = CalcCorrectNumberOfLeaveDaysForSpecialContractSituation((DateTime)contract.EntryDate, null, arbeitstage, restlicheTageImJahr, urlaubsanspruchFuerVertragInLoop);
                                        }
                                        else // Wenn Ende des Vertrags im gleichen Jahr vor Ende des Jahres ist
                                        {
                                            int restlicheTageImJahr = Convert.ToInt32((contract.ContractEndDate.Value.Date - contract.EntryDate.Value.Date).TotalDays);
                                            errechneteTage += CalcCorrectNumberOfLeaveDaysForSpecialContractSituation((DateTime)contract.EntryDate, contract.ContractEndDate.Value.Date, arbeitstage, restlicheTageImJahr, urlaubsanspruchFuerVertragInLoop);
                                        }
                                    }
                                    else if (endDate.Value.Year == i)
                                    {
                                        int restlicheTageImJahr = Convert.ToInt32(((DateTime)endDate - new DateTime(i, 1, 1)).TotalDays);
                                        errechneteTage += CalcCorrectNumberOfLeaveDaysForSpecialContractSituation((DateTime)contract.EntryDate, endDate, arbeitstage, restlicheTageImJahr, urlaubsanspruchFuerVertragInLoop);
                                    }

                                    // Resturlaub und Urlaubsanspruch auf errechnete Werte setzen
                                    weggefallen = urlaubsanspruchFuerVertragInLoop - errechneteTage;
                                    tmp.Resturlaub += errechneteTage;
                                    tmp.Urlaubsanspruch += urlaubsanspruchFuerVertragInLoop - weggefallen;
                                }
                                else
                                {
                                    tmp.Urlaubsanspruch += urlaubsanspruchFuerVertragInLoop;
                                    tmp.Resturlaub = tmp.Urlaubsanspruch;
                                }
                            }
                            
                        }
                    }
                }

                // Abwesenheiten in Jahr x zu einem Dictionary hinzufügen, noch kein Abzug vom Konto
                var absencesYear = new List<Tuple<int, AbsenceTime>>();
                foreach (var abs in absences)
                {
                    var till = Math.Min(abs.End?.Year ?? year, year);
                    for (int i = abs.Start.Value.Year; i <= till; i++)
                    {
                        absencesYear.Add(new Tuple<int, AbsenceTime>(i, abs));
                    }
                }

                // Urlaubsanspruch berechnen
                var berechnungsjahr = firstYear;
                absencesYear = absencesYear.OrderBy(x => x.Item1).ToList();

                Dictionary<int, decimal> zuVerfallZuAddieren = new Dictionary<int, decimal>();
                var geschenkteUrlaubstage = empService.GetGeschenkteUrlaubstageForEmployee((long)emp.Oid);

                // Alle Abwesenheiten durchlaufen, deren Dauer berechnen und vom Resturlaub + Geschenkte Tage Vorjahr abziehen, sofern es nicht nutzbaren Resturlaub vom Vorjahr gibt
                // Tuple = Key-Value-Paar
                foreach (var tuple in absencesYear)
                {

                    var absYear = tuple.Item1;
                    var absence = tuple.Item2;
                    if(absYear == 2026)
                    { }
                    _Feiertage = GetFeiertage(absYear);

                    // Resturlaub aus Vorjahr übertragen
                    while (berechnungsjahr < absYear)
                    {
                        var geschenkteTageFuerAbrechnungsjahr = geschenkteUrlaubstage.Where(g => g.Date.Year == berechnungsjahr).ToList();
                        var sonderurlaubFuerAbrechnungsjahr = empService.GetSonderurlaubForEmployee((long)emp.Oid, berechnungsjahr);


                        var tmp = konten[berechnungsjahr]; 
                        var tmp2 = konten[berechnungsjahr + 1]; 

                        tmp2.ResturlaubVorjahrTotal = tmp.Resturlaub + geschenkteTageFuerAbrechnungsjahr.Sum(g => g.AnzahlTage) + sonderurlaubFuerAbrechnungsjahr.Sum(s => s.Value);
                        tmp2.ResturlaubVorjahr = tmp.Resturlaub + geschenkteTageFuerAbrechnungsjahr.Sum(g => g.AnzahlTage) + sonderurlaubFuerAbrechnungsjahr.Sum(s => s.Value);

                        berechnungsjahr++;
                    }

                    var current = konten[absYear];
                    if (absYear == 2025)
                    {

                    }

                    // Start und Ende auf Jahresanfang/-ende setzen, wenn Start des Urlaubs im Vorjahr oder Ende des Urlaubs im nächsten Jahr liegt
                    var start = DateTimeExtensions.GetMax(absence.Start, new DateTime(absYear, 1, 1));
                    var end = DateTimeExtensions.GetMin(absence.End, new DateTime(absYear, 12, 31));

                    // Dauer des Urlaubs unter Berücksichtigung von Wochenend- und Feiertagen berechnen

                    // Berücksichtigung von Arbeitszeiten
                    decimal dauer = 0;

                    var spanne = MapperFactory.AbsenceTimeDC_AbsenceTime.MapToNewDC(absence);
                    if (spanne.End.HasValue && spanne.End.Value.Year > absYear)
                        spanne.End = new DateTime(absYear, 12, 31);
                    if (spanne.Start.HasValue && spanne.Start.Value.Year < absYear)
                        spanne.Start = new DateTime(absYear, 01, 01);

                    if (arbeitszeiten.Count > 0)
                    {
                        foreach (var az in arbeitszeiten)
                        {
                            if (az.Eintraege.Count > 0 && az.GueltigVon.HasValue)
                            {
                                var azEnde = !az.GueltigBis.HasValue ? new DateTime(year, 12, 31) : az.GueltigBis.Value;
                                if (new DateTimeSpan(az.GueltigVon.Value, azEnde).ContainsDate(spanne.AbsenceSpan.StartDate) && az.Eintraege != null && az.Eintraege.Count > 0)
                                {
                                    dauer = CountUrlaubstageArbeitszeiten(spanne, absYear, az);
                                    break;
                                }
                                else
                                    dauer = CountUrlaubstageStandard(spanne, absYear, contractsAndWeeklyDays);
                            }
                            else
                                dauer = CountUrlaubstageStandard(spanne, absYear, contractsAndWeeklyDays);
                        }
                    }
                    else
                        dauer = CountUrlaubstageStandard(spanne, absYear, contractsAndWeeklyDays);
                    //dauer = BerechneAnzahlUrlaubstage(absence, null, absYear, workdays); // HIER MÜSSEN PARAMETER FÜR ISTWOCHENENDE() MITGEGEBEN WERDEN 

                    // Verfallsdatum des Urlaubs festlegen
                    var expiration = GetExpirationDate(absYear);
                    current.UrlaubsVerfallsdatum = expiration;

                    // Resturlaub vom Vorjahr verwenden, wenn Resturlaub aus dem Vorjahr existiert und der Urlaub vor dem Verfallsdatum beginnt
                    if (expiration != null && current.ResturlaubVorjahr > 0 && start <= expiration || expiration == null && current.ResturlaubVorjahr > 0)
                    {
                        var firstEnd = GetFirstEnd(end, expiration); // Ende von Urlaub oder Verfallsdatum, je nachdem was früher ist

                        var dauerVorjahr = 0m; 
                        DateTime zaehlerDatum = (DateTime)start;

                        // Urlaubstagzähler erhöhen, wenn aktueller Tag der Schleife weder ein Wochenend- noch ein Feiertag ist
                        // Wenn nur ein Arbeitstag pro Woche im Vertrag ist, wird das nicht berücksichtigt.. EINBAUEN
                        

                        var tageInDerWoche = 0;
                        while (zaehlerDatum <= firstEnd)
                        {
                            if (zaehlerDatum.DayOfWeek == DayOfWeek.Monday)
                                tageInDerWoche = 0;

                            bool istWochenende = CheckIstWochenende(workdays, zaehlerDatum.DayOfWeek);
                            bool istInArbeitszeiten = CheckIstInArbeitszeiten(arbeitszeiten, zaehlerDatum);
                            if (istInArbeitszeiten && !istWochenende && !_Feiertage.Contains(zaehlerDatum) && tageInDerWoche < workdays)
                            {
                                if (zaehlerDatum.Date == firstEnd.Date && zaehlerDatum.TimeOfDay != firstEnd.TimeOfDay)
                                    dauerVorjahr += 0.5m;
                                else
                                    dauerVorjahr++;

                                tageInDerWoche++;
                            }

                            zaehlerDatum = zaehlerDatum.AddDays(1);
                        }


                        var bucheVorjahr = Math.Min(current.ResturlaubVorjahr, dauerVorjahr);

                        // Urlaub, der mit Resturlaub Vorjahr abgedeckt werden kann, von diesem abziehen
                        current.ResturlaubVorjahr -= bucheVorjahr;
                        // Die Anzahl der Tage, die der Urlaub geht, um die Anzahl Tage reduzieren, die vom Resturlaub genommen werden kann, da "dauer" vom Urlaubskontingent abgezogen wird
                        dauer -= bucheVorjahr;
                        if (dauer < 0)
                        {
                            if (!zuVerfallZuAddieren.ContainsKey(absYear))
                                zuVerfallZuAddieren.Add(absYear, 0);
                           
                            zuVerfallZuAddieren[absYear] -= dauer;
                        }
                    }
                    else if (expiration != null && start > expiration) // Wenn der Urlaub nach dem Verfallsdatum beginnt, ist der verfallene Urlaub gleich dem Urlaub, der aus dem Vorjahr übrig ist
                    {
                        current.VerfallenerUrlaub = zuVerfallZuAddieren.ContainsKey(absYear) ? current.ResturlaubVorjahr + zuVerfallZuAddieren[absYear] : current.ResturlaubVorjahr;
                    }

                    // Restliche Dauer vom Urlaub abziehen
                    current.Resturlaub -= dauer < 0 ? 0 : dauer; // ausprobieren
                }

                // Als letztes geschenkte Urlaubstage draufrechnen auf aktuelles Jahr
                foreach (var konto in konten)
                {
                    var i = konto.Key;

                    // Wenn es geschenkte Tage gibt, Liste durchlaufen und für jeden Eintrag den Zähler entsprechend der Tage erhöhen
                    if (geschenkteUrlaubstage != null)
                    {
                        // Zähler für die Anzahl der geschenkten Tage für das ganze Jahr (i)
                        decimal anzGeschenkteTage = 0.0m;

                        foreach (var item in geschenkteUrlaubstage)
                        {
                            if (item.Date.Year == i)
                                anzGeschenkteTage += item.AnzahlTage;
                        }
                        // Geschenkte Tage auf Anspruch und Resturlaub addieren
                        konto.Value.Urlaubsanspruch += anzGeschenkteTage;
                        konto.Value.Resturlaub += anzGeschenkteTage;
                    }
                }
                

                return konten;
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        public virtual DateTime GetFirstEnd(DateTime? end, DateTime expiration)
        {
            return (DateTime)DateTimeExtensions.GetMin(end, expiration);
        }

        public bool CheckIstWochenende(int? workdays, DayOfWeek tag)
        {
            bool istWochenende = tag == DayOfWeek.Saturday || tag == DayOfWeek.Sunday;

            if (workdays == 6)
                istWochenende = tag == DayOfWeek.Sunday;
            else if (workdays > 6)
                istWochenende = false;

            return istWochenende;
        }
        public bool CheckIstInArbeitszeiten(List<ArbeitszeitDC> arbeitszeiten, DateTime day)
        {
            if (arbeitszeiten == null || arbeitszeiten.Count == 0 || (arbeitszeiten != null && !arbeitszeiten.Any(a => a.Eintraege.Count > 0)))
                return true;
            
            bool istInArbeitszeiten = false;
            foreach (var az in arbeitszeiten)
            {
                if (az.GueltigVon.HasValue && day >= az.GueltigVon.Value && az.GueltigBis.HasValue && day <= az.GueltigBis ||
                    az.GueltigVon.HasValue && day >= az.GueltigVon.Value && !az.GueltigBis.HasValue)
                {
                    if (az.Eintraege.Any(e => e.DayOfWeek == day.DayOfWeek))
                        istInArbeitszeiten = true;
                }
            }
            if (istInArbeitszeiten && !arbeitszeiten.Any(a => a.Eintraege.Count > 0))
                istInArbeitszeiten = true;

            return istInArbeitszeiten;
        }
        internal decimal BerechneAnzahlUrlaubstageMitWeeklyDays(AbsenceTimeDC absenceDC, int year, int weeklyDays)
        {
            decimal tage = 0;

            if (absenceDC.Start.HasValue)
            {
                DateTime start = (absenceDC.Start.Value.Year == year) ? absenceDC.Start.Value : new DateTime(year, 1, 1);
                DateTime end = start;
                DateTime maxend = new DateTime(year, 12, 31);

                if (absenceDC.End.HasValue)
                {
                    end = absenceDC.End.Value;
                }
                if (maxend < end)
                {
                    end = maxend;
                }

                decimal tageInEinerWoche = 0; // Tage für die Ist- und Sollstunden
                int wochentageVergangen = 0; // Vergangene Wochentage
                while (start <= end)
                {
                    // Wenn Wochentag Montag ist, werden Tage einer Woche resetted und die vergangenen Arbeitstage 
                    var wochentag = start.DayOfWeek;
                    if (wochentag == DayOfWeek.Monday)
                    {
                        tageInEinerWoche = 0;
                        wochentageVergangen = 0;
                    }

                    if (!IstFeiertag(start))
                    {
                        if (wochentageVergangen < weeklyDays)
                        {
                            // Wenn nur ein halber Tag, dann..
                            if (start.Date == end.Date && start.TimeOfDay != end.TimeOfDay)
                            {
                                tageInEinerWoche += 0.5m;
                                if (tageInEinerWoche >= weeklyDays)
                                    tage += tageInEinerWoche > weeklyDays ? 0 - tage + weeklyDays : 0.5m;
                                else
                                    tage += 0.5m;
                            }
                            else
                            {
                                tageInEinerWoche++;
                                if (tageInEinerWoche >= weeklyDays)
                                    tage += tageInEinerWoche > weeklyDays ? 0 - tage + weeklyDays : 1;
                                else
                                    tage++;
                            }
                        }
                        wochentageVergangen++;
                    }

                    start = start.AddDays(1);
                }
            }

            return tage;
        }

        // Methode zur Berechnung der Urlaubstage, wenn Vertrag mitten im Jahr beginnt oder endet. 
        // BSP: 30 Urlaubstage, Beginn am 01.06.; Dann entfallen eine bestimmte Anzahl an Tagen, das wird hier berechnet
        public virtual decimal CalcCorrectNumberOfLeaveDaysForSpecialContractSituation(DateTime entryDate, DateTime? endDate, int anzahlArbeitstage, int restlicheTageImJahr, decimal? urlaubstageProJahr)
        {
            decimal urlaubstage = 0;
            if (urlaubstageProJahr == null)
                urlaubstageProJahr = 0m;

            if (entryDate.Day == 1 && entryDate.Month == 1 || entryDate.Day == 2 && entryDate.Month == 1) //Erster Tag im Jahr
            {
                //Prüfen, ob Enddatum Ende des Jahres oder früher ist
                if (endDate == null || (endDate.HasValue && endDate.Value.Day == 31 && endDate.Value.Month == 12))
                    urlaubstage = (decimal)urlaubstageProJahr;
                else
                    urlaubstage = (decimal)urlaubstageProJahr / 365m * restlicheTageImJahr;
            }
            else
            {
                urlaubstage = (decimal)urlaubstageProJahr / 365m * restlicheTageImJahr;
            }

            // Runden
            urlaubstage = UrlaubstageRunden(urlaubstage);

            return urlaubstage;

            #region Alte Version, die immer wieder zu Problemen führte. Sollte es mit der neuen mehr Probleme geben, dann das wieder rein und das obere raus.
            //decimal urlaubstage = 0;
            //if (urlaubstageProJahr == null)
            //    urlaubstageProJahr = 0m;

            //if (entryDate.Day == 1 && entryDate.Month == 1 || entryDate.Day == 2 && entryDate.Month == 1) //Erster Tag im Jahr
            //{
            //    //Prüfen, ob Enddatum Ende des Jahres oder früher ist
            //    if (endDate == null)
            //        urlaubstage = (decimal)urlaubstageProJahr;

            //    else if (endDate.Value.Day == 31 && endDate.Value.Month == 12)
            //        urlaubstage = (decimal)urlaubstageProJahr;

            //    else
            //    {
            //        if (anzahlArbeitstage < 5) // weniger als 5 Tage (Urlaubsanspruch / 12 Monate * Monate Arbeit) / 5 * Wochenarbeitstage
            //            urlaubstage = (decimal)urlaubstageProJahr / 12 * (Convert.ToDecimal((endDate.Value - entryDate).TotalDays) / 30) / 5m * anzahlArbeitstage;
            //            //urlaubstage = (decimal)urlaubstageProJahr / 5m * anzahlArbeitstage;
            //        else
            //        {
            //            if (anzahlArbeitstage == 5 || anzahlArbeitstage == 6 || anzahlArbeitstage == 7) // 5 oder 6 Tage
            //                urlaubstage = (decimal)urlaubstageProJahr / 365m * restlicheTageImJahr;
            //        }
            //    }

            //}
            //else if (/*entryDate.Day > 1 && */anzahlArbeitstage < 5) // Mitten im Jahr, weniger als 5 Tage
            //{
            //    urlaubstage = (decimal)urlaubstageProJahr / 5m * anzahlArbeitstage / 365m * restlicheTageImJahr;
            //}
            //else if (/*entryDate.Day > 1 && */anzahlArbeitstage >= 5) // Mitten im Jahr, 5 oder 6 Tage
            //{
            //    urlaubstage = (decimal)urlaubstageProJahr / 365m * restlicheTageImJahr;
            //}

            //// Runden
            //urlaubstage = UrlaubstageRunden(urlaubstage);

            //return urlaubstage;
            #endregion
        }

        public virtual decimal UrlaubstageRunden(decimal urlaubstage)
        {
            // Bis 0.25 wird abgerundet
            if (urlaubstage - (int)urlaubstage < 0.25m)
            {
                urlaubstage = Math.Round(urlaubstage, MidpointRounding.AwayFromZero);
            }
            // Zwischen 0.25 und 0.75 wird auf 0.5 gerundet
            else if (urlaubstage - (int)urlaubstage < 0.75m)
            {
                decimal digits = urlaubstage - (int)urlaubstage;
                urlaubstage = urlaubstage - digits + 0.5m;
            }
            // Ab 0.75 auf nächste volle Zahl aufrunden 
            else
            {
                urlaubstage = Math.Ceiling(urlaubstage);
            }

            return urlaubstage;
        }

        public decimal BerechneAnzahlUrlaubstage(AbsenceTime absence, AbsenceTimeDC absenceDC, int year, int? workdays)
        {
            if (absence != null)
            {
                if (absence.Start.HasValue)
                {
                    decimal days = 0;
                    //int days = 0;

                    //DateTime start = absence.Start.Value;        
                    DateTime start = (absence.Start.Value.Year == year) ? absence.Start.Value : new DateTime(year, 1, 1);
                    DateTime end = start;
                    DateTime maxend = new DateTime(year, 12, 31);
                    if (absence.End.HasValue)
                    {
                        end = absence.End.Value;
                    }

                    if (maxend < end)
                    {
                        end = maxend;
                    }

                    var tageInDerWoche = 0m;
                    while (start <= end)
                    {
                        if (start.DayOfWeek == DayOfWeek.Monday)
                            tageInDerWoche = 0;
                        if (!CheckIstWochenende(workdays, start.DayOfWeek) && !IstFeiertag(start) && tageInDerWoche < workdays.Value && tageInDerWoche + 1 <= workdays.Value)
                        {
                            if (start.Date == end.Date && start.TimeOfDay != end.TimeOfDay)
                            {
                                days += 0.5m;
                                tageInDerWoche += 0.5m;
                            }
                            else
                            {
                                days++;
                                tageInDerWoche++;
                            }
                        }

                        start = start.AddDays(1);
                    }
                    return (decimal)days;
                }
            }

            else if (absenceDC != null)
            {
                if (absenceDC.Start.HasValue)
                {
                    decimal days = 0;
                    //int days = 0;

                    //DateTime start = absence.Start.Value;        
                    DateTime start = (absenceDC.Start.Value.Year == year) ? absenceDC.Start.Value : new DateTime(year, 1, 1);
                    DateTime end = start;
                    DateTime maxend = new DateTime(year, 12, 31);
                    if (absenceDC.End.HasValue)
                    {
                        end = absenceDC.End.Value;
                    }

                    if (maxend < end)
                    {
                        end = maxend;
                    }


                    while (start <= end)
                    {
                        if (!CheckIstWochenende(workdays, start.DayOfWeek) && !IstFeiertag(start))
                        {
                            if (start.Date == end.Date && start.TimeOfDay != end.TimeOfDay)
                                days += 0.5m;
                            else
                                days++;
                        }

                        start = start.AddDays(1);
                    }
                    return (decimal)days;
                }
            }


            return 0;
        }
        public Dictionary<long?, decimal> BerechneAnzEinerAbwesenheitFuerMehrereMitarbeiter(List<long?> empOids, int year, string reason)
        {
            SetLokaleFeiertagListe(year);

            EmployeeServiceImp es = new EmployeeServiceImp();
            var absences = es.GetAllEmployeeAbsenceTimesForYear(year).Where(abs => abs.Reason.Description.ToLower().Contains(reason.ToLower()));

            Dictionary<long?, decimal> urlaubGenommenProMitarbeiter = new Dictionary<long?, decimal>();

            foreach (var oid in empOids)
            {
                var absencesForCurrentEmp = absences.Where(a => a.EmployeeOid == oid);
                decimal tage = 0;

                foreach (var abs in absencesForCurrentEmp)
                {
                    var start = (DateTime)DateTimeExtensions.GetMax(abs.Start, new DateTime(year, 1, 1));
                    var end = (DateTime)DateTimeExtensions.GetMin(abs.End != null ? abs.End: new DateTime(year, 12, 31), new DateTime(year, 12, 31));

                    while (start <= end)
                    {
                        if (start.DayOfWeek != DayOfWeek.Saturday && start.DayOfWeek != DayOfWeek.Sunday && !_Feiertage.Contains(start))
                        {
                            if (start.Date == end.Date && start.TimeOfDay != end.TimeOfDay)
                                tage += 0.5m;
                            else
                                tage++;
                        }


                        start = start.AddDays(1);
                    }
                }

                urlaubGenommenProMitarbeiter.Add(oid, tage);
            }

            return urlaubGenommenProMitarbeiter;
        }
    }
}