using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using BeWo.Data.Access;
using BeWo.Data.Entities;
using BeWo.Service.DCEntityMapper;

using BS.Shared;
using BS.Shared.Core;
using BS.Shared.DataContracts;
using BS.Shared.DataContracts.Compact;
using BS.Shared.Extensions;
using DevExpress.XtraRichEdit.Commands;
using Employee = BeWo.Data.Entities.Employee;

namespace BeWo.Service.SBD
{
    internal class VertretungsManager
    {
        private static List<ContactDC> LoadContactInformationForEntity<T>(long entityOid) where T : BeWoEntityBase
        {
            var entity = typeof(T) == typeof(Employee) ? DAOFactory.GenericDAO.LoadByID<Employee>(entityOid).Person : DAOFactory.GenericDAO.LoadByID<Customer>(entityOid).Person;

            return MapperFactory.ContactDC_Contact.MapToNewDCs(entity.Contacts);
        }

        public List<VertretungsItemDC> CreateSubstitutions(DateTime start, DateTime end)
        {
            Dictionary<String, bool> employeeIsAbsenceDict = new Dictionary<String, bool>();
            Dictionary<String, bool> customerIsAbsenceDict = new Dictionary<String, bool>();

            var vertretungsItems = new List<VertretungsItemDC>();

            end = end.Date.AddDays(1).AddTicks(-1);
            var vertretungen = DAOFactory.SearchDAO.FindVertretungen(start, end).Where(v => v.VertretenderMitarbeiterOid.HasValue).ToList();
            var absenceTimes = DAOFactory.SearchDAO.FindAbsenceTimes(start, end).ToList();

            var employeeAbsenceTimes = absenceTimes.Where(absenceTime => absenceTime.EmployeeOid.HasValue).ToList();
            var customerAbsenceTimes = absenceTimes.Where(absenceTime => absenceTime.CustomerOid.HasValue).ToList();

            var customerOids = vertretungen.Where(w => w.CustomerOid.HasValue).Select(s => s.CustomerOid.Value).ToList();
            customerOids.AddRangeIfElementsNotIn(absenceTimes.Where(w => w.CustomerOid.HasValue).Select(s => s.CustomerOid.Value).ToList());

            var customers = DAOFactory.GenericDAO.LoadByIDs<Customer>(customerOids);
            var customerContactInformation = new Dictionary<long, List<ContactDC>>();

            var employees = DAOFactory.GenericDAO.LoadByIDs<Employee>(employeeAbsenceTimes.Select(absenceTime => absenceTime.EmployeeOid.Value));

            var employeeVertretungsItems = new List<VertretungsItemDC>();
            var customerVertretungsItems = new List<VertretungsItemDC>();
            var employeeVertretungsItemsGuids2Ignore = new List<Guid>();

            foreach (var customer in customers)
            {
                var contacts = MapperFactory.ContactDC_Contact.MapToNewDCs(customer.Person.Contacts);

                if (customer.Oid != null)
                {
                    customerContactInformation.AddOrUpdateValueInDictionary(customer.Oid.Value, contacts);
                }
            }

            // Mitarbeiterabwesenheiten
            foreach (var absenceTime in employeeAbsenceTimes)
            {
                var employee = employees.FirstOrDefault(emp => emp.Oid.HasValue && emp.Oid.Value.Equals(absenceTime.EmployeeOid));
                if (employee == null)
                {
                    continue;
                }

                var employeeDC = MapperFactory.CompactEmployeeDC_Employee.MapToNewDC(employee);
                var employeeAddressString = GetEmployeeAddressInfo(employee.Oid.Value);
                var employeeContactInformationList = LoadContactInformationForEntity<Employee>(employee.Oid.Value);

                var absenceTimeDC = MapperFactory.AbsenceTimeDC_AbsenceTime.MapToNewDC(absenceTime);

                foreach (var employee2Customer in employee.Employee2CustomerList.Where(e2C => e2C.IsActive == ActivationTypeId.Active))
                {
                    foreach (var valueListEntry2Object in employee2Customer.ValueList.Where(entry2Object => entry2Object.Entry.Type == ValueListEntryType.StaffRoleType))
                    {
                        var customer = employee2Customer.Customer;
                        var customerDC = MapperFactory.CompactCustomerDC_Customer.MapToNewDC(customer);
                        var customerContactInformationList = LoadContactInformationForEntity<Customer>(customer.Oid.Value);
                        var schools = MapperFactory.CustomerOrganisationRelationDC_Customer2Organisation.MapToNewDCs(customer.Customer2OrganisationList.Where(customer2Organisation => customer2Organisation.ValueList.Any(b => b.Entry.Type == ValueListEntryType.EnvironmentOrganisationType && b.Entry.Value.Equals("Schule"))));

                        var assistanceTimeEntries = GetAssistanceTimesForCustomer(customer, employee, absenceTime, start, end);

                        var dateTime = start;
                        while (dateTime <= end)
                        {
                            if (LiegtImZeitraum(dateTime, absenceTime))
                            {
                                AddToDict(employeeIsAbsenceDict, dateTime, employee.Oid.Value);

                                var dateTimeCopy = dateTime;
                                var relevantAssistanceTimeEntries = assistanceTimeEntries.Where(entry => IsAbsenceTimeInAssistanceTime(dateTimeCopy, entry, absenceTime));

                                foreach (var assistanceTimeEntry in relevantAssistanceTimeEntries)
                                {
                                    var vertretungsObjekte = vertretungen.Where(w => w.EmployeeOid.HasValue && w.EmployeeOid.Equals(employee.Oid) && w.CustomerOid.HasValue && w.CustomerOid.Equals(customer.Oid) && w.VertretungsZeitraumVon.Date <= dateTimeCopy && w.VertretungsZeitraumBis.Date >= dateTimeCopy);
                                    var lastSubstitutions = DAOFactory.SearchDAO.GetLastSubstitutionItems(employee.Oid.Value, 3);
                                    var lastSubstitutionDCs = MapperFactory.VertretungDC_Vertretung.MapToNewDCs(lastSubstitutions);
                                    var assistanceTimeEntryDC = MapperFactory.ArbeitszeitEintragDC_ArbeitszeitEintrag.MapToNewDC(assistanceTimeEntry);

                                    var newVertretungsItem = new VertretungsItemDC
                                    {
                                        Id = Guid.NewGuid(),
                                        Datum = dateTime,
                                        Absencetime = absenceTimeDC,
                                        AssistanceTime = assistanceTimeEntryDC,
                                        Employee = employeeDC,
                                        EmployeeAddressString = employeeAddressString,
                                        LastSubstitutions = lastSubstitutionDCs,
                                        Customer = customerDC,
                                        CustomerContactInformation = customerContactInformationList,
                                        EmployeeContactInformation = employeeContactInformationList,
                                        Schools = schools,
                                        Bemerkung = absenceTime.Notice
                                    };

                                    AddKrankheitsZeitraumAndMeldungToItem(newVertretungsItem, newVertretungsItem.Absencetime);
                                    GetVertretungsstatus(newVertretungsItem, dateTime, absenceTime.Start.Value, customer);

                                    // Es gibt immer nur ein Vertretungsobjekt
                                    var vertretung = vertretungsObjekte.FirstOrDefault();

                                    if (vertretung?.VertretenderMitarbeiterOid != null)
                                    {
                                        if (GetIsSubstitutedCompletely(new List<ArbeitszeitEintrag> {assistanceTimeEntry}, vertretung, dateTime))
                                        {
                                            var substitutionEmployee = DAOFactory.GenericDAO.LoadByID<Employee>(vertretung.VertretenderMitarbeiterOid.Value);
                                            var substitutionEmployeeDC = MapperFactory.CompactEmployeeDC_Employee.MapToNewDC(substitutionEmployee);

                                            newVertretungsItem.Vertreter = substitutionEmployeeDC;

                                            newVertretungsItem.VertreterInfoString = GetEmployeeAddressInfo(vertretung.VertretenderMitarbeiterOid.Value);

                                            newVertretungsItem.Vertretung = MapperFactory.VertretungDC_Vertretung.MapToNewDC(vertretung);
                                            newVertretungsItem.Bemerkung = vertretung.Notice;

                                            newVertretungsItem.VertretungsStatus = VertretungsStatus.MaKrankVertretungVorhanden;
                                        }
                                    }

                                    SetSubstitutionColor(newVertretungsItem);

                                    SetSBDInformation(newVertretungsItem, customer, employee, true);

                                    SetTeamleitung(employee, newVertretungsItem);

                                    employeeVertretungsItems.Add(newVertretungsItem);
                                }
                            }

                            dateTime = dateTime.AddDays(1);
                        }
                    }
                }
            }

            // Klientenabwesenheiten
            foreach (var absenceTime in customerAbsenceTimes)
            {
                var customer = customers.FirstOrDefault(first => first.Oid.HasValue && first.Oid.Equals(absenceTime.CustomerOid)) ?? DAOFactory.GenericDAO.LoadByID<Customer>(absenceTime.CustomerOid.Value);
                var absenceTimeDC = MapperFactory.AbsenceTimeDC_AbsenceTime.MapToNewDC(absenceTime);
                var customerDC = MapperFactory.CompactCustomerDC_Customer.MapToNewDC(customer);
                var customerContactInformationList = LoadContactInformationForEntity<Customer>(customer.Oid.Value);
                var schools = MapperFactory.CustomerOrganisationRelationDC_Customer2Organisation.MapToNewDCs(customer.Customer2OrganisationList.Where(customer2Organisation => customer2Organisation.ValueList.Any(b => b.Entry.Type == ValueListEntryType.EnvironmentOrganisationType && b.Entry.Value.Equals("Schule"))));
                var schoolAssistanceTimes = GetSchoolAssistanceTimes(customer, start, end, absenceTime);
                var hauptbetreuer = customer.Employee2CustomerList.FirstOrDefault(f => f.IsActive == ActivationTypeId.Active && f.ValueList.Any(b => b.Entry.Type.Equals(ValueListEntryType.StaffRoleType) && b.Entry.Value.ToLower().Equals("hauptbetreuung")))?.Employee;
                if (hauptbetreuer == null)
                {
                    hauptbetreuer = customer.Employee2CustomerList.FirstOrDefault()?.Employee;
                }
                MigriereSubstitutionStatus(customer);

                var assistingEmployees = new List<Employee>();
                customer.Arbeitszeiten.DoForEach(a => assistingEmployees.AddRangeIfElementsNotIn(a.ArbeitszeitEintraege.Where(ae => ae.Employee != null).Select(s => s.Employee)));

                schoolAssistanceTimes.DoForEach(a =>
                {
                    foreach (var assistanceTimeEntry in a.ArbeitszeitEintraege)
                    {
                        if (assistanceTimeEntry.Employee != null && assistanceTimeEntry.Employee.IsActive != ActivationTypeId.Active)
                        {
                            continue;
                        }

                        if (assistanceTimeEntry.Employee == null)
                        {
                            if (hauptbetreuer != null)
                            {
                                assistingEmployees.AddIfNotIn(hauptbetreuer);
                            }
                        }
                        else
                        {
                            assistingEmployees.AddIfNotIn(assistanceTimeEntry.Employee);
                        }
                    }
                });

                var hasCaregiver = customer.Employee2CustomerList.Any(a => a.ValueList.Any(b => b.Entry.Type.Equals(ValueListEntryType.StaffRoleType) && !b.Entry.Value.ToLower().Equals("ehemalige betreuung"))) || assistingEmployees.Any();
                if (hasCaregiver)
                {
                    var relatedEmployees = new List<Employee>(assistingEmployees);
                    relatedEmployees.AddRangeIfElementsNotIn(
                        customer.Employee2CustomerList
                            .Where(
                                e2C => e2C.Employee.IsActive == ActivationTypeId.Active &&
                                       !e2C.ValueList.Any(
                                           w => w.Entry.Type.Equals(ValueListEntryType.StaffRoleType) &&
                                                !w.Entry.Value.ToLower().Equals("ehemalige betreuung")))
                            .Select(s => s.Employee));

                    foreach (var employee in relatedEmployees)
                    {
                        var employeeDC = MapperFactory.CompactEmployeeDC_Employee.MapToNewDC(employee);
                        var employeeAddressString = GetEmployeeAddressInfo(employee.Oid.Value);
                        var employeeContactInformationList = LoadContactInformationForEntity<Employee>(employee.Oid.Value);

                        var assistanceTimeEntries = GetAssistanceTimesForCustomer(customer, employee, absenceTime, start, end);

                        var dateTime = start;
                        while (dateTime <= end)
                        {
                            if (LiegtImZeitraum(dateTime, absenceTime))
                            {
                                AddToDict(customerIsAbsenceDict, dateTime, customer.Oid.Value);

                                var dateTimeCopy = dateTime;
                                var relevantAssistanceTimeEntries = assistanceTimeEntries.Where(entry => IsAbsenceTimeInAssistanceTime(dateTime, entry, absenceTime) && (entry.Employee != null && entry.Employee.Equals(employee) || entry.Employee == null && employee.Equals(hauptbetreuer))).ToList();
                                var vertretungsObjekte = vertretungen.Where(w => w.EmployeeOid.HasValue && w.EmployeeOid.Equals(employee.Oid) && w.CustomerOid.HasValue && w.CustomerOid.Equals(customer.Oid) && w.VertretungsZeitraumVon.Date <= dateTimeCopy && w.VertretungsZeitraumBis.Date >= dateTimeCopy).ToList();
                                var lastSubstitutions = DAOFactory.SearchDAO.GetLastSubstitutionItems(employee.Oid.Value, 3);
                                var lastSubstitutionDCs = MapperFactory.VertretungDC_Vertretung.MapToNewDCs(lastSubstitutions);
                                var assistanceTimeEntryDCs = MapperFactory.ArbeitszeitEintragDC_ArbeitszeitEintrag.MapToNewDCs(relevantAssistanceTimeEntries);

                                
                                foreach (var assistanceTimeEntry in relevantAssistanceTimeEntries)
                                {
                                    var assistanceTimeEntryDC = MapperFactory.ArbeitszeitEintragDC_ArbeitszeitEintrag.MapToNewDC(assistanceTimeEntry);

                                    var newVertretungsItem = new VertretungsItemDC
                                    {
                                        Id = Guid.NewGuid(),
                                        Datum = dateTime,
                                        Absencetime = absenceTimeDC,
                                        Arbeitszeiten = assistanceTimeEntryDCs,
                                        Employee = employeeDC,
                                        EmployeeAddressString = employeeAddressString,
                                        LastSubstitutions = lastSubstitutionDCs,
                                        Customer = customerDC,
                                        CustomerContactInformation = customerContactInformationList,
                                        EmployeeContactInformation = employeeContactInformationList,
                                        Schools = schools,
                                        VertretungsStatus = VertretungsStatus.KlientKrank,
                                        Bemerkung = absenceTime.Notice,
                                        AssistanceTime = assistanceTimeEntryDC
                                    };

                                    AddKrankheitsZeitraumAndMeldungToItem(newVertretungsItem, newVertretungsItem.Absencetime);

                                    var vertretung = vertretungsObjekte.FirstOrDefault();

                                    if(vertretung?.VertretenderMitarbeiterOid != null)
                                    {
                                        if(GetIsSubstitutedCompletely(relevantAssistanceTimeEntries, vertretung, dateTime))
                                        {
                                            var substitutionEmployee = DAOFactory.GenericDAO.LoadByID<Employee>(vertretung.VertretenderMitarbeiterOid.Value);
                                            var substitutionEmployeeDC = MapperFactory.CompactEmployeeDC_Employee.MapToNewDC(substitutionEmployee);

                                            newVertretungsItem.Vertreter = substitutionEmployeeDC;

                                            newVertretungsItem.VertreterInfoString = GetEmployeeAddressInfo(vertretung.VertretenderMitarbeiterOid.Value);

                                            newVertretungsItem.Vertretung = MapperFactory.VertretungDC_Vertretung.MapToNewDC(vertretung);
                                            newVertretungsItem.Bemerkung = vertretung.Notice;

                                            newVertretungsItem.VertretungsStatus = VertretungsStatus.MaKrankVertretungVorhanden;
                                        }
                                    }

                                    // TODO: Hat die vertretungsItemListe Objekte mit dem Klienten im selben Zeitfenster?
                                    foreach (var employeeVertretungsItem in employeeVertretungsItems.Where(w => w.Customer.Equals(customerDC)))
                                    {
                                        if (employeeVertretungsItem.Datum == dateTime)
                                        {
                                            if (IsAbsenceTimeInAssistanceTime(dateTime, employeeVertretungsItem.AssistanceTime, absenceTime))
                                            {
                                                employeeVertretungsItemsGuids2Ignore.AddIfNotIn(employeeVertretungsItem.Id);
                                                if (newVertretungsItem.VertretungsStatus == VertretungsStatus.KlientKrank)
                                                {
                                                    newVertretungsItem.VertretungsStatus = VertretungsStatus.KlientUndMitarbeiterKrank;
                                                }
                                                else
                                                {
                                                    newVertretungsItem.VertretungsStatus =
                                                        VertretungsStatus.MaKrankKeineVertretungBenoetigt;
                                                }
                                            }
                                        }
                                    }

                                    SetSubstitutionColor(newVertretungsItem);

                                    


                                    SetSBDInformation(newVertretungsItem, customer, employee, false);

                                    SetTeamleitung(employee, newVertretungsItem);

                                    customerVertretungsItems.Add(newVertretungsItem);
                                }
                            }

                            dateTime = dateTime.AddDays(1);
                        }
                    }
                }
                else // Kein Betreuer, also auch keine Vertretungen, sondern nur Abwesenheiten
                {
                    var assistanceTimeEntries = GetAssistanceTimesForCustomer(customer, null, absenceTime, start, end);

                    var dateTime = start;
                    while (dateTime <= end)
                    {
                        if (LiegtImZeitraum(dateTime, absenceTime))
                        {
                            var relevantAssistanceTimeEntries = assistanceTimeEntries.Where(entry => IsAbsenceTimeInAssistanceTime(dateTime, entry, absenceTime)).ToList();
                            var assistanceTimeEntryDCs = MapperFactory.ArbeitszeitEintragDC_ArbeitszeitEintrag.MapToNewDCs(relevantAssistanceTimeEntries);

                            var newVertretungsItem = new VertretungsItemDC
                            {
                                Id = Guid.NewGuid(),
                                Datum = dateTime,
                                Absencetime = absenceTimeDC,
                                Arbeitszeiten = assistanceTimeEntryDCs,
                                Customer = customerDC,
                                CustomerContactInformation = customerContactInformationList,
                                Schools = schools,
                                VertretungsStatus = VertretungsStatus.KlientUndMitarbeiterKrank,
                                Bemerkung = absenceTime.Notice
                            };

                            SetzeSchule(newVertretungsItem, customer);

                            AddKrankheitsZeitraumAndMeldungToItem(newVertretungsItem, absenceTimeDC);

                            SetSubstitutionColor(newVertretungsItem);

                            SetSBDInformation(newVertretungsItem, customer, null, false);

                            customerVertretungsItems.Add(newVertretungsItem);
                        }

                        dateTime = dateTime.AddDays(1);
                    }
                }
            }

            vertretungsItems.AddRange(employeeVertretungsItems.Where(vertretungsItem => !employeeVertretungsItemsGuids2Ignore.Contains(vertretungsItem.Id)));

            //prüfen, ob Mitarbeiter bereits als Vertretung eingesetzt ist:
            //customerVertretungsItems = customerVertretungsItems.Where(c => c.Employee != null && c.Equals( !employeeVertretungsItems.Where(ei => ei.Vertreter != null).Select(ei2 => ei2.Vertreter.EmployeeOid).Contains(c.Employee.EmployeeOid))).ToList();
            var newList = new List<VertretungsItemDC>();
            foreach (var ci in customerVertretungsItems)
            {
                if (ci.Employee == null)
                {
                    newList.Add(ci);
                }
                else
                {
                    bool istAlsVertreterEingesetzt = false;

                    foreach (var ei in employeeVertretungsItems)
                    {
                        if (ei.Vertreter != null && ei.Vertreter.EmployeeOid == ci.Employee.EmployeeOid)
                        {
                            istAlsVertreterEingesetzt = true;
                        }
                    }

                    if (!istAlsVertreterEingesetzt)
                    {
                        newList.Add(ci);
                    }
                }
            }

            //customerVertretungsItems = customerVertretungsItems.Where(c => c.Employee == null || !employeeVertretungsItems.Where(ei => ei.Vertreter != null).Select(ei2 => ei2.Vertreter.EmployeeOid).Contains(c.Employee.EmployeeOid)).ToList();
            customerVertretungsItems = newList;

            vertretungsItems.AddRange(customerVertretungsItems);

            SetSubstitutingEmployee2CustomersRelation(vertretungsItems);

            vertretungsItems = RemoveDuplicates(vertretungsItems);
            return vertretungsItems;
        }

        private List<VertretungsItemDC> RemoveDuplicates(List<VertretungsItemDC> vertretungsItems)
        {
            var newList = new List<VertretungsItemDC>();
            var keyDict = new Dictionary<string, bool>();
            foreach (var ci in vertretungsItems)
            {
                if (ci.Customer != null && ci.Employee != null && ci.Absencetime != null &&
                    (ci.VertretungsStatus == VertretungsStatus.KlientUndMitarbeiterKrank ||
                     ci.VertretungsStatus == VertretungsStatus.MaKrankKeineVertretungBenoetigt ||
                     ci.VertretungsStatus == VertretungsStatus.MaKrankVertretungVorhanden))
                {
                    String key = "";
                    if (ci.Vertretung != null &&
                        ci.Vertretung.VertretungsZeitraumVon.Hour == 0 &&
                        ci.Vertretung.VertretungsZeitraumVon.Minute == 0 &&
                        ci.Vertretung.VertretungsZeitraumBis.Hour == 23 &&
                        ci.Vertretung.VertretungsZeitraumBis.Minute == 59)
                    {
                        ci.Vertretung.VertretungsZeitraumBis = ci.Vertretung.VertretungsZeitraumBis.Date;

                        key = String.Format("{0}_{1}_{2:dd.MM.yyyy HH:mm} - {3:dd.MM.yyyy HH:mm}_{4}", ci.Customer.Oid, ci.Employee.EmployeeOid, ci.Vertretung.VertretungsZeitraumVon, ci.Vertretung.VertretungsZeitraumBis, ci.Absencetime.AbsenceTimeOid);
                    }
                    else
                    {
                        if (ci.Vertretung == null)
                        {
                            key = String.Format("{0}_{1}_{2}", ci.Customer.Oid, ci.Employee.EmployeeOid, ci.Absencetime.AbsenceTimeOid);
                        }
                    }
                    

                    if (String.IsNullOrEmpty(key) || !keyDict.ContainsKey(key))
                    {
                        newList.Add(ci);
                        if (!String.IsNullOrEmpty(key))
                        {
                            keyDict.Add(key, true);
                        }
                    }
                    else
                    {
                        int test = 0;
                    }
                }
                else
                {
                    newList.Add(ci);
                }
            }

            return newList;
        }

        private void AddToDict(Dictionary<string, bool> dict, DateTime dateTime, long oid)
        {
            String key = String.Format("{0:ddMMyyyy}_{1}", dateTime, oid);
            if (!dict.ContainsKey(key))
            {
                dict.Add(key, true);
            }
        }

        public List<VertretungsItemDC> CreateVertretungsListe(DateTime start, DateTime end)
        {
            return CreateSubstitutions(start, end);
        }

        private static void SetSubstitutingEmployee2CustomersRelation(IEnumerable<VertretungsItemDC> vertretungsItems)
        {
            var vertreterZuKlient = new Dictionary<string, CompactCustomerDC>();
            foreach (var item in vertretungsItems)
            {
                //Suche alle Vertreter für Klienten und merke diese
                if (item.VertretungsStatus != VertretungsStatus.KlientKrank)
                {
                    if (item.Vertreter != null && item.Customer != null)
                    {
                        var key = $"{item.Vertreter.EmployeeOid}_{item.Datum:dd.MM.yyyy}";

                        if (!vertreterZuKlient.ContainsKey(key))
                        {
                            vertreterZuKlient.Add(key, item.Customer);
                        }
                    }
                }

                if (item.MitarbeiterEinsatzBei == "???" && item.Employee != null)
                {
                    item.MitarbeiterEinsatzBei = "";

                    var key = $"{item.Employee.EmployeeOid}_{item.Datum:dd.MM.yyyy}";

                    if (vertreterZuKlient.ContainsKey(key))
                    {
                        item.MitarbeiterEinsatzBei = $"{vertreterZuKlient[key].LastNameFirstName}";
                    }
                }
            }
        }

        private static void SetSBDInformation(VertretungsItemDC vertretungsItem, Customer customer, Employee employee, bool isEmployeeAbsenceTime)
        {
            vertretungsItem.CustomerPflege = customer.Pflege ? "Ja" : "Nein";
            vertretungsItem.CustomerToilettengang = customer.Toilettengang ? "Ja" : "Nein";
            vertretungsItem.CustomerAggressivitaet = customer.Aggressiv ? "Ja" : "Nein";
            vertretungsItem.CustomerHygienebelehrung = customer.Hygienebelehrung ? "Ja" : "Nein";
            vertretungsItem.CustomerSchutzstufe = customer.Schutzstufe;

            vertretungsItem.EmployeePflege = employee == null ? "Nein" : employee.Pflege ? "Ja" : "Nein";
            vertretungsItem.EmployeeToilettengang = employee == null ? "Nein" : employee.Toilettengang ? "Ja" : "Nein";
            vertretungsItem.EmployeeAggressivitaet = employee == null ? "Nein" : employee.Aggressiv ? "Ja" : "Nein";
            vertretungsItem.EmployeeHygienebelehrung = employee == null ? "Nein" : employee.Hygienebelehrung ? "Ja" : "Nein";
            vertretungsItem.EmployeeSchutzstufe = employee?.Schutzstufe;

            if (isEmployeeAbsenceTime)
            {
                vertretungsItem.Pflege = customer.Pflege ? "Ja" : "Nein";
                vertretungsItem.Toilettengang = customer.Toilettengang ? "Ja" : "Nein";
                vertretungsItem.Aggressiv = customer.Aggressiv ? "Ja" : "Nein";

                if (customer.Person.Sex.HasValue)
                {
                    vertretungsItem.Geschlecht = Utils.GetSexAbbrevation(customer.Person.Sex);
                }
            }
            else
            {
                vertretungsItem.Pflege = employee == null ? "Nein" : employee.Pflege ? "Ja" : "Nein";
                vertretungsItem.Toilettengang = employee == null ? "Nein" : employee.Toilettengang ? "Ja" : "Nein";
                vertretungsItem.Aggressiv = employee == null ? "Nein" : employee.Aggressiv ? "Ja" : "Nein";

                if (employee?.Person.Sex != null)
                {
                    vertretungsItem.Geschlecht = Utils.GetSexAbbrevation(employee.Person.Sex);
                }

                vertretungsItem.MitarbeiterEinsatzBei = "???";
            }


            var customerToolTip = new StringBuilder();
            var employeeToolTip = new StringBuilder();
            var vertreterToolTip = new StringBuilder();


            String customerName = "";
            String employeeName = "";
            String vertreterName = "";

            if (vertretungsItem.Customer != null)
            {
                customerName = String.Format("{0} {1}", vertretungsItem.Customer.FirstName, vertretungsItem.Customer.LastName);
            }
            if (vertretungsItem.Employee != null)
            {
                employeeName = String.Format("{0} {1}", vertretungsItem.Employee.FirstName, vertretungsItem.Employee.LastName);
            }
            if (vertretungsItem.Vertreter != null)
            {
                vertreterName = String.Format("{0} {1}", vertretungsItem.Vertreter.FirstName, vertretungsItem.Vertreter.LastName);
            }

            String schoolString = "";
            if (vertretungsItem.Schools != null)
            {
                foreach (var item in vertretungsItem.Schools)
                {
                    if (schoolString.Length > 0)
                    {
                        schoolString += ", ";
                    }

                    schoolString += item.Organisation.Name;
                }
            }


            customerToolTip.AppendLine("<StackPanel xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation'>");
            employeeToolTip.AppendLine("<StackPanel xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation'>");
            vertreterToolTip.AppendLine("<StackPanel xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation'>");

            //Customer Tooltip
            if (!String.IsNullOrEmpty(customerName))
            {
                customerToolTip.AppendLine(String.Format("<TextBlock FontWeight='Bold' Text='{0}' />", customerName));
            }
            if (!String.IsNullOrEmpty(schoolString))
            {
                customerToolTip.AppendLine(String.Format("<Separator />"));
                customerToolTip.AppendLine(String.Format("<TextBlock FontWeight='Bold' Text='Schule:' /> "));
                customerToolTip.AppendLine(String.Format("<TextBlock Text='{0}' />", schoolString));
            }
            String contactString = "";

            if (vertretungsItem.EmployeeContactInformation != null && vertretungsItem.EmployeeContactInformation.Count > 0)
            {
                foreach (var item in vertretungsItem.EmployeeContactInformation)
                {
                    if (contactString.Length > 0)
                    {
                        contactString += "<LineBreak/>";
                    }

                    var typeAsString = string.Empty;
                    switch (item.ContactType)
                    {
                        case ContactType.business_Mail:
                            typeAsString = "E-Mail: ";
                            break;
                        case ContactType.business_Fax:
                            typeAsString = "Fax: ";
                            break;
                        case ContactType.business_Phone:
                            typeAsString = "Tel.: ";
                            break;
                        case ContactType.business_MobilePhone:
                            typeAsString = "Handynr.: ";
                            break;
                    }

                    contactString += typeAsString + item.ContactValue;
                }
            }
            if (!String.IsNullOrEmpty(contactString))
            {
                customerToolTip.AppendLine(String.Format("<Separator />"));
                customerToolTip.AppendLine(String.Format("<TextBlock FontWeight='Bold' Text='Kontakt:' /> "));
                customerToolTip.AppendLine(String.Format("<TextBlock>{0}</TextBlock>", contactString));
            }

            var lastSubstitutions = string.Empty;

            foreach (var item in vertretungsItem.LastSubstitutions)
            {
                if (lastSubstitutions.Length > 0)
                {
                    lastSubstitutions += "<LineBreak/>";
                }

                var start = item.VertretungsZeitraumVon.Minute == 0 && item.VertretungsZeitraumVon.Hour == 0 ? item.VertretungsZeitraumVon.ToString("dd.MM.yyyy") : item.VertretungsZeitraumVon.ToString("dd.MM.yyyy HH:mm");
                var end = item.VertretungsZeitraumBis.Minute == 0 && item.VertretungsZeitraumBis.Hour == 0 ? item.VertretungsZeitraumBis.ToString("dd.MM.yyyy") : item.VertretungsZeitraumBis.ToString("dd.MM.yyyy HH:mm");

                lastSubstitutions += $"{start} - {end}";
            }

            if (!String.IsNullOrEmpty(lastSubstitutions))
            {
                customerToolTip.AppendLine(String.Format("<Separator />"));
                customerToolTip.AppendLine(String.Format("<TextBlock FontWeight='Bold' Text='Letzte Vertretungen:' /> "));
                customerToolTip.AppendLine(String.Format("<TextBlock>{0}</TextBlock>", lastSubstitutions));
            }

            var sbdStatus = string.Empty;

            //if (vertretungsItem.Absencetime != null)
            //{
            if (customer.Pflege)
            {
                sbdStatus += "Benötigt Pflege";
            }

            if (customer.Toilettengang)
            {
                if (sbdStatus.Length > 0)
                {
                    sbdStatus += ", ";
                }

                sbdStatus += "Toilettengang";
            }

            if (customer.Aggressiv)
            {
                if (sbdStatus.Length > 0)
                {
                    sbdStatus += ", ";
                }

                sbdStatus += "Aggressivität";
            }

            if (customer.Hygienebelehrung)
            {
                if (sbdStatus.Length > 0)
                {
                    sbdStatus += ", ";
                }

                sbdStatus += "Hygienebelehrung";
            }

            if (!String.IsNullOrWhiteSpace(customer.Schutzstufe))
            {
                if (sbdStatus.Length > 0)
                {
                    sbdStatus += ", ";
                }

                sbdStatus += $"Schutzstufe {customer.Schutzstufe}";
            }

            // Vertretung gewünscht [ab x. Tag]
            if (customer.SubstitutionNeed == SubstitutionNeed.SubstitutionWanted)
            {
                if (sbdStatus.Length > 0)
                {
                    sbdStatus += "<LineBreak/>";
                }

                sbdStatus += "Vertretung gewünscht";

                if (customer.AbWelchemKrankheitsTag > 0)
                {
                    sbdStatus += $" ab {customer.AbWelchemKrankheitsTag}. Tag";
                }
            }

            if (!String.IsNullOrEmpty(sbdStatus))
            {
                customerToolTip.AppendLine(String.Format("<Separator />"));
                customerToolTip.AppendLine(String.Format("<TextBlock FontWeight='Bold' Text='Schulbegleitender Dienst:' /> "));
                customerToolTip.AppendLine(String.Format("<TextBlock>{0}</TextBlock>", sbdStatus));
            }
            //}
            //else
            //{
            //    if (EmployeePflege?.Equals("Ja") ?? false)
            //    {
            //        result += "Benötigt Pflege";
            //    }

            //    if (EmployeeToilettengang?.Equals("Ja") ?? false)
            //    {
            //        if (result.Length > 0)
            //        {
            //            result += ", ";
            //        }

            //        result += "Toilettengang";
            //    }

            //    if (EmployeeAggressivitaet?.Equals("Ja") ?? false)
            //    {
            //        if (result.Length > 0)
            //        {
            //            result += ", ";
            //        }

            //        result += "Aggressivität";
            //    }

            //    if (EmployeeHygienebelehrung?.Equals("Ja") ?? false)
            //    {
            //        if (result.Length > 0)
            //        {
            //            result += ", ";
            //        }

            //        result += "Hygienebelehrung";
            //    }

            //    if (string.IsNullOrWhiteSpace(EmployeeSchutzstufe) == false)
            //    {
            //        if (result.Length > 0)
            //        {
            //            result += ", ";
            //        }

            //        result += $"Schutzstufe {EmployeeSchutzstufe}";
            //    }
            ////}

            if (vertretungsItem.Customer != null)
            {
                customerToolTip.AppendLine(String.Format("<Separator />"));
                customerToolTip.AppendLine(String.Format("<TextBlock FontWeight='Bold' Text='Wohnort:' /> "));
                customerToolTip.AppendLine(String.Format("<TextBlock Text='{0}' />", vertretungsItem.Customer.AddressString));
            }

            //    <Separator Visibility="{Binding Path=Row.SchulbegleitenderDienstString, Converter={StaticResource StringLengthVisibilityConverter}}" />
            //    <TextBlock FontWeight="Bold" Text="Schulbegleitender Dienst:" Visibility="{Binding Path=Row.SchulbegleitenderDienstString, Converter={StaticResource StringLengthVisibilityConverter}}" />
            //    <TextBlock Text="{Binding Row.SchulbegleitenderDienstString}" Visibility="{Binding Path=Text, Converter={StaticResource StringLengthVisibilityConverter}, RelativeSource={RelativeSource Self}}" />

            //    <Separator Visibility="{Binding Row.EmployeeAddressString, Converter={StaticResource StringLengthVisibilityConverter}}" />
            //    <TextBlock FontWeight="Bold" Text="{markup:Translate Mitarbeiter/in:}" Visibility="{Binding Row.EmployeeAddressString, Converter={StaticResource StringLengthVisibilityConverter}}" />
            //    <TextBlock Text="{Binding Row.EmployeeAddressString}"  Visibility="{Binding Path=Text, Converter={StaticResource StringLengthVisibilityConverter}, RelativeSource={RelativeSource Self}}" />
            //</StackPanel>



            //Employee Tooltip
            if (!String.IsNullOrEmpty(employeeName))
            {
                employeeToolTip.AppendLine(String.Format("<TextBlock FontWeight='Bold' Text='{0}' />", employeeName));
            }
            //if (!String.IsNullOrEmpty(schoolString))
            //{
            //    employeeToolTip.AppendLine(String.Format("<Separator />"));
            //    employeeToolTip.AppendLine(String.Format("<TextBlock FontWeight='Bold' Text='Schule:' /> "));
            //    employeeToolTip.AppendLine(String.Format("<TextBlock Text='{0}' />", schoolString));
            //}

            if (vertretungsItem.Employee != null)
            {
                employeeToolTip.AppendLine(String.Format("<Separator />"));
                employeeToolTip.AppendLine(String.Format("<TextBlock FontWeight='Bold' Text='Wohnort:' /> "));
                employeeToolTip.AppendLine(String.Format("<TextBlock Text='{0}' />", vertretungsItem.Employee.DetailDescription));
            }

            //Vertreter Tooltip
            if (!String.IsNullOrEmpty(vertreterName))
            {
                vertreterToolTip.AppendLine(String.Format("<TextBlock FontWeight='Bold' Text='{0}' />", vertreterName));
            }
            //if (!String.IsNullOrEmpty(schoolString))
            //{
            //    vertreterToolTip.AppendLine(String.Format("<Separator />"));
            //    vertreterToolTip.AppendLine(String.Format("<TextBlock FontWeight='Bold' Text='Schule:' /> "));
            //    vertreterToolTip.AppendLine(String.Format("<TextBlock Text='{0}' />", schoolString));
            //}

            if (vertretungsItem.Vertreter != null)
            {
                vertreterToolTip.AppendLine(String.Format("<Separator />"));
                vertreterToolTip.AppendLine(String.Format("<TextBlock FontWeight='Bold' Text='Wohnort:' /> "));
                vertreterToolTip.AppendLine(String.Format("<TextBlock Text='{0}' />", vertretungsItem.Vertreter.DetailDescription));
            }
            customerToolTip.AppendLine("</StackPanel>");
            employeeToolTip.AppendLine("</StackPanel>");
            vertreterToolTip.AppendLine("</StackPanel>");



            //                < TextBlock FontWeight='Bold' Text='{0}'/>
            //                <Separator />
            //                <TextBlock Text='{1}'/>
            //            </StackPanel>", text1, text2); //.Replace("'", "\"");
            // //tt = @"<TextBlock FontWeight='Bold' Text='TESTSETSETESSETSET'/>";
            vertretungsItem.CustomerToolTip = customerToolTip.ToString();
            vertretungsItem.EmployeeToolTip = employeeToolTip.ToString();
            vertretungsItem.VertreterToolTip = vertreterToolTip.ToString();
            
            //< Separator Visibility = "{Binding Path=Row.SchoolString, Converter={StaticResource StringLengthVisibilityConverter}}" />

            //< TextBlock FontWeight = "Bold" Text = "Schule1:" Visibility = "{Binding Path=Row.SchoolString, Converter={StaticResource StringLengthVisibilityConverter}}" />

            //< TextBlock Text = "{Binding Row.SchoolString}" Visibility = "{Binding Path=Text, Converter={StaticResource StringLengthVisibilityConverter}, RelativeSource={RelativeSource Self}}" />


            //< Separator Visibility = "{Binding Path=Row.Customer.AddressString, Converter={StaticResource StringLengthVisibilityConverter}}" />

            //< TextBlock FontWeight = "Bold" Text = "Wohnort:" Visibility = "{Binding Path=Row.Customer.AddressString, Converter={StaticResource StringLengthVisibilityConverter}}" />

            //< TextBlock Text = "{Binding Row.Customer.AddressString}" />


            //< Separator Visibility = "{Binding Path=Row.CustomerContactInformationString, Converter={StaticResource StringLengthVisibilityConverter}}" />

            //< TextBlock FontWeight = "Bold" Text = "Kontakt:" Visibility = "{Binding Path=Row.CustomerContactInformationString, Converter={StaticResource StringLengthVisibilityConverter}}" />

            //< TextBlock Text = "{Binding Row.CustomerContactInformationString}" Visibility = "{Binding Path=Text, Converter={StaticResource StringLengthVisibilityConverter}, RelativeSource={RelativeSource Self}}" />


            //< Separator Visibility = "{Binding Path=Row.SchulbegleitenderDienstString, Converter={StaticResource StringLengthVisibilityConverter}}" />

            //< TextBlock FontWeight = "Bold" Text = "Schulbegleitender Dienst:" Visibility = "{Binding Path=Row.SchulbegleitenderDienstString, Converter={StaticResource StringLengthVisibilityConverter}}" />

            //< TextBlock Text = "{Binding Row.SchulbegleitenderDienstString}" Visibility = "{Binding Path=Text, Converter={StaticResource StringLengthVisibilityConverter}, RelativeSource={RelativeSource Self}}" />

        }

        private static void SetSubstitutionColor(VertretungsItemDC vertretungsItem)
        {
            switch (vertretungsItem.VertretungsStatus)
            {
                case VertretungsStatus.MaKrankVertretungBenoetigt:
                    vertretungsItem.KlientStatusColor = "#FF0000"; // Rot
                    break;
                case VertretungsStatus.MaKrankKeineVertretungBenoetigt:
                    vertretungsItem.KlientStatusColor = "#7FFF7F"; // Grün
                    break;
                case VertretungsStatus.KlientUndMitarbeiterKrank:
                    vertretungsItem.KlientStatusColor = "#7FFF7F"; // Grün
                    break;
                case VertretungsStatus.MaKrankVertretungVorhanden:
                    vertretungsItem.KlientStatusColor = "#7FFF7F"; // Grün
                    break;
                case VertretungsStatus.KlientKrank:
                    vertretungsItem.KlientStatusColor = "#FFFFA5"; // Gelb
                    break;
            }
        }

        private static void MigriereSubstitutionStatus(Customer customer)
        {
            if (customer != null)
            {
                if (customer.SubstitutionNeed == SubstitutionNeed.SubstitutionNeedUnset)
                {
                    if (customer.VertretungDringendErforderlich)
                    {
                        customer.SubstitutionNeed = SubstitutionNeed.SubstitutionNeeded;
                    }
                    else
                    {
                        customer.SubstitutionNeed = customer.VertretungGewuenscht ? SubstitutionNeed.SubstitutionWanted : SubstitutionNeed.NoSubstitutionWanted;
                    }
                }
                else
                {
                    customer.SubstitutionNeed = customer.SubstitutionNeed;
                }
            }
        }

        private static void SetTeamleitung(BeWoEntityBase employee, VertretungsItemDC item)
        {
            if (employee.Oid == null)
            {
                return;
            }

            var sb = new StringBuilder();
            var teams = DAOFactory.SearchDAO.FindTeamsOfEmployee(employee.Oid.Value);

            foreach (var team in teams)
            {
                if (team.Leader != null)
                {
                    if (sb.Length > 0)
                    {
                        sb.Append(", ");
                    }

                    sb.Append(team.Leader.Person.FirstNameLastName);
                }
            }

            item.Teamleitung = sb.ToString();
        }

        private static void SetzeSchule(VertretungsItemDC newItem, Customer customer)
        {
            if (customer != null)
            {
                foreach (var customer2Organisation in customer.Customer2OrganisationList)
                {
                    foreach (var valueListEntry2Object in customer2Organisation.ValueList)
                    {
                        if (valueListEntry2Object.Entry.Value != null && valueListEntry2Object.Entry.Value.Contains("Schule"))
                        {
                            newItem.Schule = MapperFactory.CompactOrganisationDC_Organisation.MapToNewDC(customer2Organisation.Organisation);

                            if (customer2Organisation.Organisation.Address != null)
                            {
                                newItem.Schule.Street = customer2Organisation.Organisation.Address.Street;
                                newItem.Schule.PostalCode = customer2Organisation.Organisation.Address.PostalCode;
                                newItem.Schule.Town = customer2Organisation.Organisation.Address.Town;
                            }
                        }
                    }
                }
            }
        }

        private static bool LiegtImZeitraum(DateTime dateTime, AbsenceTime absenceTime)
        {
            return absenceTime.Start < dateTime.Date.AddDays(1) && absenceTime.End >= dateTime.Date;
        }

        private static void AddKrankheitsZeitraumAndMeldungToItem(VertretungsItemDC item, AbsenceTimeDC absenceTime)
        {
            if (!absenceTime.Start.HasValue || !absenceTime.End.HasValue)
            {
                item.Krankheitszeitraum = absenceTime.Start.HasValue ? absenceTime.Start.Value.ToString("dd.MM.yyyy") : "Unbekannt";

                item.Krankheitszeitraum += " - ";

                if (absenceTime.End.HasValue)
                {
                    item.Krankheitszeitraum += absenceTime.End.Value.ToString("dd.MM.yyyy");
                }
                else
                {
                    item.Krankheitszeitraum += "Unbekannt";
                }
            }
            else
            {
                if (absenceTime.Start.Value.Date != absenceTime.End.Value.Date)
                {
                    if (absenceTime.Start.Value.Hour == 0 && absenceTime.Start.Value.Minute == 0 &&
                        absenceTime.End.Value.Hour == 0 && absenceTime.End.Value.Minute == 0)
                    {
                        item.Krankheitszeitraum = absenceTime.Start.Value.ToString("dd.MM.yyyy") + " - " + absenceTime.End.Value.ToString("dd.MM.yyyy");
                    }
                    else
                    {
                        item.Krankheitszeitraum = absenceTime.Start.Value.ToString("dd.MM.yyyy HH:mm") + " - " + absenceTime.End.Value.ToString("dd.MM.yyyy HH:mm");
                    }
                }
                else
                {
                    if (absenceTime.Start.Value.Hour == 0 && absenceTime.Start.Value.Minute == 0 &&
                        absenceTime.End.Value.Hour == 0 && absenceTime.End.Value.Minute == 0)
                    {
                        item.Krankheitszeitraum = absenceTime.Start.Value.ToString("dd.MM.yyyy");
                    }
                    else
                    {
                        item.Krankheitszeitraum = absenceTime.Start.Value.ToString("dd.MM.yyyy HH:mm") + " - " + absenceTime.End.Value.ToString("HH:mm");
                    }
                }
            }


            if (absenceTime.KrankheitsMeldung != null)
            {
                item.Krankheitsmeldung = absenceTime.KrankheitsMeldung.Value;
            }
            else if (absenceTime.Start.HasValue)
            {
                item.Krankheitsmeldung = absenceTime.Start.Value;
            }
        }

        private static bool GetIsSubstitutedCompletely(IEnumerable<ArbeitszeitEintrag> assistanceTimes, Vertretung substitution, DateTime dateTime)
        {
            var isSubstituted = true;

            foreach (var assistanceTime in assistanceTimes)
            {
                var assistanceDateTimes = DateTimeUtils.GetAssistanceTimeComparisonDateTime(assistanceTime.UhrzeitVon, assistanceTime.UhrzeitBis, dateTime);
                if (substitution.VertretungsZeitraumBis.Hour == 0 && substitution.VertretungsZeitraumBis.Minute == 0)
                {
                    substitution.VertretungsZeitraumBis = substitution.VertretungsZeitraumBis.AddDays(1).AddTicks(-1);
                }

                isSubstituted = assistanceDateTimes.Start.AreInBetweenDates(assistanceDateTimes.End, substitution.VertretungsZeitraumVon, substitution.VertretungsZeitraumBis);

                if (!isSubstituted)
                {
                    break;
                }
            }

            return isSubstituted;
        }

        private static void GetVertretungsstatus(VertretungsItemDC vertretungsItem, DateTime dateTime, DateTime absenceTimeStartDate, Customer customer)
        {
            MigriereSubstitutionStatus(customer);

            if (customer.SubstitutionNeed == SubstitutionNeed.SubstitutionNeeded)
            {
                vertretungsItem.VertretungsStatus = VertretungsStatus.MaKrankVertretungBenoetigt;
                vertretungsItem.Dringlichkeit = "Dringend";
                vertretungsItem.DringlichkeitColor = "#FF0000"; // rot
            } 
            else if (customer.SubstitutionNeed == SubstitutionNeed.SubstitutionWanted)
            {
                vertretungsItem.Dringlichkeit = "Möglichst";
                vertretungsItem.DringlichkeitColor = "#F3D04F"; // Senfgelb
            }
            else if (customer.SubstitutionNeed == SubstitutionNeed.NoSubstitutionWanted)
            {
                vertretungsItem.VertretungsStatus = VertretungsStatus.MaKrankKeineVertretungBenoetigt;
                vertretungsItem.Dringlichkeit = "Kein Vertretungsbedarf";
                vertretungsItem.DringlichkeitColor = "#FFFFFF"; // weiß
            }

            if (customer.AbWelchemKrankheitsTag > 1 && dateTime < absenceTimeStartDate.AddDays(customer.AbWelchemKrankheitsTag - 1))
            {
                vertretungsItem.VertretungsStatus = VertretungsStatus.MaKrankKeineVertretungBenoetigt;
                vertretungsItem.Dringlichkeit = $"Vertretung erst ab dem {customer.AbWelchemKrankheitsTag}.Tag benötigt";
                vertretungsItem.DringlichkeitColor = "#FFFFFF"; // weiß
            }

            if (customer.AbWelchemKrankheitsTag <= 1 && customer.SubstitutionNeed != SubstitutionNeed.SubstitutionWanted && customer.SubstitutionNeed != SubstitutionNeed.SubstitutionNeeded)
            {
                vertretungsItem.VertretungsStatus = VertretungsStatus.MaKrankKeineVertretungBenoetigt;
            }
        }

        private static string GetEmployeeAddressInfo(long employeeOid)
        {
            var result = string.Empty;

            var employee = DAOFactory.GenericDAO.LoadByID<Employee>(employeeOid);

            var address = employee.Person.Address;

            if (address != null)
            {
                var addressInfo = string.Empty;

                addressInfo += employee.Person.LastNameFirstName;

                if (!string.IsNullOrWhiteSpace(address.Street))
                {
                    if (addressInfo.Length > 0)
                    {
                        addressInfo += "\n\n";
                    }

                    addressInfo += address.Street;
                }

                if (!string.IsNullOrWhiteSpace(address.PostalCode))
                {
                    if (addressInfo.Length > 0)
                    {
                        addressInfo += "\n";
                    }

                    addressInfo += address.PostalCode;
                }

                if (!string.IsNullOrWhiteSpace(address.Town))
                {
                    if (addressInfo.Length > 0)
                    {
                        addressInfo += " ";
                    }

                    addressInfo += address.Town;
                }

                result = addressInfo;
            }

            return result;
        }

        private static bool IsAbsenceTimeInAssistanceTime(DateTime currentDate, ArbeitszeitEintrag assistanceTime, AbsenceTime absenceTime)
        {
            if (currentDate.DayOfWeek != DateTimeUtils.ConvertAppointmentDayOfWeekToDayOfWeek(assistanceTime.Tag) || absenceTime.Start == null)
            {
                return false;
            }

            var assistanceTimeDates = DateTimeUtils.GetAssistanceTimeComparisonDateTime(assistanceTime.UhrzeitVon, assistanceTime.UhrzeitBis, currentDate);

            var absenceTimeEnd = absenceTime.End;

            if (absenceTimeEnd.HasValue && absenceTimeEnd.Value.Hour == 0 && absenceTimeEnd.Value.Minute == 0)
            {
                absenceTimeEnd = absenceTimeEnd.Value.AddHours(23).AddMinutes(59).AddSeconds(59);
            }

            return assistanceTimeDates.Start.IsIntervalOverlappingWithAbsenceTimeInterval(assistanceTimeDates.End, absenceTime.Start.Value, absenceTimeEnd);
        }

        private static bool IsAbsenceTimeInAssistanceTime(DateTime currentDate, ArbeitszeitEintragDC assistanceTime, AbsenceTime absenceTime)
        {
            if (currentDate.DayOfWeek != DateTimeUtils.ConvertAppointmentDayOfWeekToDayOfWeek(assistanceTime.Tag) || absenceTime.Start == null)
            {
                return false;
            }

            var assistanceTimeDates = DateTimeUtils.GetAssistanceTimeComparisonDateTime(assistanceTime.UhrzeitVon, assistanceTime.UhrzeitBis, currentDate);

            var absenceTimeEnd = absenceTime.End;

            //if (absenceTimeEnd.HasValue && absenceTime.Start.Value.Equals(absenceTimeEnd.Value))
            //{
            //    absenceTimeEnd = absenceTimeEnd.Value.AddHours(23).AddMinutes(59).AddSeconds(59);
            //}
            if (absenceTimeEnd.HasValue && absenceTimeEnd.Value.Hour == 0 && absenceTimeEnd.Value.Minute == 0 && absenceTimeEnd.Value.Second == 0)
            {
                absenceTimeEnd = absenceTimeEnd.Value.Date.AddHours(23).AddMinutes(59).AddSeconds(59);
            }

            return assistanceTimeDates.Start.IsIntervalOverlappingWithAbsenceTimeInterval(assistanceTimeDates.End, absenceTime.Start.Value, absenceTimeEnd);
        }

        private static List<ArbeitszeitEintrag> GetAssistanceTimesForCustomer(Customer customer, Employee employee, AbsenceTime absenceTime, DateTime start, DateTime end)
        {
            var assistanceTimeEntries = new List<ArbeitszeitEintrag>();

            var allSchoolAssistanceTimes = new List<Arbeitszeit>();
            var allCustomerAssistanceTimes = new List<Arbeitszeit>();

            var schoolAssistanceTimes = new List<Arbeitszeit>();
            var customerAssistanceTimes = new List<Arbeitszeit>();

            var hasSchoolAssistanceTimes = customer.Customer2OrganisationList.Any(a => a.ValueList.Any(b => b.Entry.Type == ValueListEntryType.EnvironmentOrganisationType && b.Entry.Value.Equals("Schule")));
            if (hasSchoolAssistanceTimes)
            {
                var school = customer.Customer2OrganisationList.FirstOrDefault(f => f.ValueList.Any(b => b.Entry.Type == ValueListEntryType.EnvironmentOrganisationType && b.Entry.Value.Equals("Schule")));
                if (school != null)
                {
                    allSchoolAssistanceTimes.AddRange(school.Organisation.Arbeitszeiten);
                }
            }

            var hasAssistanceTimes = customer.Arbeitszeiten?.Count > 0;
            if (hasAssistanceTimes)
            {
                allCustomerAssistanceTimes.AddRange(customer.Arbeitszeiten);
            }

            var dateTime = start;
            while (dateTime <= end)
            {
                if (LiegtImZeitraum(dateTime, absenceTime))
                {
                    customerAssistanceTimes.AddRange(allCustomerAssistanceTimes.Where(w => IsArbeitszeitValid(w, dateTime)));

                    schoolAssistanceTimes.AddRange(allSchoolAssistanceTimes.Where(w => IsArbeitszeitValid(w, dateTime)));
                }

                dateTime = dateTime.AddDays(1);
            }

            if (customerAssistanceTimes.Count > 0)
            {
                customerAssistanceTimes.DoForEach(assistanceTime => assistanceTimeEntries.AddRange(assistanceTime.ArbeitszeitEintraege.Where(entry => entry.Employee == null || entry.Employee.Equals(employee))));
            }
            else
            {
                schoolAssistanceTimes.DoForEach(assistanceTime => assistanceTimeEntries.AddRange(assistanceTime.ArbeitszeitEintraege.Where(entry => entry.Employee == null || entry.Employee.Equals(employee))));
            }

            return assistanceTimeEntries;
        }

        private static bool IsArbeitszeitValid(Arbeitszeit arbeitszeit, DateTime time)
        {
            if (arbeitszeit.GueltigVon == null && arbeitszeit.GueltigBis == null)
            {
                return true;
            }

            if (arbeitszeit.GueltigVon.HasValue && arbeitszeit.GueltigBis.HasValue)
            {
                return time.InBetween(arbeitszeit.GueltigVon.Value, arbeitszeit.GueltigBis.Value, true);
            }

            if (arbeitszeit.GueltigVon == null && arbeitszeit.GueltigBis.HasValue)
            {
                return time <= arbeitszeit.GueltigBis;
            }

            if (arbeitszeit.GueltigBis == null)
            {
                return time >= arbeitszeit.GueltigVon;
            }

            return false;
        }

        private static List<Arbeitszeit> GetSchoolAssistanceTimes(Customer customer, DateTime start, DateTime end, AbsenceTime absenceTime)
        {
            var allSchoolAssistanceTimes = new List<Arbeitszeit>();

            var schoolAssistanceTimes = new List<Arbeitszeit>();

            var hasSchoolAssistanceTimes = customer.Customer2OrganisationList.Any(a => a.ValueList.Any(b => b.Entry.Type == ValueListEntryType.EnvironmentOrganisationType && b.Entry.Value.Equals("Schule")));
            if (hasSchoolAssistanceTimes)
            {
                var school = customer.Customer2OrganisationList.FirstOrDefault(f => f.ValueList.Any(b => b.Entry.Type == ValueListEntryType.EnvironmentOrganisationType && b.Entry.Value.Equals("Schule")));
                if (school != null)
                {
                    allSchoolAssistanceTimes.AddRange(school.Organisation.Arbeitszeiten);
                }
            }

            var dateTime = start;
            while (dateTime <= end)
            {
                if (LiegtImZeitraum(dateTime, absenceTime))
                {
                    schoolAssistanceTimes.AddRange(allSchoolAssistanceTimes.Where(w => IsArbeitszeitValid(w, dateTime)));
                }

                dateTime = dateTime.AddDays(1);
            }

            return schoolAssistanceTimes;
        }
    }
}