using System;
using System.Collections.Generic;
using System.Linq;
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.Extensions;
using BS.Shared.Services;

namespace BeWo.Service.Plugins
{
    public class ServiceRecordStatisticFactory : AbstractIDSpecificDefaultClass<ServiceRecordStatisticFactory>
    {
        public virtual ServiceRecordStatisticsInfoDC GetServiceRecordStatisticInfo(long costBearer2SupportConceptOid, DateTime statisticsDate)
        {
            if (!UseFlexibleView()) // AB, 17.12.2025: alter Standard: Kein umswitchen erwünscht -> nur Wochenansicht
            {
                return null;
            }

            // Monatsansicht wird nur gewählt, wenn ausschließlich Bewilligungen mit Monatsstunden vorhanden sind
            var c2s = DAOFactory.GenericDAO.LoadByID<CostBearer2SupportConcept>(costBearer2SupportConceptOid);
            if (c2s.ApprovalPeriodList.Any(scap => scap.ApprovedBEInterval.HasValue && scap.ApprovedBEInterval.Value == SupportConceptApprovalInterval.Monthly) &&
            !c2s.ApprovalPeriodList.Any(scap => scap.ApprovedBEInterval.HasValue && scap.ApprovedBEInterval.Value == SupportConceptApprovalInterval.Weekly))
            {
                var stats = CreateSupportConceptStatisticsImpl(costBearer2SupportConceptOid, statisticsDate);
                var dc = new ServiceRecordStatisticsInfoDC();
                dc.Header = new string[4];
                dc.Header[0] = "Bewilligungszeitraum:";
                dc.Header[1] = "Geleistet diesen Monat/Gesamt:";
                dc.Header[2] = "Bewilligt diesen Monat/Gesamt:";
                dc.Header[3] = "Frei diesen Monat/Gesamt:";

                dc.ForegroundColor = new string[4];
                dc.ForegroundColor[0] = "#FF2B508B";
                dc.ForegroundColor[1] = "#FF2B508B";
                dc.ForegroundColor[2] = "#FF2B508B";
                dc.ForegroundColor[3] = "#FF2B508B";

                dc.PeriodStatisticInfos = new List<ServiceRecordPeriodStatisticsInfoDC>();
                if (stats != null)
                {
                    if (stats.PeriodStatistics.Count > 1 && !TimeSpanIsEqual(stats))
                        dc.PeriodStatisticInfos.Add(CreateMonthTotalStatistics(stats, statisticsDate));

                    foreach (var pdc in stats.PeriodStatistics)
                    {
                        dc.PeriodStatisticInfos.Add(CreateServiceRecordPeriodMonthStatisticsInfo(stats, pdc, statisticsDate));
                    }
                }

                return dc;
            }
            else
            {
                return null;
            }
        }

        private ServiceRecordPeriodStatisticsInfoDC CreateServiceRecordPeriodMonthStatisticsInfo(SupportConceptStatisticsDC stats, SupportConceptPeriodStatisticsDC periodStats, DateTime statisticsDate)
        {
            var dc = CreateDefaultServiceRecordPeriodStatisticsInfo(4);

            if (periodStats.SupportConceptApprovalPeriod != null)
            {
                if (periodStats.SupportConceptApprovalPeriod.ServiceCategory != null)
                {
                    dc.LeftValues[0] = String.Format("{0}: {1:dd.MM.yy} - {2:dd.MM.yy}",
                                                      periodStats.SupportConceptApprovalPeriod.ServiceCategory.Name,
                                                      periodStats.SupportConceptApprovalPeriod.StartDate,
                                                      periodStats.SupportConceptApprovalPeriod.EndDate);
                }
                else
                {
                    dc.LeftValues[0] = String.Format("{0:dd.MM.yy} - {1:dd.MM.yy}",
                                                   periodStats.SupportConceptApprovalPeriod.StartDate,
                                                   periodStats.SupportConceptApprovalPeriod.EndDate);
                }
            }

            dc.LeftValues[1] = String.Format("{0:0.00}", periodStats.MinutesProvidedThisMonth / 60);
            dc.RightValues[1] = String.Format("{0:0.00}", periodStats.MinutesProvidedTotalRounded / 60);

            dc.LeftValues[2] = String.Format("{0:0.00}", periodStats.MinutesApprovedPerMonth / 60);
            dc.RightValues[2] = String.Format("{0:0.00}", periodStats.MinutesApprovedTotal / 60);

            dc.LeftValues[3] = String.Format("{0:0.00}", (periodStats.MinutesApprovedPerMonth - periodStats.MinutesProvidedThisMonth) / 60);
            dc.RightValues[3] = String.Format("{0:0.00}", (periodStats.MinutesApprovedTotal - periodStats.MinutesProvidedTotalRounded) / 60);


            return dc;
        }

        public virtual ServiceRecordPeriodStatisticsInfoDC CreateMonthTotalStatistics(SupportConceptStatisticsDC stats, DateTime statisticsDate)
        {
            var dc = CreateDefaultServiceRecordPeriodStatisticsInfo(4);
            dc.LeftValues[0] = "Gesamt";

            dc.LeftValues[1] = String.Format("{0:0.00}", stats.MinutesProvidedThisMonth / 60);
            dc.RightValues[1] = String.Format("{0:0.00}", stats.MinutesProvidedTotalRounded / 60);

            dc.LeftValues[2] = String.Format("{0:0.00}", stats.MinutesApprovedPerMonth / 60);
            dc.RightValues[2] = String.Format("{0:0.00}", stats.MinutesApprovedTotal / 60);

            dc.LeftValues[3] = String.Format("{0:0.00}", (stats.MinutesApprovedPerMonth - stats.MinutesProvidedThisMonth) / 60);
            dc.RightValues[3] = String.Format("{0:0.00}", (stats.MinutesApprovedTotal - stats.MinutesProvidedTotalRounded) / 60);

            return dc;
        }

        public virtual bool UseFlexibleView()
        {
            return true;
        }

        public virtual SupportConceptStatisticsDC CreateSupportConceptStatistics(long costBearer2SupportConceptOid, DateTime statisticsDate)
        {
            return CreateSupportConceptStatisticsImpl(costBearer2SupportConceptOid, statisticsDate);
        }

        public virtual SupportConceptStatisticsDC CreateSupportConceptStatisticsImpl(long costBearer2SupportConceptOid, DateTime statisticsDate)
        {
            return CreateSupportConceptStatisticsImpl(costBearer2SupportConceptOid, statisticsDate, null);
        }

        public virtual SupportConceptStatisticsDC CreateSupportConceptStatisticsImpl(long costBearer2SupportConceptOid, DateTime statisticsDate, long? ignoreServiceRecordOid)
        {

            var stats = new SupportConceptStatisticsDC();
            stats.PeriodStatistics = new List<SupportConceptPeriodStatisticsDC>();
            stats.DateOfCreation = statisticsDate;

            var cb2sc = DAOFactory.GenericDAO.LoadByID<CostBearer2SupportConcept>(costBearer2SupportConceptOid);
            if (cb2sc.SupportConcept.Customer.Person.FirstName == "Ilona ")
            {
                int test = 0;
            }
            var relDc = CreateCb2ScDC(cb2sc);
            var calc = PluginLoader.FindClass<Calculations>(cb2sc.CostBearer.ID) ?? Calculations.GetInstance(cb2sc.CostBearer.ID);

            stats.StatisticsStartDate = relDc.StartDate ?? DateTime.MinValue;
            stats.StatisticsEndDate = relDc.EndDate ?? DateTime.MaxValue;

            var serviceUnit = relDc.CostBearer.CostRatePeriods.GetCostRatePeriodForDate(CostRatePeriodType.MinutesPerServiceUnit, statisticsDate);
            stats.ServiceUnitName = serviceUnit.UnitName;

            var minutesApprovedTotal = (calc.GetApprovedHoursTotal(relDc, true) ?? 0m) * 60m;
            stats.MinutesApprovedTotal = minutesApprovedTotal;
            stats.MinutesApprovedPerWeek = (calc.GetApprovedHoursPerWeek(relDc, statisticsDate) ?? 0m) * 60m;
            stats.ApprovedMinutesTillNow = calc.GetApprovedHoursTillNow(relDc, statisticsDate) * 60m;

            // Hier die Periods zusammenfassen, die identische Zeiträume und identische Leistungskategorien haben.
            foreach (var periodDC in relDc.ApprovalPeriodList)
            {
                var periodStats = CreatePeriodStatisticsDC(relDc, periodDC, calc, statisticsDate);

                // Wenn Bewilligungdatum und Leistungskategorie identisch ist sollen die Statistiken zusammengefasst werden, anstatt getrennt ausgeschrieben
                if (periodDC.StartDate != null && periodDC.EndDate != null)
                {
                    var vorhandeneStatistik = stats.PeriodStatistics != null && stats.PeriodStatistics.Count > 0 ?
                    stats.PeriodStatistics.FirstOrDefault(ps => periodDC.StartDate >= ps.SupportConceptApprovalPeriod.StartDate &&
                    periodDC.EndDate <= ps.SupportConceptApprovalPeriod.EndDate && ps.SupportConceptApprovalPeriod.ServiceCategory == periodDC.ServiceCategory) : null;

                    if (vorhandeneStatistik != null)
                    {
                        vorhandeneStatistik = SummarizeStats(vorhandeneStatistik, periodStats);
                    }
                    else
                    {
                        stats.PeriodStatistics.Add(periodStats);
                    }
                }
                else
                {
                    stats.PeriodStatistics.Add(periodStats);
                }
            }

            SortStatistics(stats);
            var serviceRecords = GetServiceRecordsForStatistic(costBearer2SupportConceptOid);
            var serviceRecordsProcessed = new Dictionary<long, bool>();
            if (ignoreServiceRecordOid.HasValue)
            {
                serviceRecordsProcessed.Add(ignoreServiceRecordOid.Value, true);
            }

            foreach (var sr in serviceRecords)
            {
                if (!serviceRecordsProcessed.ContainsKey(sr.Oid.Value))
                {
                    ProcessServiceRecord(sr, cb2sc, stats, statisticsDate, calc);
                    serviceRecordsProcessed.Add(sr.Oid.Value, true);
                }
            }


            if (relDc.EndDate.HasValue)
            {
                DateTime dt = statisticsDate.Date;
                if (relDc.StartDate.HasValue && relDc.StartDate > dt)
                {
                    dt = relDc.StartDate.Value;
                }

                TimeSpan ts = relDc.EndDate.Value.Subtract(dt);
                int days = ts.Days + 1;
                if (days > 0)
                {
                    stats.MinutesFreePerWeekAverage = (stats.MinutesApprovedTotal - stats.MinutesProvidedTotalRounded) / (days / 7m);

                    foreach (var ps in stats.PeriodStatistics)
                    {
                        if (ps.SupportConceptApprovalPeriod.StartDate.HasValue && ps.SupportConceptApprovalPeriod.EndDate.HasValue)
                        {
                            DateTime dtPeriod = statisticsDate.Date;
                            if (ps.SupportConceptApprovalPeriod.StartDate.HasValue && ps.SupportConceptApprovalPeriod.StartDate > dtPeriod)
                            {
                                dtPeriod = ps.SupportConceptApprovalPeriod.StartDate.Value;
                            }
                            TimeSpan tsPeriod = ps.SupportConceptApprovalPeriod.EndDate.Value.Subtract(dtPeriod);
                            int daysPeriod = tsPeriod.Days + 1;
                            if (daysPeriod < 0)
                            {
                                daysPeriod = 0;
                            }
                            // Standard - Stunden für ausgewähltes Intervall x/Woche etce
                            if (ps.SupportConceptApprovalPeriod.ApprovedBEPerInterval != null)
                            {
                                if (ps.SupportConceptApprovalPeriod.IsApprovedBEShifting) // Standardfall - Übertragbare Bewilligung mit Stunden für ausgewähltes Intervall x/Woche etc
                                {
                                    if (daysPeriod != 0)
                                    {
                                        ps.MinutesFreePerWeek = (ps.MinutesApprovedTotal - ps.MinutesProvidedTotalRounded) / (daysPeriod / 7m);
                                        ps.MinutesFreePerWeekStatisticDate = (ps.MinutesApprovedTotal - ps.IstTotalUntilThisMonth - ps.MinutesProvidedThisMonth) / (daysPeriod / 7m);
                                        ps.MinutesFreePerMonth = (ps.MinutesApprovedTotal - ps.MinutesProvidedTotalRounded) / (daysPeriod / 7m) * (365m / 84m);
                                        ps.MinutesFreePerMonthStatisticDate = (ps.MinutesApprovedTotal - ps.IstTotalUntilThisMonth - ps.MinutesProvidedThisMonth) / (daysPeriod / 7m) * (365m / 84m);
                                    }
                                    else // Bewilligung ist abgelaufen
                                    {
                                        ps.MinutesFreePerWeek = ps.MinutesApprovedTotal - ps.MinutesProvidedTotalRounded;
                                        ps.MinutesFreePerWeekStatisticDate = ps.MinutesApprovedTotal - ps.MinutesProvidedTotalRounded;
                                        ps.MinutesFreePerMonth = ps.MinutesApprovedTotal - ps.MinutesProvidedTotalRounded;
                                        ps.MinutesFreePerMonthStatisticDate = ps.MinutesApprovedTotal - ps.MinutesProvidedTotalRounded;
                                    }
                                }
                                else if (ps.SupportConceptApprovalPeriod.ApprovedBEInterval == SupportConceptApprovalInterval.Weekly)
                                {
                                    ps.MinutesFreePerWeek = ps.MinutesApprovedPerWeek - ps.MinutesProvidedThisWeek;
                                    ps.MinutesFreePerWeekStatisticDate = ps.MinutesFreePerWeek;
                                    // den Wert pro Monat auszurechnen macht überhaupt keinen Sinn, da ich nur die angefangenen Std diese Woche kenne
                                    // Rest wäre dann theoretisch Stunden * Anzahl der ganzen Wochen....
                                    ps.MinutesFreePerMonth = ps.MinutesApprovedPerMonth - ps.MinutesProvidedThisMonth;
                                    ps.MinutesFreePerMonthStatisticDate = ps.MinutesFreePerMonth;
                                }
                                else if (ps.SupportConceptApprovalPeriod.ApprovedBEInterval == SupportConceptApprovalInterval.Monthly)
                                {
                                    ps.MinutesFreePerMonth = ps.MinutesApprovedPerMonth - ps.MinutesProvidedThisMonth;
                                    ps.MinutesFreePerMonthStatisticDate = ps.MinutesFreePerMonth;
                                    ps.MinutesFreePerWeek = ps.MinutesFreePerMonth / 4.33m;
                                    ps.MinutesFreePerWeekStatisticDate = ps.MinutesFreePerWeek;
                                }
                            }
                            else if (ps.SupportConceptApprovalPeriod.ApprovedBETotal != null) // Gesamtbewilligung für einen beliebigen Zeitraum
                            {
                                decimal freeRest = ps.MinutesApprovedTotal - ps.MinutesProvidedTotalRounded;
                                if (daysPeriod != 0 && daysPeriod != 1)
                                {
                                    ps.MinutesFreePerWeek = freeRest / (daysPeriod / 7m);
                                    ps.MinutesFreePerWeekStatisticDate = (ps.MinutesApprovedTotal - ps.IstTotalUntilThisMonth - ps.MinutesProvidedThisMonth) / (daysPeriod / 7m);
                                    ps.MinutesFreePerMonthStatisticDate = (ps.MinutesApprovedTotal - ps.IstTotalUntilThisMonth - ps.MinutesProvidedThisMonth) / (daysPeriod / 7m) * (365m / 84m);
                                    ps.MinutesFreePerMonth = freeRest / (daysPeriod / 7m) * (365m / 84m);

                                }
                                else // Bewilligung ist abgelaufen
                                {
                                    ps.MinutesFreePerWeek = freeRest;
                                    ps.MinutesFreePerMonth = freeRest;
                                }
                            }
                        }

                        decimal freeTotalPeriod = ps.MinutesApprovedTotal - ps.MinutesProvidedTotalRounded;
                        if (ps.MinutesFreePerWeek > freeTotalPeriod)
                        {
                            ps.MinutesFreePerWeek = freeTotalPeriod;
                        }
                        if (ps.MinutesFreePerWeek < 0)
                        {
                            ps.MinutesFreePerWeek = 0;
                        }
                        if (ps.MinutesFreePerMonth > freeTotalPeriod)
                        {
                            ps.MinutesFreePerMonth = freeTotalPeriod;
                        }
                        if (ps.MinutesFreePerMonth < 0)
                        {
                            ps.MinutesFreePerMonth = 0;
                        }
                    }
                }
            }
            decimal freeTotal = stats.MinutesApprovedTotal - stats.MinutesProvidedTotalRounded;
            if (stats.MinutesFreePerWeekAverage > freeTotal)
            {
                stats.MinutesFreePerWeekAverage = freeTotal;
            }
            if (stats.MinutesFreePerWeekAverage < 0)
            {
                stats.MinutesFreePerWeekAverage = 0;
            }


            //Berechne bewilligte Stunden pro Monat und Soll
            stats.MinutesApprovedPerMonth = GetApprovedMinutesPerMonth(stats);
            if (relDc.StartDate.HasValue && relDc.EndDate.HasValue)
            {
                DateTime max = statisticsDate < relDc.EndDate.Value ? statisticsDate : relDc.EndDate.Value;
                DateTime s = relDc.StartDate.Value;
                decimal monthsUntilNow = 0;

                if (s.Day == 1)
                {
                    while ((s = s.AddMonths(1)) < max)
                    {
                        monthsUntilNow++;
                    }

                    stats.SollTotalUntilThisMonth = stats.MinutesApprovedPerMonth * monthsUntilNow;
                }
                else
                {
                    DateTime nextMonth = s.AddMonths(1);
                    nextMonth = new DateTime(nextMonth.Year, nextMonth.Month, 1);

                    if (nextMonth <= max)
                    {
                        monthsUntilNow = (decimal)nextMonth.Subtract(s).TotalDays / DateTime.DaysInMonth(s.Year, s.Month);
                    }

                    while ((nextMonth = nextMonth.AddMonths(1)) < max)
                    {
                        monthsUntilNow++;
                    }

                    stats.SollTotalUntilThisMonth = stats.MinutesApprovedPerMonth * (decimal)monthsUntilNow;
                }
            }

            return stats;
        }

        protected virtual IEnumerable<ServiceRecord> GetServiceRecordsForStatistic(long costBearer2SupportConceptOid)
        {
            return DAOFactory.SearchDAO.FindServiceRecordsDetailsForLastDays(costBearer2SupportConceptOid, null);
        }

        protected virtual void ProcessServiceRecord(ServiceRecord sr, CostBearer2SupportConcept cb2sc, SupportConceptStatisticsDC stats, DateTime statisticsDate, Calculations calc)
        {
            decimal minutesProvided = 0;
            decimal minutesProvidedRounded = 0;
            decimal minutesProvidedThisWeek = 0;
            decimal minutesProvidedThisMonth = 0;
            decimal minutesProvidedUntilLastMonth = 0;

            bool billable = false;
            if (sr.ServiceDescription != null && sr.ServiceDescription.ServiceCategory != null)
            {
                billable = sr.ServiceDescription.ServiceCategory.IsBillable;
            }

            bool outOfPeriod = true;
            if (cb2sc.StartDate.HasValue && cb2sc.EndDate.HasValue)
            {
                outOfPeriod = false;
                DateTime end = cb2sc.EndDate.Value;
                if (end < DateTime.MaxValue.Date)
                    end = end.AddDays(1);
                if (sr.Start < cb2sc.StartDate || sr.Start >= end)
                {
                    outOfPeriod = true;
                }
            }

            SupportConceptPeriodStatisticsDC periodStats =
                GetPeriodDCFromServiceRecord(stats.PeriodStatistics, sr);


            if (billable || (periodStats != null && periodStats.SupportConceptApprovalPeriod.ServiceCategory != null))
            {
                minutesProvided = (decimal)sr.DurationMinutes;

                if (!billable && periodStats.SupportConceptApprovalPeriod.ServiceCategory != null &&
                    !periodStats.SupportConceptApprovalPeriod.ServiceCategory.IsBillable)
                {
                    minutesProvidedRounded = minutesProvided;
                }
                else
                {
                    var srDc = MapToServiceRecordDCForStatistic(sr);
                    minutesProvidedRounded = calc.GetBillableDurationInMinutes(srDc, false);
                    if (periodStats != null)
                    {

                        if (periodStats.ServiceRecords == null)
                        {
                            periodStats.ServiceRecords = new List<ServiceRecordDC>();
                        }
                        periodStats.ServiceRecords.Add(srDc);
                    }
                }


                var firstOfMonthDt = new DateTime(statisticsDate.Year, statisticsDate.Month, 1);
                DateTime mondayDt = statisticsDate.GetLast(DayOfWeek.Monday).Date;
                DateTime sundayDt = statisticsDate.GetNext(DayOfWeek.Sunday).Date;

                if (sr.Start >= mondayDt && sr.Start < mondayDt.AddDays(7))
                {
                    minutesProvidedThisWeek = minutesProvidedRounded;
                }
                if (sr.Start >= firstOfMonthDt && sr.Start < firstOfMonthDt.AddMonths(1))
                {
                    minutesProvidedThisMonth = minutesProvidedRounded;
                }
                if (sr.Start >= stats.StatisticsStartDate && sr.Start < firstOfMonthDt)
                {
                    minutesProvidedUntilLastMonth += minutesProvidedRounded;
                }

                CalculateFixedAmountBudget(sr, periodStats, statisticsDate);


            }

            if (outOfPeriod)
            {
                stats.MinutesOutOfApprovedPeriod += minutesProvidedRounded;
            }
            stats.MinutesProvidedTotal += minutesProvided;
            stats.MinutesProvidedTotalRounded += minutesProvidedRounded;
            stats.MinutesProvidedThisMonth += minutesProvidedThisMonth;
            stats.IstTotalUntilThisMonth += minutesProvidedUntilLastMonth;
            stats.MinutesProvidedThisWeek += minutesProvidedThisWeek;


            if (periodStats != null)
            {
                if (outOfPeriod)
                {
                    periodStats.MinutesOutOfApprovedPeriod += minutesProvidedRounded;
                }

                periodStats.MinutesProvidedTotal += minutesProvided;
                periodStats.MinutesProvidedTotalRounded += minutesProvidedRounded;
                periodStats.MinutesProvidedThisWeek += minutesProvidedThisWeek;
                periodStats.MinutesProvidedThisMonth += minutesProvidedThisMonth;
                periodStats.IstTotalUntilThisMonth += minutesProvidedUntilLastMonth;
            }
        }

        protected virtual void CalculateFixedAmountBudget(ServiceRecord sr, SupportConceptPeriodStatisticsDC periodStats, DateTime statisticsDate)
        {
            //do nothing... Es wird kein fixes Budget im Standard berechnet
        }

        protected virtual void SortStatistics(SupportConceptStatisticsDC stats)
        {
            stats.PeriodStatistics.Sort((p1, p2) =>
            {
                int c = 0;
                if (p1.SupportConceptApprovalPeriod.StartDate.HasValue && p2.SupportConceptApprovalPeriod.StartDate.HasValue)
                {
                    c = p1.SupportConceptApprovalPeriod.StartDate.Value.CompareTo(p2.SupportConceptApprovalPeriod.StartDate.Value);
                }

                if (c == 0 && p1.SupportConceptApprovalPeriod.ServiceCategory != null && p2.SupportConceptApprovalPeriod.ServiceCategory != null)
                    c =
                        p1.SupportConceptApprovalPeriod.ServiceCategory.Name.CompareTo(
                            p2.SupportConceptApprovalPeriod.ServiceCategory.Name);
                return c;
            });

        }

        protected virtual SupportConceptPeriodStatisticsDC CreatePeriodStatisticsDC(SupportConceptCostBearerRelDC relDc, SupportConceptApprovalPeriodDC periodDC, Calculations calc, DateTime statisticsDate)
        {
            var periodStats = new SupportConceptPeriodStatisticsDC();
            periodStats.SupportConceptApprovalPeriod = periodDC;


            periodStats.MinutesApprovedTotal = (calc.GetApprovedHoursForPeriod(relDc, periodDC, relDc.CostBearer.CostRatePeriods, periodDC.StartDate, periodDC.EndDate, true) ?? 0m) * 60m;
            periodStats.MinutesApprovedPerWeek = (calc.GetApprovedHoursPerWeek(relDc, periodDC, relDc.CostBearer.CostRatePeriods, true) ?? 0m) * 60m;
            periodStats.ApprovedMinutesTillNow = calc.GetApprovedHoursTillNow(periodDC, relDc.CostBearer.CostRatePeriods, statisticsDate, relDc.CostBearer.IsCalculatingWithFactor) * 60m;

            if (periodStats.MinutesApprovedPerWeek == 0 && relDc.EndDate.HasValue &&
                relDc.EndDate < statisticsDate)
            {
                periodStats.MinutesApprovedPerWeek =
                    calc.GetApprovedHoursPerWeek(relDc, relDc.EndDate.Value) ?? 0m;
            }

            periodStats.MinutesApprovedPerMonth = GetApprovedMinutesPerMonth(periodStats);

            if (periodDC.StartDate.HasValue && periodDC.EndDate.HasValue)
            {
                DateTime periodEnd = periodDC.EndDate.Value;
                if (periodEnd < DateTime.MaxValue)
                {
                    periodEnd = periodEnd.AddDays(1);
                }
                DateTime max = statisticsDate < periodEnd ? statisticsDate : periodEnd;
                DateTime s = periodDC.StartDate.Value;

                decimal monthsUntilNow = 0;

                if (s.Day == 1)
                {
                    while ((s = s.AddMonths(1)) <= max)
                    {
                        monthsUntilNow++;
                    }

                    periodStats.SollTotalUntilThisMonth = periodStats.MinutesApprovedPerMonth * monthsUntilNow;
                }
                else
                {
                    DateTime nextMonth = s.AddMonths(1);
                    nextMonth = new DateTime(nextMonth.Year, nextMonth.Month, 1);

                    if (nextMonth <= max)
                    {
                        monthsUntilNow = (decimal)nextMonth.Subtract(s).TotalDays / DateTime.DaysInMonth(s.Year, s.Month);
                    }
                    while ((nextMonth = nextMonth.AddMonths(1)) < max)
                    {
                        monthsUntilNow++;
                    }

                    periodStats.SollTotalUntilThisMonth = periodStats.MinutesApprovedPerMonth * (decimal)monthsUntilNow;

                }

            }

            return periodStats;
        }

        protected virtual SupportConceptCostBearerRelDC CreateCb2ScDC(CostBearer2SupportConcept cb2sc)
        {
            var pDataContract = new SupportConceptCostBearerRelDC();

            if (cb2sc.CostBearer.Organisation != null)
            {
                pDataContract.CostBearer =
                    MapperFactory.CompactOrganisationDC_Organisation.MapToNewDC(cb2sc.CostBearer.Organisation);
            }

            pDataContract.CostBearer2SupportConceptOid = cb2sc.Oid;
            pDataContract.CostBearer2SupportConceptVersion = cb2sc.Version;
            pDataContract.Notice = cb2sc.Notice;
            pDataContract.Status = cb2sc.Status;
            //pDataContract.SupportConcept =
            //    MapperFactory.CompactSupportConceptDC_SupportConcept.MapToNewDC(pEntity.SupportConcept);

            pDataContract.RequestedStartDate = cb2sc.RequestedStartDate;
            pDataContract.RequestedEndDate = cb2sc.RequestedEndDate;
            pDataContract.ApprovedStartDate = cb2sc.ApprovedStartDate;
            pDataContract.ApprovedEndDate = cb2sc.ApprovedEndDate;
            pDataContract.CustomerReferenceNumber = cb2sc.CustomerReferenceNumber;

            pDataContract.MonthlyPayment = cb2sc.MonthlyPayment;

            //if (cb2sc.CostBearerContactPerson != null)
            //    pDataContract.CostBearerContactPerson =
            //        MapperFactory.CompactPersonDC_Person.MapToNewDC(cb2sc.CostBearerContactPerson);
            pDataContract.ApprovalPeriodList =
                MapperFactory.SupportConceptApprovalPeriodDC_SupportConceptApprovalPeriod.MapToNewDCs(
                    cb2sc.ApprovalPeriodList);
            if (pDataContract.ApprovalPeriodList != null)
            {
                foreach (var item in pDataContract.ApprovalPeriodList)
                {
                    if (!item.StartDate.HasValue)
                    {
                        item.StartDate = cb2sc.ApprovedStartDate.HasValue
                                             ? cb2sc.ApprovedStartDate
                                             : cb2sc.RequestedStartDate;
                    }
                    if (!item.EndDate.HasValue)
                    {
                        item.EndDate = cb2sc.ApprovedEndDate.HasValue
                                           ? cb2sc.ApprovedEndDate
                                           : cb2sc.RequestedEndDate;
                    }
                }
            }
            return pDataContract;
        }

        protected virtual SupportConceptPeriodStatisticsDC GetPeriodDCFromServiceRecord(List<SupportConceptPeriodStatisticsDC> stats, ServiceRecord sr)
        {

            foreach (var p in stats)
            {
                DateTime start = DateTime.MinValue;
                DateTime end = DateTime.MaxValue;

                if (p.SupportConceptApprovalPeriod.StartDate.HasValue)
                    start = p.SupportConceptApprovalPeriod.StartDate.Value;
                if (p.SupportConceptApprovalPeriod.EndDate.HasValue && p.SupportConceptApprovalPeriod.EndDate.Value.Date < end)
                    end = p.SupportConceptApprovalPeriod.EndDate.Value.Date.AddDays(1);

                if (sr.Start.Value.Second == 1 && sr.Start >= start && sr.Start < end)
                {
                    if (p.SupportConceptApprovalPeriod.ServiceCategory != null && p.SupportConceptApprovalPeriod.ServiceCategory.ServiceCategoryOid == sr.ServiceDescription.ServiceCategory.Oid)
                        return p;
                }
                else
                {
                    if (sr.Start >= start && sr.End < end)
                    {
                        if (p.SupportConceptApprovalPeriod.ServiceCategory != null &&
                            p.SupportConceptApprovalPeriod.ServiceCategory.ServiceCategoryOid ==
                            sr.ServiceDescription.ServiceCategory.Oid)
                            return p;

                    }
                }
            }
            foreach (var p in stats)
            {
                DateTime start = DateTime.MinValue;
                DateTime end = DateTime.MaxValue;

                if (p.SupportConceptApprovalPeriod.StartDate.HasValue)
                    start = p.SupportConceptApprovalPeriod.StartDate.Value;
                if (p.SupportConceptApprovalPeriod.EndDate.HasValue && p.SupportConceptApprovalPeriod.EndDate.Value.Date < end)
                    end = p.SupportConceptApprovalPeriod.EndDate.Value.Date.AddDays(1);

                if (sr.Start.Value.Second == 1 && sr.Start >= start && sr.Start < end)
                {
                    if (p.SupportConceptApprovalPeriod.ServiceCategory == null)
                        return p;
                }
                else
                {
                    if (sr.Start >= start && sr.End < end)
                    {
                        if (p.SupportConceptApprovalPeriod.ServiceCategory == null)
                            return p;

                    }
                }

            }
            return null;
        }

        protected virtual ServiceRecordDC MapToServiceRecordDCForStatistic(ServiceRecord pEntity)
        {
            var pDataContract = new ServiceRecordDC();

            pDataContract.ServiceRecordOid = pEntity.Oid;
            pDataContract.ServiceRecordVersion = pEntity.Version;
            pDataContract.Start = pEntity.Start;
            pDataContract.End = pEntity.End;
            pDataContract.Notice = pEntity.Notice;
            pDataContract.ServiceRecordType = pEntity.ServiceRecordType ?? ServiceRecordTypeId.DefaultActivity;
            pDataContract.DistanceInMeterDecimal = pEntity.DistanceInMeter;
            // ? pEntity.ServiceRecordType.Value
            // : ServiceRecordTypeId.DefaultActivity;

            if (pEntity.ServiceDescription != null)
            {
                pDataContract.ServiceDescription = MapperFactory.ServiceDescriptionDC_ServiceDescription.MapToNewDC(pEntity.ServiceDescription);
            }

            pDataContract.RoundedDuration = pEntity.RoundedDuration;
            pDataContract.InsertedOn = pEntity.InsTs;
            pDataContract.InsUser = pEntity.InsUser;


            pDataContract.GroupEmployeeCount = pEntity.GroupEmployeeCount;
            pDataContract.GroupPersonCount = pEntity.GroupPersonCount;
            pDataContract.GroupRoundedDuration = pEntity.GroupRoundedDuration;
            pDataContract.GroupOid = pEntity.GroupOid;

            return pDataContract;
        }

        protected virtual ServiceRecordPeriodStatisticsInfoDC CreateDefaultServiceRecordPeriodStatisticsInfo(int rows)
        {
            var dc = new ServiceRecordPeriodStatisticsInfoDC
            {
                LeftValues = new string[rows],
                RightValues = new string[rows],
                LeftValueColors = new string[rows],
                RightValueColors = new string[rows]
            };

            for (int i = 0; i < rows; i++)
            {
                dc.LeftValueColors[i] = "#FF2B508B";
                dc.RightValueColors[i] = "#FF2B508B";
            }

            return dc;
        }

        public virtual decimal GetApprovedMinutesPerMonth(SupportConceptPeriodStatisticsDC periodStats)
        {
            return periodStats.MinutesApprovedPerWeek * (365m / 84m);
        }

        public virtual decimal GetApprovedMinutesPerMonth(SupportConceptStatisticsDC stats)
        {
            return stats.MinutesApprovedPerWeek * (365m / 84m);
        }

        protected bool TimeSpanIsEqual(SupportConceptStatisticsDC r)
        {
            if (r.PeriodStatistics != null && r.PeriodStatistics.Count > 1)
            {
                for (int i = 0; i < r.PeriodStatistics.Count - 1; i++)
                {
                    var p1 = r.PeriodStatistics[i];

                    if (p1.SupportConceptApprovalPeriod.StartDate.HasValue && p1.SupportConceptApprovalPeriod.EndDate.HasValue)
                    {
                        for (int j = i + 1; j < r.PeriodStatistics.Count; j++)
                        {
                            var p2 = r.PeriodStatistics[j];
                            if (p2.SupportConceptApprovalPeriod.StartDate.HasValue && p2.SupportConceptApprovalPeriod.EndDate.HasValue)
                            {
                                if ((p1.SupportConceptApprovalPeriod.StartDate.Value.Date != p2.SupportConceptApprovalPeriod.StartDate.Value.Date) ||
                                    (p1.SupportConceptApprovalPeriod.EndDate.Value.Date != p2.SupportConceptApprovalPeriod.EndDate.Value.Date))
                                    return false;
                            }
                        }
                    }
                }
            }
            return true;
        }

        // Bei selbem Zeitraum und Kategorie soll die neue Statistik einfach auf die alte draufaddiert werden
        private SupportConceptPeriodStatisticsDC SummarizeStats(SupportConceptPeriodStatisticsDC vorhandeneStatistik, SupportConceptPeriodStatisticsDC neueStatistik)
        {
            vorhandeneStatistik.AmountConsumedThisInterval += neueStatistik.AmountConsumedThisInterval;
            vorhandeneStatistik.AmountConsumedTotal += neueStatistik.AmountConsumedTotal;
            vorhandeneStatistik.ApprovedMinutesTillNow += neueStatistik.ApprovedMinutesTillNow;
            vorhandeneStatistik.FixedAmountApprovedPerInterval += neueStatistik.FixedAmountApprovedPerInterval;
            vorhandeneStatistik.FixedAmountApprovedTotal += neueStatistik.FixedAmountApprovedTotal;
            vorhandeneStatistik.IstTotalUntilThisMonth += neueStatistik.IstTotalUntilThisMonth;
            vorhandeneStatistik.MinutesApprovedPerMonth += neueStatistik.MinutesApprovedPerMonth;
            vorhandeneStatistik.MinutesApprovedPerWeek += neueStatistik.MinutesApprovedPerWeek;
            vorhandeneStatistik.MinutesApprovedTotal += neueStatistik.MinutesApprovedTotal;
            vorhandeneStatistik.MinutesFreePerWeek += neueStatistik.MinutesFreePerWeek;
            vorhandeneStatistik.MinutesOutOfApprovedPeriod += neueStatistik.MinutesOutOfApprovedPeriod;
            vorhandeneStatistik.MinutesProvidedThisMonth += neueStatistik.MinutesProvidedThisMonth;
            vorhandeneStatistik.MinutesProvidedThisWeek += neueStatistik.MinutesProvidedThisWeek;
            vorhandeneStatistik.MinutesProvidedTotal += neueStatistik.MinutesProvidedTotal;
            vorhandeneStatistik.MinutesProvidedTotalRounded += neueStatistik.MinutesProvidedTotalRounded;
            vorhandeneStatistik.SollTotalUntilThisMonth += neueStatistik.SollTotalUntilThisMonth;

            return vorhandeneStatistik;
        }
    }
}