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

using BS.Shared.Core;
using BS.Shared.DataContracts;
using BS.Shared.Extensions;

namespace BS.Shared.Services
{
    public class Calculations : AbstractIDSpecificDefaultClass<Calculations>
    {
        #region Public Methods

        public virtual decimal GetIntervalCountForDays(decimal totalDays, SupportConceptApprovalInterval interval)
        {
            return ConvertPerIntervall2PerDay(totalDays, interval);
        }

        public virtual decimal ConvertPerIntervall2PerDay(decimal pPerInterval, SupportConceptApprovalInterval pInterval)
        {
            switch (pInterval)
            {
                case SupportConceptApprovalInterval.Daily:
                    return pPerInterval;
                case SupportConceptApprovalInterval.Weekly:
                    return pPerInterval / 7m;
                case SupportConceptApprovalInterval.Fortnightly:
                    return pPerInterval / 14m;
                case SupportConceptApprovalInterval.Monthly:
                    return pPerInterval / (365m / 12m);
                case SupportConceptApprovalInterval.Quarterly:
                    return pPerInterval / (365m / 4m);
                case SupportConceptApprovalInterval.HalfYearly:
                    return pPerInterval / (365m / 2m);
                case SupportConceptApprovalInterval.Yearly:
                    return pPerInterval / 365m;
                case SupportConceptApprovalInterval.Hourly:
                    return pPerInterval * 24;
                default:
                    return 0;
            }
        }

        public virtual decimal? GetApprovedAmountForPeriod(SupportConceptCostBearerRelDC c2sDc, DateTime? start, DateTime? end, ServiceCategoryDC cat)
        {
            // Start- und Enddate sowie Leistungskategorie sind KannFelder
            var dtStart = c2sDc.StartDate;
            var dtEnd = c2sDc.EndDate;

            if (start.HasValue && start > dtStart)
            {
                dtStart = start;
            }
            if (end.HasValue && end < dtEnd)
            {
                dtEnd = end;
            }

            decimal summe = 0;
            var orgCrList = c2sDc.CostBearer.CostRatePeriods;

            if (cat != null) // Im Fall, dass nur eine bestimmte Leistungskategorie berücksichtigt werden soll
            {
                foreach (var scap in c2sDc.ApprovalPeriodList)
                {
                    if (scap.StartDate <= dtEnd && scap.EndDate >= dtStart && scap.ServiceCategory != null && scap.ServiceCategory.ServiceCategoryOid == cat.ServiceCategoryOid)
                    {
                        if (scap.ServiceCategory.CostRatePeriods != null && scap.ServiceCategory.CostRatePeriods.Count > 0)
                        {
                            summe += GetApprovedAmountDefaultHourlyRateForPeriod(scap, scap.ServiceCategory.CostRatePeriods, dtStart, dtEnd) ?? 0;
                        }
                        else
                        {
                            summe += GetApprovedAmountDefaultHourlyRateForPeriod(scap, orgCrList, dtStart, dtEnd) ?? 0;
                        }
                    }
                }
            }
            else
            {
                foreach (var scap in c2sDc.ApprovalPeriodList)
                {
                    if (scap.StartDate <= dtEnd && scap.EndDate >= dtStart)
                    {
                        if (scap.ServiceCategory != null && scap.ServiceCategory.CostRatePeriods != null && scap.ServiceCategory.CostRatePeriods.Count > 0)
                        {
                            summe += GetApprovedAmountDefaultHourlyRateForPeriod(scap, scap.ServiceCategory.CostRatePeriods, dtStart, dtEnd) ?? 0;
                        }
                        else
                        {
                            summe += GetApprovedAmountDefaultHourlyRateForPeriod(scap, orgCrList, dtStart, dtEnd) ?? 0;
                        }
                    }
                }
            }
            return summe;
        }

        public virtual decimal? GetApprovedAmount(SupportConceptApprovalPeriodDC scap, List<CostRatePeriodDC> costRatePeriods)
        {
            decimal t1;
            decimal t2;

            if (scap.ApprovedFixedAmount.HasValue)
                return this.GetApprovedFixedAmount(scap, out t1, out t2);
            if (scap.ServiceCategory != null && scap.ServiceCategory.CostRatePeriods != null && scap.ServiceCategory.CostRatePeriods.Count > 0)
            {
                return  this.GetApprovedAmountDefaultHourlyRate(scap, scap.ServiceCategory.CostRatePeriods);
            }
            return this.GetApprovedAmountDefaultHourlyRate(scap, costRatePeriods);

        }

        public virtual decimal? GetApprovedAmountDefaultHourlyRate(SupportConceptApprovalPeriodDC scap, List<CostRatePeriodDC> costRatePeriods)
        {
            return this.GetApprovedAmountDefaultHourlyRateForPeriod(scap, costRatePeriods, scap.StartDate, scap.EndDate);
        }

        public virtual decimal? GetApprovedAmountDefaultHourlyRateForPeriod(SupportConceptApprovalPeriodDC scap,
                                                                            List<CostRatePeriodDC> costRatePeriods,
                                                                            DateTime? start,
                                                                            DateTime? end)
        {
            if (!start.HasValue || !end.HasValue)
            {
                return null;
            }

            if (scap.ApprovedBEInterval.HasValue && scap.ApprovedBEPerInterval.HasValue)
            {
                if (scap.ApprovedBEInterval.Value == SupportConceptApprovalInterval.Monthly && !scap.IsApprovedBEShifting)
                {
                    var totalMonths = GetTotalMonths(start.Value, end.Value);
                    var approvedHours = totalMonths * scap.ApprovedBEPerInterval.Value;


                    var hourlyRate = costRatePeriods.GetCostRatePeriodForDate(CostRatePeriodType.HourlyRate, start.Value);
                    var rateFactor = costRatePeriods.GetCostRatePeriodForDate(CostRatePeriodType.RateFactor, start.Value);
                    decimal amount = 0;
                    if (hourlyRate != null && hourlyRate.CostRateValue.HasValue)
                        amount = approvedHours * hourlyRate.CostRateValue.Value;
                    if (rateFactor != null && rateFactor.CostRateValue.HasValue)
                    {
                        amount = amount + (amount * rateFactor.CostRateValue.Value / 100);
                    }

                    return amount;
                }
            }


            var approvedHoursPerDay = this.GetApprovedHoursPerDay(scap, costRatePeriods);
            if (!approvedHoursPerDay.HasValue)
            {
                return null;
            }

            decimal? result = 0m;

            var day = start.Value.Date;

            if (end.Value.Date == DateTime.MaxValue.Date)
            {
                end = end.Value.AddDays(-1);
            }
            
            do
            {
                var hourlyRate = costRatePeriods.GetCostRatePeriodForDate(CostRatePeriodType.HourlyRate, day);
                var rateFactor = costRatePeriods.GetCostRatePeriodForDate(CostRatePeriodType.RateFactor, day);
                if (hourlyRate == null && rateFactor == null)
                {
                    hourlyRate = costRatePeriods.GetCostRatePeriodForDate(CostRatePeriodType.AmountOfMoney, day);
                }
                decimal? amountThisDay = 0;

                if (hourlyRate != null && hourlyRate.CostRateValue.HasValue && approvedHoursPerDay.HasValue)
                    amountThisDay = approvedHoursPerDay.Value * hourlyRate.CostRateValue.Value;
                if (rateFactor != null && rateFactor.CostRateValue.HasValue)
                {
                    amountThisDay = amountThisDay + (amountThisDay * rateFactor.CostRateValue / 100);
                }

                result += amountThisDay;

            }
            while ((day = day.AddDays(1)) <= end.Value.Date);

            return result;
        }

        public virtual decimal? GetApprovedAmountPerMonthAverage(SupportConceptCostBearerRelDC relDC)
        {
            if (relDC.MonthlyPayment.HasValue)
            {
                return relDC.MonthlyPayment;
            }

            if (relDC.ApprovedStartDate.HasValue && relDC.ApprovedEndDate.HasValue)
            {
                return this.GetApprovedAmountTotal(relDC) / this.GetMonthCount(relDC.ApprovedStartDate.Value, relDC.ApprovedEndDate.Value);
            }

            return 0;
        }

        public virtual decimal? GetApprovedAmountPerMonth(SupportConceptCostBearerRelDC relDC, DateTime dt)
        {
            if (relDC.MonthlyPayment.HasValue)
            {
                return relDC.MonthlyPayment;
            }

            var scap = FindApprovalPeriodForDateAndCategory(relDC, dt, null);
            if (scap == null && relDC.ApprovalPeriodList != null)
            {
                //letze Periode nehmen
                if (relDC.ApprovalPeriodList.Count > 0)
                    scap = relDC.ApprovalPeriodList[0];

                foreach (var ap in relDC.ApprovalPeriodList)
                {
                    if (!ap.EndDate.HasValue)
                        scap = ap;
                    else if (scap.EndDate.HasValue && ap.EndDate > scap.EndDate)
                        scap = ap;
                }

            }
            if (scap != null && scap.MonthlyPayment.HasValue && scap.MonthlyPayment.Value != 0)
                return scap.MonthlyPayment;
            else
            {
                if (relDC.ApprovedStartDate.HasValue && relDC.ApprovedEndDate.HasValue)
                {
                    decimal ratefactor = 1;
                    if (relDC.CostBearer != null && relDC.CostBearer.CostRatePeriods != null)
                    {
                        decimal? factor =
                            relDC.CostBearer.CostRatePeriods.GetCurrentlyValidRateValue(CostRatePeriodType.RateFactor);
                        if (factor.HasValue)
                            ratefactor = (100 + factor.Value) / 100;
                    }

                    var monate = this.GetMonthCount(relDC.ApprovedStartDate.Value, relDC.ApprovedEndDate.Value);
                    if (monate != 0)
                    {
                        return (this.GetApprovedAmountTotal(relDC) / monate) / ratefactor;
                    }
                }
            }
            return 0;
        }

        public virtual SupportConceptApprovalPeriodDC FindApprovalPeriodForDateAndCategory(SupportConceptCostBearerRelDC relDC, DateTime dt, ServiceCategoryDC category)
        {
            SupportConceptApprovalPeriodDC scap = null;

            if (relDC.ApprovalPeriodList != null)
            {
                if (category != null)
                {
                    scap = relDC.ApprovalPeriodList.FirstOrDefault(
                        i =>
                        dt.InBetween(i.Span, true) && i.ServiceCategory != null &&
                        i.ServiceCategory.ServiceCategoryOid == category.ServiceCategoryOid);
                }

                if (scap == null)
                    scap = relDC.ApprovalPeriodList.FirstOrDefault(i => dt.InBetween(i.Span, true));
            }
            return scap;
        }

        public virtual decimal? GetApprovedAmountTotal(SupportConceptCostBearerRelDC relDC)
        {
            if (relDC.ApprovalPeriodList == null || !relDC.GetApprovedDuration().HasValue)
            {
                return null;
            }

            return relDC.ApprovalPeriodList.Sum(i => this.GetApprovedAmount(i, relDC.CostBearer.CostRatePeriods));
        }

        public virtual decimal? GetApprovedBEPerWeek(SupportConceptApprovalPeriodDC scap,
                                                     List<CostRatePeriodDC> costRatePeriods)
        {
            return costRatePeriods.GetCurrentlyValidRate(CostRatePeriodType.MinutesPerServiceUnit)
                .GetHoursInBE(this.GetApprovedHoursPerWeek(scap, costRatePeriods));
        }

        public virtual decimal? GetApprovedBEPerWeek(SupportConceptCostBearerRelDC relDC,
                                                     DateTime date)
        {
            if (!relDC.GetApprovedDuration().HasValue)
            {
                return null;
            }

            return relDC.CostBearer.CostRatePeriods.GetCurrentlyValidRate(CostRatePeriodType.MinutesPerServiceUnit)
                .GetHoursInBE(this.GetApprovedHoursPerWeek(relDC, date));
        }

        public virtual decimal? GetApprovedBEPerWeekAverage(SupportConceptCostBearerRelDC relDC, bool useIsCalculationWithFactor)
        {
            if (!relDC.GetApprovedDuration().HasValue)
            {
                return null;
            }

            return relDC.CostBearer.CostRatePeriods.GetCurrentlyValidRate(CostRatePeriodType.MinutesPerServiceUnit)
                .GetHoursInBE(this.GetApprovedHoursPerWeekAverage(relDC, useIsCalculationWithFactor));
        }

        private decimal? GetApprovedBETotal(SupportConceptCostBearerRelDC relDC, bool useIsCalculationWithFactor)
        {
            if (!relDC.GetApprovedDuration().HasValue)
            {
                return null;
            }

            return relDC.CostBearer.CostRatePeriods.GetCurrentlyValidRate(CostRatePeriodType.MinutesPerServiceUnit)
                .GetHoursInBE(this.GetApprovedHoursTotal(relDC, useIsCalculationWithFactor));
        }

        public virtual decimal? GetApprovedBETotal(SupportConceptApprovalPeriodDC scap,
                                                   List<CostRatePeriodDC> costRatePeriods)
        {
            return costRatePeriods.GetCurrentlyValidRate(CostRatePeriodType.MinutesPerServiceUnit)
                .GetHoursInBE(this.GetApprovedHoursTotal(scap, costRatePeriods));
        }

        public virtual decimal? GetApprovedFixedAmount(SupportConceptApprovalPeriodDC scap, out decimal amountPerUnit, out decimal unitCount)
        {
            return this.GetApprovedFixedAmountForPeriod(scap, scap.StartDate, scap.EndDate, out amountPerUnit, out unitCount);
        }

        public virtual decimal? GetApprovedFixedAmountForPeriod(SupportConceptApprovalPeriodDC scap, DateTime? pStart, DateTime? pEnd, out decimal amountPerUnit, out decimal unitCount)
        {
            amountPerUnit = 0;
            unitCount = 0;

            if (!pStart.HasValue || !pEnd.HasValue || !scap.ApprovedFixedAmount.HasValue || !scap.ApprovedFixedAmountInterval.HasValue)
            {
                return null;
            }
            decimal amount = 0;


            TimeUnit tu = TimeUnit.Day;
            switch (scap.ApprovedFixedAmountInterval.Value)
            {

                case SupportConceptApprovalInterval.Weekly:
                    tu = TimeUnit.Week;
                    break;

                case SupportConceptApprovalInterval.Fortnightly:
                    tu = TimeUnit.Fortnightly;
                    break;

                case SupportConceptApprovalInterval.Monthly:
                    tu = TimeUnit.Month;
                    break;
                case SupportConceptApprovalInterval.Quarterly:

                    tu = TimeUnit.Quarter;
                    break;
                case SupportConceptApprovalInterval.HalfYearly:
                    tu = TimeUnit.Halfyear;
                    break;

                case SupportConceptApprovalInterval.Yearly:
                    tu = TimeUnit.Year;
                    break;
                case SupportConceptApprovalInterval.Hourly:
                    tu = TimeUnit.Hour;
                    break;

            }

            DateTimeUnit du = pStart.Value.Date.GetDateTimeUnit(pEnd.Value.Date, tu);
            amount = scap.ApprovedFixedAmount.Value * du.UnitCount;

            amountPerUnit = scap.ApprovedFixedAmount.Value;
            unitCount = du.UnitCount;

            if (du.RestDays > 0)
            {
                decimal restamountperday = ConvertPerIntervall2PerDay(scap.ApprovedFixedAmount.Value, scap.ApprovedFixedAmountInterval.Value);

                amount += (restamountperday * du.RestDays);
            }
            return amount;
        }

        public virtual decimal GetApprovedHoursForPeriod(SupportConceptCostBearerRelDC relDC,
                                                          DateTime pStart,
                                                          DateTime pEnd)
        {

            var costRatePeriods = relDC.CostBearer.CostRatePeriods;

            decimal approvedHours = 0;

            DateTime start = pStart;
            DateTime end = pEnd;

            while (start <= end)
            {
                var scap = relDC.ApprovalPeriodList.FirstOrDefault(i => start.InBetween(i.Span, true));

                if (scap != null)
                {
                    if (scap.EndDate.HasValue && scap.EndDate.Value < end)
                        end = scap.EndDate.Value;

                    var periodInDays = end.Subtract(start).Days + 1;

                    approvedHours += (this.GetApprovedHoursPerDay(scap, costRatePeriods) ?? 0) * periodInDays;
                }
                else
                {
                    DateTime minStart = DateTime.MaxValue;

                    foreach (var period in relDC.ApprovalPeriodList)
                    {
                        if (period.StartDate.HasValue && period.EndDate.HasValue)
                        {
                            if (period.StartDate.Value > start && period.StartDate.Value <= pEnd && period.StartDate.Value < minStart)
                            {
                                minStart = period.StartDate.Value;
                            }
                        }
                    }
                    end = minStart.AddDays(-1);
                }

                start = end.AddDays(1);
                end = pEnd;
            }


            return approvedHours;
        }

        public virtual decimal? GetApprovedHoursForPeriod(SupportConceptCostBearerRelDC relDC,
                                                          SupportConceptApprovalPeriodDC scap,
                                                          List<CostRatePeriodDC> costRatePeriods,
                                                          DateTime? pStart,
                                                          DateTime? pEnd,
                                                          bool useIsCalculationWithFactor)
        {
            IList<AccountingPeriod> splittedPeriods = SplitPeriodsByRateFactors(scap, costRatePeriods, pStart, pEnd);

            decimal? approvedTotal = null;
            foreach (var ap in splittedPeriods)
            {
                decimal? approvedHours = GetApprovedHoursForPeriod(ap.SupportConceptApprovalPeriod, ap.CostRatesInPeriod, ap.PeriodStart, ap.PeriodEnd);
                if (approvedHours.HasValue && useIsCalculationWithFactor)
                {
                    DateTime dt = DateTime.Now;
                    if (ap.PeriodStart < dt)
                    {
                        dt = ap.PeriodStart;
                    }
                    
                    approvedHours = ApplyIsCalculationWithFactor(relDC, approvedHours, dt);
                }

                if (approvedHours.HasValue)
                {
                    if (!approvedTotal.HasValue)
                    {
                        approvedTotal = 0;
                    }
                    approvedTotal += approvedHours;
                }
            }
            
            return approvedTotal;

        }

        public virtual IList<AccountingPeriod> SplitPeriodsByRateFactors(SupportConceptApprovalPeriodDC scap, List<CostRatePeriodDC> costRatePeriods, DateTime? start, DateTime? end)
        {
            List<AccountingPeriod> list = new List<AccountingPeriod>();

            if (start.HasValue && end.HasValue)
            {
                
                var rateFactorList = costRatePeriods.GetSpans(CostRatePeriodType.RateFactor, start.Value, end.Value).ToList();
                if (rateFactorList.Count > 1)
                {
                    DateTime startTemp = start.Value;
                    DateTime endTemp = end.Value;
                    

                    for (int i = 0; i < rateFactorList.Count; i++)
                    {
                        if (startTemp <= end.Value)
                        {
                            var crp = rateFactorList.ElementAt(i).Key;

                            if (crp.EndDate.HasValue && crp.EndDate.Value < endTemp)
                                endTemp = crp.EndDate.Value.Date;

                            var ap = CreateDefaultPeriod(scap, costRatePeriods, startTemp, endTemp);
                            
                            if (crp.CostRateValue.HasValue)
                                ap.RateFactor = crp.CostRateValue.Value;

                            startTemp = endTemp.AddDays(1);
                            endTemp = end.Value;

                            list.Add(ap);
                        }
                    }

                    
                }
            }
            if (list.Count == 0)
            {
                list.Add(CreateDefaultPeriod(scap, costRatePeriods, start, end));
            }
            return list;

        }

        private AccountingPeriod CreateDefaultPeriod(SupportConceptApprovalPeriodDC scap, List<CostRatePeriodDC> costRatePeriods, DateTime? pStart, DateTime? pEnd)
        {
            var ap = new AccountingPeriod()
            {
                SupportConceptApprovalPeriod = scap,
                CostRatesInPeriod = costRatePeriods
                
            };
            if (pStart.HasValue)
                ap.PeriodStart = pStart.Value;

            if (pEnd.HasValue)
                ap.PeriodEnd = pEnd.Value;
            return ap;
        }

        //Diese Methode überschreiben, wenn die bewilligten Stunden anders als Standard berechnet werden sollen (z.B. pro Monat 4.33 * Wochen) 
        public virtual decimal? GetApprovedHoursForPeriod(SupportConceptApprovalPeriodDC scap,
                                                          List<CostRatePeriodDC> costRatePeriods,
                                                          DateTime? pStart,
                                                          DateTime? pEnd)
        {
            if (!pStart.HasValue || !pEnd.HasValue)
            {
                return null;
            }
            if (scap.ApprovedBEInterval.HasValue && scap.ApprovedBEPerInterval.HasValue)
            {
                if (scap.ApprovedBEInterval.Value == SupportConceptApprovalInterval.Monthly)
                {
                    var months = GetTotalMonths(pStart.Value, pEnd.Value);
                    return months * scap.ApprovedBEPerInterval.Value;
                }
                else if (scap.ApprovedBEInterval.Value == SupportConceptApprovalInterval.Quarterly)
                {
                    var qs = GetTotalQuarters(pStart.Value, pEnd.Value);
                    return qs * scap.ApprovedBEPerInterval.Value;
                }
            }

            var periodInDays = (pEnd.Value.Date - pStart.Value.Date).Days + 1;

            return this.GetApprovedHoursPerDay(scap, costRatePeriods) * periodInDays;
        }

        public virtual decimal GetTotalMonths(DateTime start, DateTime end)
        {
            var am = DateTimeUtils.GetTotalMonths(start, end);

            return am.AnzahlMonateGesamt;
        }

        public virtual decimal GetTotalQuarters(DateTime start, DateTime end)
        {
            int restTageStart = 0;
            int restTageEnd = 0;

            DateTime startDt = start;
            DateTime endDt = end;

            if (startDt.Day > 1)
            {
                var endMonat = new DateTime(startDt.Year, startDt.Month, 1).AddMonths(1).AddDays(-1);

                if (endDt < endMonat)
                {
                    endMonat = endDt;
                }
                restTageStart = endMonat.Subtract(startDt).Days + 1;
                startDt = endMonat.AddDays(1);
            }

            DateTime startTemp = startDt;

            int fullQuarters = 0;
            while (startDt <= endDt)
            {
                startDt = startDt.AddMonths(3);

                if (startDt <= endDt.AddDays(1))
                {
                    startTemp = startDt;
                    fullQuarters++;
                }
            }

            if (startTemp < endDt.AddDays(1))
            {
                restTageEnd = endDt.Subtract(startTemp).Days + 1;
            }

            decimal quartersTotal = fullQuarters;


            if (restTageStart > 0)
            {
                quartersTotal += restTageStart / 90m;

            }
            if (restTageEnd > 0)
            {
                quartersTotal += restTageEnd / 90m;

            }
            return quartersTotal;
        }
        public virtual decimal? GetApprovedHoursPerDay(SupportConceptApprovalPeriodDC scap, List<CostRatePeriodDC> costRatePeriods)
        {
            if (!scap.EndDate.HasValue || !scap.StartDate.HasValue) // || scap.ApprovedFixedAmount.HasValue)
            {
                return null;
            }

            var serviceUnit = costRatePeriods.GetCostRatePeriodForDate(CostRatePeriodType.MinutesPerServiceUnit, scap.EndDate.Value);

            if (scap.ApprovedBETotal.HasValue)
            {
                var scapDurationInDays = (scap.EndDate.Value - scap.StartDate.Value).Days + 1;
                decimal approvedBEPerDay = 0;
                if (scapDurationInDays != 0)
                    approvedBEPerDay = scap.ApprovedBETotal.Value / scapDurationInDays;

                return serviceUnit.GetBEInMinutes(approvedBEPerDay) / 60m;
            }
            else if (scap.ApprovedBEPerInterval.HasValue)
            {
                decimal approvedBEPerDay = 0;
                if (scap.ApprovedBEInterval.HasValue)
                {
                    if (scap.ApprovedBEInterval.Value == SupportConceptApprovalInterval.Yearly)
                    {
                        var totalDays = (scap.EndDate.Value - scap.StartDate.Value).Days + 1;

                        int totalYears = 0;
                        DateTime start = scap.StartDate.Value.AddYears(1);

                        //Anzahl Jahre ausrechnen. Nur wenn das Enddatum genau auf das Datum eines Jahres fällt
                        while (start <= scap.EndDate.Value.AddDays(1))
                        {
                            totalYears++;

                            start = start.AddYears(1);
                            if (start > scap.EndDate.Value.AddDays(1) && start != scap.EndDate.Value.AddDays(1).AddYears(1))
                                totalYears = 0;

                        }

                        if (totalYears > 0)
                        {
                            approvedBEPerDay = (scap.ApprovedBEPerInterval.Value * totalYears) / totalDays;

                            return serviceUnit.GetBEInMinutes(approvedBEPerDay) / 60m;
                        }
                    }

                    approvedBEPerDay = this.ConvertPerIntervall2PerDay(scap.ApprovedBEPerInterval.Value,
                            scap.ApprovedBEInterval.Value);
                }
                return serviceUnit.GetBEInMinutes(approvedBEPerDay) / 60m;
            }

            return null;
        }

        public virtual decimal? GetApprovedHoursPerDay(SupportConceptCostBearerRelDC relDC, DateTime date)
        {
            if (!relDC.GetApprovedDuration().HasValue)
            {
                return null;
            }

            var scap = relDC.ApprovalPeriodList.FirstOrDefault(i => date.InBetween(i.Span, true));
            return scap != null
                       ? this.GetApprovedHoursPerDay(scap, relDC.CostBearer.CostRatePeriods)
                       : null;
        }

        public virtual decimal? GetApprovedHoursPerWeek(SupportConceptApprovalPeriodDC scap,
                                                        List<CostRatePeriodDC> costRatePeriods)
        {
            if (scap.ApprovedBEPerInterval.HasValue && scap.ApprovedBEInterval.HasValue && scap.ApprovedBEInterval.Value == SupportConceptApprovalInterval.Weekly)
            {
                DateTime dt = DateTime.Now;
                if (scap.StartDate.HasValue && scap.StartDate.Value > dt)
                {
                    dt = scap.StartDate.Value;
                }
                if (scap.EndDate.HasValue && scap.EndDate.Value < dt)
                {
                    dt = scap.EndDate.Value;
                }

                var serviceUnit = costRatePeriods.GetCostRatePeriodForDate(CostRatePeriodType.MinutesPerServiceUnit, dt);
                if (serviceUnit != null)
                    return serviceUnit.GetBEInHours(scap.ApprovedBEPerInterval);
            }
            return this.GetApprovedHoursPerDay(scap, costRatePeriods) * 7;
        }

        public virtual decimal? GetApprovedHoursPerWeek(SupportConceptApprovalPeriodDC scap,
                                                        List<CostRatePeriodDC> costRatePeriods, bool useIsCalculationWithFactor)
        {
            if (scap.ApprovedBEPerInterval.HasValue && scap.ApprovedBEInterval.HasValue && scap.ApprovedBEInterval.Value == SupportConceptApprovalInterval.Weekly)
            {
                var serviceUnit = costRatePeriods.GetCostRatePeriodForDate(CostRatePeriodType.MinutesPerServiceUnit, DateTime.Now);
                if (serviceUnit != null)
                    return serviceUnit.GetBEInHours(scap.ApprovedBEPerInterval);
            }
            return this.GetApprovedHoursPerDay(scap, costRatePeriods) * 7;
        }

        public virtual decimal? GetApprovedHoursPerWeek(SupportConceptCostBearerRelDC relDC, SupportConceptApprovalPeriodDC scap,
                                                        List<CostRatePeriodDC> costRatePeriods, bool useIsCalculationWithFactor)
        {
            decimal? hoursPerWeek = GetApprovedHoursPerWeek(scap, costRatePeriods);
            if (hoursPerWeek.HasValue && useIsCalculationWithFactor)
                hoursPerWeek = ApplyIsCalculationWithFactor(relDC, scap, hoursPerWeek);
            return hoursPerWeek;
        }

        public virtual decimal? GetApprovedHoursPerWeek(SupportConceptCostBearerRelDC relDC,
                                                        DateTime date)
        {
            return GetApprovedHoursPerWeek(relDC, date, true);
        }


        public virtual decimal? GetApprovedHoursPerWeek(SupportConceptCostBearerRelDC relDC,
                                                        DateTime date, bool useIsCalculationWithFactor)
        {
            if (!relDC.GetApprovedDuration().HasValue)
            {
                return null;
            }

            var scap = relDC.ApprovalPeriodList.FirstOrDefault(i => date.InBetween(i.Span, true));
            decimal? hoursPerWeek = null;
            if (scap != null)
            {
                hoursPerWeek = this.GetApprovedHoursPerWeek(scap, relDC.CostBearer.CostRatePeriods);
                if (useIsCalculationWithFactor)
                    hoursPerWeek = ApplyIsCalculationWithFactor(relDC, hoursPerWeek);
            }
            return hoursPerWeek;
        }

        public virtual decimal? ApplyIsCalculationWithFactor(SupportConceptCostBearerRelDC relDC, SupportConceptApprovalPeriodDC scap, decimal? valueToApply)
        {
            DateTime dt = DateTime.Now;
            if (scap.StartDate.HasValue && scap.StartDate.Value > dt)
            {
                dt = scap.StartDate.Value;
            }
            if (scap.EndDate.HasValue && scap.EndDate.Value < dt)
            {
                dt = scap.EndDate.Value;
            }
            return ApplyIsCalculationWithFactor(relDC, valueToApply, dt);
        }

        public virtual decimal? ApplyIsCalculationWithFactor(SupportConceptCostBearerRelDC relDC, decimal? valueToApply)
        {
            return ApplyIsCalculationWithFactor(relDC, valueToApply, DateTime.Now);
        }

        public virtual decimal? ApplyIsCalculationWithFactor(SupportConceptCostBearerRelDC relDC, decimal? valueToApply, DateTime date)
        {
            if (valueToApply.HasValue && relDC.CostBearer != null && relDC.CostBearer.IsCalculatingWithFactor)
            {
                if (relDC.CostBearer.CostRatePeriods != null)
                {
                    decimal? rateFactor =
                        relDC.CostBearer.CostRatePeriods.GetValidRateValueForDate(CostRatePeriodType.RateFactor, date);
                    if (rateFactor.HasValue && rateFactor.Value > 0)
                        valueToApply = (valueToApply.Value * 100) / (rateFactor.Value + 100);
                }

            }
            return valueToApply;
        }

        public virtual decimal? GetApprovedHoursPerWeekAverage(SupportConceptCostBearerRelDC relDC, bool useIsCalculationWithFactor)
        {
            var duration = relDC.GetApprovedDuration();
            if (!duration.HasValue)
            {
                return null;
            }
            if (relDC.ApprovalPeriodList != null && relDC.ApprovalPeriodList.Count == 1)
            {
                decimal? hoursPerWeek = GetApprovedHoursPerWeek(relDC.ApprovalPeriodList[0], relDC.CostBearer.CostRatePeriods);
                if (useIsCalculationWithFactor)
                    hoursPerWeek = ApplyIsCalculationWithFactor(relDC, hoursPerWeek);
                return hoursPerWeek;
            }

            if (duration.Value.Days != 0)
            {
                var averagePerDay = this.GetApprovedHoursTotal(relDC, useIsCalculationWithFactor) / duration.Value.Days;
                return averagePerDay * 7;
            }

            return null;
        }

        public virtual decimal? GetApprovedHoursTotal(SupportConceptCostBearerRelDC relDC, bool useIsCalculationWithFactor)
        {
            if (relDC.ApprovalPeriodList == null || !relDC.GetApprovedDuration().HasValue)
            {
                return null;
            }

            decimal? total = null;

            foreach (var scap in relDC.ApprovalPeriodList)
            {
                IList<AccountingPeriod> splittedPeriods = SplitPeriodsByRateFactors(scap, relDC.CostBearer.CostRatePeriods, scap.StartDate, scap.EndDate);

                
                foreach (var ap in splittedPeriods)
                {
                    decimal? hours = this.GetApprovedHoursForPeriod(ap.SupportConceptApprovalPeriod, ap.CostRatesInPeriod, ap.PeriodStart, ap.PeriodEnd);
                    if (useIsCalculationWithFactor)
                    {
                        DateTime dt = DateTime.Now;
                        if (ap.PeriodStart < dt)
                        {
                            dt = ap.PeriodStart;
                        }
                        hours = ApplyIsCalculationWithFactor(relDC, hours, dt);
                    }
                    if (hours.HasValue)
                    {
                        if (!total.HasValue)
                        {
                            total = 0;
                        }
                        total += hours;
                    }
                }
                
            }



            //decimal? hoursTotal = relDC.ApprovalPeriodList.Sum(i => this.GetApprovedHoursTotal(i, relDC.CostBearer.CostRatePeriods));
            //if (useIsCalculationWithFactor)
            //    hoursTotal = ApplyIsCalculationWithFactor(relDC, hoursTotal);

            if (total.HasValue)
                total = Math.Round(total.Value, 10, MidpointRounding.AwayFromZero);
            return total;
        }

        public virtual decimal? GetApprovedHoursTotal(SupportConceptApprovalPeriodDC scap,
                                                      List<CostRatePeriodDC> costRatePeriods)
        {
            IList<AccountingPeriod> splittedPeriods = SplitPeriodsByRateFactors(scap, costRatePeriods, scap.StartDate, scap.EndDate);

            
            decimal? total = null;
            foreach (var ap in splittedPeriods)
            {
                decimal? hours = this.GetApprovedHoursForPeriod(ap.SupportConceptApprovalPeriod, ap.CostRatesInPeriod, ap.PeriodStart, ap.PeriodEnd);
                
                if (hours.HasValue)
                {
                    if (!total.HasValue)
                    {
                        total = 0;
                    }
                    total += hours;
                }
            }

            return total;
            
        }

        public virtual BillingData GetBillingData(ServiceRecordDC record)
        {
            BillingData data = new BillingData();
            data.BillingPeriodStart = record.Start;
            data.BillingPeriodEnd = record.End;

            CostRatePeriodDC hourlyRate = null;
            CostRatePeriodDC flatRate = null;

            bool useRatefactor = true;
            if (record.ServiceDescription.Category.IsBillable)
            {
                var crpList = record.ServiceDescription.CostRatePeriods;
                var ai = record.ServiceDescription.AccountingInterval;

                if (crpList.Count(c => c.CostRateValue.HasValue) == 0)
                {
                    crpList = record.ServiceDescription.Category.CostRatePeriods;
                    ai = record.ServiceDescription.Category.AccountingInterval;
                }
                if (ai == null)
                {
                    ai = AccountingIntervalType.Hourly;
                }
                if (crpList.Count(c => c.CostRateValue.HasValue) > 0)
                {
                    CostRatePeriodDC crp = crpList.GetCostRatePeriodForDate(CostRatePeriodType.AmountOfMoney,
                                                                            record.Start.Value);

                    if (ai.HasValue)
                    {
                        if (ai.Value == AccountingIntervalType.Hourly)
                            hourlyRate = crp;
                        else if (ai.Value == AccountingIntervalType.FlatRate)
                            flatRate = crp;
                        else if (ai.Value == AccountingIntervalType.Daily)
                        {
                            double days = 0;

                            if (data.BillingPeriodStart.HasValue && data.BillingPeriodEnd.HasValue)
                            {
                                days = data.BillingPeriodEnd.Value.Subtract(data.BillingPeriodStart.Value).Days + 1;
                            }
                            data.UnitCount = (decimal)days;
                            data.AmountPerUnit = crp.CostRateValue ?? 0;
                            data.AmountTotal = data.UnitCount * data.AmountPerUnit;
                            data.AccountingInterval = AccountingIntervalType.Daily;
                            data.GrossAmountTotal = data.AmountTotal;

                            return data;
                        }
                        else if (ai.Value == AccountingIntervalType.Monthly)
                        {
                            
                            
                            AnzahlMonate am = null;
                            data.UnitCount = 1;
                            if (data.BillingPeriodStart.HasValue && data.BillingPeriodEnd.HasValue)
                            {
                                am = DateTimeUtils.GetTotalMonths(data.BillingPeriodStart.Value, data.BillingPeriodEnd.Value);
                                decimal monate = Math.Ceiling(am.AnzahlMonateGesamt);
                                if (monate > data.UnitCount)
                                {
                                    data.UnitCount = monate;
                                }
                            }
                            
                            
                            data.AmountPerUnit = crp.CostRateValue ?? 0;
                            data.AmountTotal = data.UnitCount * data.AmountPerUnit;
                            data.AccountingInterval = AccountingIntervalType.Monthly;
                            data.GrossAmountTotal = data.AmountTotal;

                            return data;
                        }
                    }
                }
            }

            if (hourlyRate != null || flatRate != null)
                useRatefactor = false;

            if (flatRate != null)
            {
                if (record.DistanceInMeterDecimal.HasValue && record.DistanceInMeterDecimal.Value > 0)
                {
                    data.UnitCount = record.DistanceInMeterDecimal.Value;
                }
                else
                {
                    data.UnitCount = 1;
                }
                data.AmountPerUnit = flatRate.CostRateValue;
                data.AmountTotal = data.UnitCount * data.AmountPerUnit;
                data.AccountingInterval = AccountingIntervalType.FlatRate;
            }
            else
            {
                if (hourlyRate == null)
                    hourlyRate = this.GetHourlyRatePeriodForServiceRecord(record);

                decimal rdMinutes = this.GetBillableDurationInMinutes(record, false);
                data.UnitCount = rdMinutes / 60m;


                if (hourlyRate != null)
                {
                    var prozent = record.ServiceDescription.Category.Percentage;
                    if (record.ServiceDescription.ProzentAbrechnung.HasValue)
                    {
                        prozent = record.ServiceDescription.ProzentAbrechnung.Value;
                    }
                    
                    data.AmountPerUnit = hourlyRate.CostRateValue * prozent / 100 ;
                }
                data.AmountTotal = data.AmountPerUnit * data.UnitCount;
                data.AccountingInterval = AccountingIntervalType.Hourly;

            }

            if (useRatefactor)
            {
                var rateFactor =
                    record.CostBearer.CostRatePeriods.GetCostRatePeriodForDate(CostRatePeriodType.RateFactor,
                                                                               record.Start.Value);
                if (rateFactor != null && rateFactor.CostRateValue.HasValue)
                {
                    data.RateFactor = rateFactor.CostRateValue;
                    data.GrossAmountTotal = data.AmountTotal + (data.AmountTotal * rateFactor.CostRateValue / 100);
                }
            }
            if (!data.GrossAmountTotal.HasValue)
                data.GrossAmountTotal = data.AmountTotal;


            return data;
        }


        public virtual decimal? GetBillableAmount(ServiceRecordDC record)
        {
            var rdMinutes = this.GetBillableDurationInMinutes(record, false);
            var hourlyRate = this.GetHourlyRatePeriodForServiceRecord(record);
            decimal amount = 0;
            if (hourlyRate != null && hourlyRate.CostRateValue.HasValue)
                amount = (rdMinutes / 60m) * hourlyRate.CostRateValue.Value;

            var rateFactor = record.CostBearer.CostRatePeriods.GetCostRatePeriodForDate(CostRatePeriodType.RateFactor, record.Start.Value);
            if (rateFactor != null && rateFactor.CostRateValue.HasValue)
            {
                return amount + (amount * rateFactor.CostRateValue / 100);
            }

            return amount;
        }

        public virtual decimal GetBillableDurationInMinutes(ServiceRecordDC record)
        {
            return GetBillableDurationInMinutes(record, false);
        }

        public virtual decimal GetBillableDurationInMinutes(ServiceRecordDC record, bool useProzentAbrechenbar)
        {
            if (!record.ServiceDescription.Category.IsBillable)
            {
                return 0;
            }
            decimal rdMinutes = record.RoundedDuration;

            //var prozent = record.ServiceDescription.Category.ProzentBudget ?? record.ServiceDescription.Category.Percentage;
            //if (record.ServiceDescription.ProzentBudget.HasValue)
            //{
            //    prozent = record.ServiceDescription.ProzentBudget.Value;
            //}
            decimal prozent = 100;
            if (useProzentAbrechenbar)
            {
                if (record.ServiceDescription.ProzentAbrechnung.HasValue)
                {
                    prozent = record.ServiceDescription.ProzentAbrechnung.Value;
                }
                else
                {
                    prozent = record.ServiceDescription.Category.Percentage;
                }
            }
            
            rdMinutes *= (prozent / 100);

            if (record.GroupEmployeeCount.HasValue)
                rdMinutes /= record.GroupEmployeeCount.Value;

            return rdMinutes;
        }
        public virtual decimal GetDocumentedDurationInMinutes(ServiceRecordDC record, bool useProzentBudget)
        {
            if (!record.ServiceDescription.Category.IsBillable)
            {
                return 0;
            }
            decimal rdMinutes = record.RoundedDuration;

            decimal prozent = 100;
            if (useProzentBudget)
            {
                if (record.ServiceDescription.ProzentBudget.HasValue)
                {
                    prozent = record.ServiceDescription.ProzentBudget.Value;
                }
                else
                {
                    prozent = record.ServiceDescription.Category.Percentage;
                }
            }

            rdMinutes *= (prozent / 100);

            if (record.GroupEmployeeCount.HasValue)
                rdMinutes /= record.GroupEmployeeCount.Value;

            return rdMinutes;
        }
        //public virtual decimal GetBillableDurationInMinutes(ServiceRecordDC record)
        //{
        //    if (!record.ServiceDescription.Category.IsBillable)
        //    {
        //        return 0;
        //    }
        //    decimal rdMinutes = record.RoundedDuration;

        //    var prozent = record.ServiceDescription.Category.ProzentBudget ?? record.ServiceDescription.Category.Percentage;
        //    if (record.ServiceDescription.ProzentBudget.HasValue)
        //    {
        //        prozent = record.ServiceDescription.ProzentBudget.Value;
        //    }
        //    rdMinutes *= (prozent / 100);

        //    if (record.GroupEmployeeCount.HasValue)
        //        rdMinutes /= record.GroupEmployeeCount.Value;

        //    return rdMinutes;
        //}

        //public virtual decimal GetBillableDurationInMinutes(ServiceRecordDC record)
        //{
        //    if (!record.ServiceDescription.Category.IsBillable)
        //    {
        //        return 0;
        //    }
        //    decimal rdMinutes = record.RoundedDuration;

        //    decimal prozent = record.ServiceDescription.Category.ProzentBudget ?? record.ServiceDescription.Category.Percentage;
        //    if (record.ServiceDescription.ProzentBudget.HasValue)
        //    {
        //        prozent = record.ServiceDescription.ProzentBudget.Value;
        //    }
        //    rdMinutes *= (prozent / 100);

        //    if (record.GroupEmployeeCount.HasValue)
        //        rdMinutes /= record.GroupEmployeeCount.Value;

        //    return rdMinutes;
        //}

        public virtual decimal GetBillableDurationInMinutes(List<ServiceRecordDC> records)
        {
            return records.Sum(i => GetBillableDurationInMinutes(i, true));
        }
        public virtual decimal GetDocumentedDurationInMinutes(List<ServiceRecordDC> records) // Selbe wie GetBillableDurationInMinutes() aber mit ProzentBudget
        {
            return records.Sum(i => GetDocumentedDurationInMinutes(i, true));
        }

        public virtual decimal GetDurationInMinutesForBillableAmount(ServiceRecordDC record, decimal amount)
        {
            var hourlyRate = this.GetHourlyRatePeriodForServiceRecord(record);
            var rateFactor = record.CostBearer.CostRatePeriods.GetCostRatePeriodForDate(CostRatePeriodType.RateFactor, record.Start.Value);
            if (rateFactor != null && rateFactor.CostRateValue.HasValue)
            {
                amount = (amount / (100 + rateFactor.CostRateValue.Value)) * 100;
            }
            if (hourlyRate != null && hourlyRate.CostRateValue.HasValue)
                return (amount / hourlyRate.CostRateValue.Value) * 60m;
            return 0;
        }

        public virtual CostRatePeriodDC GetHourlyRatePeriodForServiceRecord(ServiceRecordDC record)
        {
            var qualificationOIDs = record.Employee.ValueListEntries
                .Where(i => i.Value == ValueListEntryType.StaffQualificationsType)
                .Select(i => i.Key)
                .ToList();

            var qualificationHourlyRates = record.CostBearer.CostRatePeriods.Where(i =>
                                                                                   i.CostRateType == CostRatePeriodType.HourlyRate &&
                                                                                   i.ValueListEntry != null &&
                                                                                   i.ValueListEntry.Type == ValueListEntryType.StaffQualificationsType);

            var matchingQualifications = qualificationHourlyRates
                .Where(i => qualificationOIDs.Contains(i.ValueListEntry.ValueListEntryOid.Value))
                .ToList();

            var applyingQualificationRates = matchingQualifications
                .GetCostRatePeriodForDateGroupedByValueListEntryOid(CostRatePeriodType.HourlyRate, record.Start.Value);

            if (applyingQualificationRates.Count > 0)
            {
                var maxAmount = applyingQualificationRates.Max(i => i.Value.CostRateValue);
                return applyingQualificationRates.First(i => i.Value.CostRateValue.Equals(maxAmount)).Value;
            }

            return record.CostBearer.CostRatePeriods
                .GetCostRatePeriodForDate(CostRatePeriodType.HourlyRate, record.Start.Value);
        }

        public virtual decimal GetHoursNotBillableDueToAbsenceTimes(SupportConceptCostBearerRelDC sc2cb,
                                                                    List<ServiceRecordDC> records,
                                                                    Dictionary<DateTimeSpan, decimal> absenceTimes,
                                                                    bool doRemoveFromRecordsList,
                                                                    bool doCrop)
        {
            return sc2cb.ApprovalPeriodList.Sum(i => this.GetHoursNotBillableDueToAbsenceTimes(i,
                                                                                               sc2cb.CostBearer.CostRatePeriods,
                                                                                               records,
                                                                                               absenceTimes,
                                                                                               doRemoveFromRecordsList,
                                                                                               doCrop));

        }

        public virtual decimal GetHoursNotBillableDueToAbsenceTimes(SupportConceptApprovalPeriodDC scap,
                                                                    List<CostRatePeriodDC> costRates,
                                                                    List<ServiceRecordDC> records,
                                                                    Dictionary<DateTimeSpan, decimal> absenceTimes,
                                                                    bool doRemoveFromRecordsList,
                                                                    bool doCrop)
        {
            if (scap.ApprovedFixedAmount.HasValue)
            {
                return 0m;
            }

            var hoursNotBillableAbsence = 0m;
            foreach (var iRecord in records.ToList())
            {
                // falls mehrere Bewilligungen bestehen, dürfen Zeiterfassungeinträge nur einmal berücksichtigt werden!
                if (!iRecord.Start.Value.InBetween(scap.Span, true))
                {
                    continue;
                }

                var absenceSpan = absenceTimes.FirstOrDefault(i => iRecord.Start.Value.InBetween(i.Key, true)).Key;
                if (absenceSpan != null)
                {
                    var rd = this.GetBillableDurationInMinutes(iRecord, false);

                    if (absenceTimes[absenceSpan] == 0)
                    {
                        if (doRemoveFromRecordsList)
                        {
                            records.Remove(iRecord);
                        }

                        hoursNotBillableAbsence += rd / 60m;
                        continue;
                    }

                    if (absenceTimes[absenceSpan] - rd >= 0)
                    {
                        absenceTimes[absenceSpan] -= rd;
                        continue;
                    }

                    hoursNotBillableAbsence += (rd - absenceTimes[absenceSpan]) / 60;

                    if (!doCrop)
                    {
                        if (doRemoveFromRecordsList)
                        {
                            records.Remove(iRecord);
                        }

                        continue;
                    }

                    iRecord.End = iRecord.Start.Value.AddMinutes(Convert.ToDouble(absenceTimes[absenceSpan]));

                    var minuteInterval = costRates.GetCostRatePeriodForDate(CostRatePeriodType.MinutesIntervall, iRecord.Start.Value);
                    var duration = Convert.ToDecimal((iRecord.End - iRecord.Start).Value.TotalMinutes);

                    //###CB 5min
                    if (minuteInterval != null && minuteInterval.CostRateValue.HasValue && minuteInterval.CostRateValue.Value != 0)
                    {
                        iRecord.RoundedDuration = GetRoundedDuration((int)minuteInterval.CostRateValue.Value, duration);
                    }
                    else
                    {
                        iRecord.RoundedDuration = duration;
                    }
                    absenceTimes[absenceSpan] = 0;
                }
            }

            return hoursNotBillableAbsence;
        }

        public virtual decimal GetHoursNotBillableDueToMoreThanApproved(SupportConceptCostBearerRelDC sc2cb,
                                                                        List<ServiceRecordDC> records,
                                                                        bool doRemoveFromRecordsList,
                                                                        bool doCrop)
        {
            return sc2cb.ApprovalPeriodList.Sum(i => this.GetHoursNotBillableDueToMoreThanApproved(i,
                                                                                                   sc2cb.CostBearer.CostRatePeriods,
                                                                                                   records,
                                                                                                   doRemoveFromRecordsList,
                                                                                                   doCrop));
        }

        public virtual decimal GetHoursNotBillableDueToMoreThanApproved(SupportConceptApprovalPeriodDC scap,
                                                                        List<CostRatePeriodDC> costRates,
                                                                        List<ServiceRecordDC> records,
                                                                        bool doRemoveFromList,
                                                                        bool doCrop)
        {
            if (scap.ApprovedFixedAmount.HasValue)
            {
                return 0m;
            }

            var approvedAmountCounter = this.GetApprovedAmountDefaultHourlyRate(scap, costRates) ?? 0m;
            var hoursNotBillableNotApproved = 0m;

            foreach (var iRecord in records.ToList())
            {
                if (!iRecord.Start.Value.InBetween(scap.Span, true))
                {
                    if (doRemoveFromList)
                    {
                        records.Remove(iRecord);
                    }

                    continue;
                }

                var amount = this.GetBillableAmount(iRecord) ?? 0m;
                if (approvedAmountCounter - amount >= 0)
                {
                    approvedAmountCounter -= amount;
                    continue;
                }

                if (approvedAmountCounter == 0 || !doCrop)
                {
                    if (doRemoveFromList)
                    {
                        records.Remove(iRecord);
                    }

                    hoursNotBillableNotApproved += this.GetBillableDurationInMinutes(iRecord, false) / 60m;
                    continue;
                }

                var oldDuration = this.GetBillableDurationInMinutes(iRecord, false);

                iRecord.RoundedDuration = this.GetDurationInMinutesForBillableAmount(iRecord, approvedAmountCounter);
                iRecord.End = iRecord.Start.Value.AddMinutes(Convert.ToInt32(iRecord.RoundedDuration));
                hoursNotBillableNotApproved += (oldDuration - iRecord.RoundedDuration) / 60m;
                approvedAmountCounter = 0;
            }

            return hoursNotBillableNotApproved;
        }


        public virtual decimal GetHoursNotBillableDueToOutOfSpan(SupportConceptCostBearerRelDC relDC, List<ServiceRecordDC> records)
        {
            decimal hoursOutOfSpan = 0m;

            DateTimeSpan span = new DateTimeSpan();
            span.StartDate = relDC.StartDate ?? DateTime.MinValue;
            span.EndDate = relDC.EndDate ?? DateTime.MaxValue;

            foreach (var iRecord in records)
            {

                if (!iRecord.Start.Value.InBetween(span, true))
                {
                    hoursOutOfSpan += this.GetBillableDurationInMinutes(iRecord, true) / 60m;
                }
            }

            return hoursOutOfSpan;
        }

        public virtual decimal GetMonthCount(DateTime startDate, DateTime endDate)
        {
            var am = DateTimeUtils.GetTotalMonths(startDate, endDate);
            return am.AnzahlMonateGesamt;
        }

        public virtual decimal? GetApprovedHoursTillNow(SupportConceptCostBearerRelDC relDC, DateTime? appointedDate)
        {

            decimal? totalApproved = null;


            if (relDC.ApprovalPeriodList != null)
            {
                if (relDC.ApprovalPeriodList.Count == 1)
                {
                    decimal? flsTotal = GetApprovedHoursTotal(relDC, true);
                    decimal durationInWeeks = GetDurationInWeeks(relDC) ?? 0;
                    decimal durationInWeeksTillNow = GetDurationInWeeksTillNow(relDC, appointedDate) ?? 0;

                    if (flsTotal.HasValue && durationInWeeks != 0)
                    {
                        if (Math.Round(durationInWeeks, 10) == Math.Round(durationInWeeksTillNow, 10))
                            return flsTotal.Value;
                        totalApproved = flsTotal.Value * ((durationInWeeksTillNow + (1m / 7m)) / durationInWeeks);
                    }
                    else
                    {
                        var approvedPerWeek = GetApprovedHoursPerWeekAverage(relDC, true) ?? 0m;

                        totalApproved = approvedPerWeek * (durationInWeeksTillNow + (1m / 7m));
                    }
                }
                else if (relDC.ApprovalPeriodList.Count > 1)
                {
                    DateTime calcDate = (appointedDate.HasValue && appointedDate.Value < DateTime.Now.Date)
                                                 ? appointedDate.Value
                                                 : DateTime.Now.Date;

                    totalApproved = 0;
                    foreach (var period in relDC.ApprovalPeriodList)
                    {
                        if (period.StartDate.HasValue && period.EndDate.HasValue && calcDate >= period.StartDate)
                        {
                            var approvedHoursPerDay =
                                    GetApprovedHoursPerDay(period, relDC.CostBearer.CostRatePeriods) ?? 0;
                            DateTime endDate = calcDate;
                            if (period.EndDate < endDate)
                            {
                                endDate = period.EndDate.Value;
                            }
                            decimal days = Convert.ToDecimal((endDate - period.StartDate.Value).Days + 1);

                            if (relDC.CostBearer.IsCalculatingWithFactor && relDC.CostBearer.CostRatePeriods != null)
                            {
                                var rateFactorsInSpan = relDC.CostBearer.CostRatePeriods.GetSpans(CostRatePeriodType.RateFactor, period.StartDate.Value.Date, endDate).ToList();

                                if (rateFactorsInSpan.Count > 1)
                                {
                                    days = 0; //Verhindere weitere Addition unten
                                    foreach (var keyValuePair in rateFactorsInSpan)
                                    {
                                        var span = keyValuePair.Value;
                                        var rf = keyValuePair.Key;

                                        if (rf.CostRateValue.HasValue)
                                        {
                                            var spanDays = (span.EndDate - span.StartDate).Days + 1;
                                            var approvedHoursPerDayRf = (approvedHoursPerDay * 100) / (rf.CostRateValue.Value + 100);
                                            totalApproved += (spanDays * approvedHoursPerDayRf);
                                        }
                                    }
                                }
                                else if (rateFactorsInSpan.Count == 1)
                                {
                                    decimal? rateFactor = rateFactorsInSpan[0].Key.CostRateValue;
                                    if (rateFactor.HasValue && rateFactor.Value > 0)
                                        approvedHoursPerDay = (approvedHoursPerDay * 100) / (rateFactor.Value + 100);
                                }
                                //decimal? rateFactor =
                                //    relDC.CostBearer.CostRatePeriods.GetCurrentlyValidRateValue(CostRatePeriodType.RateFactor);
                                //if (rateFactor.HasValue && rateFactor.Value > 0)
                                //    approvedHoursPerDay = (approvedHoursPerDay * 100) / (rateFactor.Value + 100);
                            }
                            totalApproved += (days * approvedHoursPerDay);
                        }
                    }
                }
            }

            return totalApproved;
        }

        public virtual decimal? GetApprovedHoursTillNow(SupportConceptApprovalPeriodDC scap, List<CostRatePeriodDC> costRates, DateTime? appointedDate, bool excludeRateFactor)
        {

            decimal? totalApproved = null;

            DateTime calcDate = (appointedDate.HasValue && appointedDate.Value < DateTime.Now.Date)
                                                 ? appointedDate.Value
                                                 : DateTime.Now.Date;


            if (scap.StartDate.HasValue && scap.EndDate.HasValue && calcDate >= scap.StartDate)
            {
                decimal days;
                var approvedHoursPerDay =
                        GetApprovedHoursPerDay(scap, costRates) ?? 0;

                if (excludeRateFactor)
                {
                    decimal? rateFactor = costRates.GetCurrentlyValidRateValue(CostRatePeriodType.RateFactor);
                    if (rateFactor.HasValue && rateFactor.Value > 0)
                        approvedHoursPerDay = (approvedHoursPerDay * 100) / (rateFactor.Value + 100);
                }

                if (calcDate >= scap.EndDate.Value)
                {
                    days = Convert.ToDecimal((scap.EndDate.Value - scap.StartDate.Value).Days + 1);
                }
                else
                {
                    days = Convert.ToDecimal((calcDate - scap.StartDate.Value).Days + 1);
                }

                totalApproved = (days * approvedHoursPerDay);
            }


            return totalApproved;
        }
        #endregion



        public virtual decimal? GetDurationInWeeks(SupportConceptCostBearerRelDC relDC)
        {
            if (relDC.StartDate != null && relDC.EndDate != null)
            {
                return Convert.ToDecimal((relDC.EndDate.Value - relDC.StartDate.Value).Days + 1) / 7;
            }
            return null;
        }


        public virtual decimal? GetDurationInWeeksTillNow(SupportConceptCostBearerRelDC relDC, DateTime? appointedDate)
        {

            if (relDC.StartDate != null && relDC.EndDate != null)
            {
                DateTime lCalcDate = (appointedDate.HasValue && appointedDate.Value < DateTime.Now.Date)
                                                 ? appointedDate.Value
                                                 : DateTime.Now.Date;

                lCalcDate = lCalcDate > relDC.EndDate
                                    ? relDC.EndDate.Value.Date.AddDays(1)
                                    : lCalcDate;
                return Convert.ToDecimal((lCalcDate - relDC.StartDate.Value).Days) / 7m;
            }

            return null;
        }

        public virtual IList<BillingData> GetFixedBillingData(SupportConceptApprovalPeriodDC supportConceptApprovalPeriod, DateTime? start, DateTime? end)
        {
            IList<BillingData> billingDatas = new List<BillingData>();
            DateTime? dtStart = start ?? supportConceptApprovalPeriod.StartDate;
            DateTime? dtEnd = end ?? supportConceptApprovalPeriod.EndDate;

            if (dtStart.HasValue && dtEnd.HasValue)
            {
                decimal amountPerUnit;
                decimal unitCount;

                decimal? approvalPeriodFixedAmount = GetApprovedFixedAmountForPeriod(supportConceptApprovalPeriod, dtStart, dtEnd, out amountPerUnit, out unitCount);
                if (approvalPeriodFixedAmount.HasValue)
                {
                    billingDatas.Add(new BillingData()
                    {
                        AmountTotal = approvalPeriodFixedAmount,
                        GrossAmountTotal = approvalPeriodFixedAmount,
                        BillingPeriodStart = dtStart,
                        BillingPeriodEnd = dtEnd,
                        AccountingInterval = AccountingIntervalType.FlatRate,
                        AmountPerUnit = amountPerUnit,
                        UnitCount = unitCount

                    });
                }
                else if (supportConceptApprovalPeriod.ServiceCategory != null)
                {
                    var crpList = supportConceptApprovalPeriod.ServiceCategory.CostRatePeriods;
                    var ai = supportConceptApprovalPeriod.ServiceCategory.AccountingInterval;
                    if (ai.HasValue)
                    {
                        DateTime intervalStart = dtStart.Value;
                        DateTime intervalEnd = dtStart.Value;
                        while (intervalStart <= dtEnd)
                        {

                            switch (ai.Value)
                            {
                                case AccountingIntervalType.Daily:
                                    intervalEnd = intervalStart.AddDays(1);
                                    break;
                                case AccountingIntervalType.Weekly:
                                    intervalEnd = intervalStart.AddDays(7);
                                    break;
                                case AccountingIntervalType.Fortnightly:
                                    intervalEnd = intervalStart.AddDays(14);
                                    break;
                                case AccountingIntervalType.Monthly:
                                    intervalEnd = intervalStart.AddMonths(1);
                                    break;
                                case AccountingIntervalType.Quarterly:
                                    intervalEnd = intervalStart.AddMonths(3);
                                    break;
                                case AccountingIntervalType.HalfYearly:
                                    intervalEnd = intervalStart.AddMonths(6);
                                    break;
                                case AccountingIntervalType.Yearly:
                                    intervalEnd = intervalStart.AddYears(1);
                                    break;
                                case AccountingIntervalType.FlatRate:
                                    intervalEnd = dtEnd.Value.AddDays(1);
                                    break;
                                default:
                                    intervalEnd = dtEnd.Value.AddDays(1);
                                    break;

                            }

                            CostRatePeriodDC crp = crpList.GetCostRatePeriodForDate(CostRatePeriodType.AmountOfMoney,
                                                                                    intervalStart);
                            if (crp != null && crp.CostRateValue.HasValue)
                            {
                                billingDatas.Add(new BillingData()
                                {
                                    AmountTotal = crp.CostRateValue,
                                    GrossAmountTotal = crp.CostRateValue,
                                    BillingPeriodStart = intervalStart,
                                    BillingPeriodEnd = intervalEnd.AddDays(-1),
                                    AccountingInterval = ai

                                });
                            }

                            intervalStart = intervalEnd;
                        }
                    }
                }
            }


            return billingDatas;
        }

        public virtual List<AccountingPeriod> GetAccountingPeriods(SupportConceptCostBearerRelDC relDC, List<ServiceRecordDC> recordDCS, DateTimeSpan span)
        {
            Dictionary<long, bool> groupBookingDict = new Dictionary<long, bool>();
            List<AccountingPeriod> apList = new List<AccountingPeriod>();
            Dictionary<AccountingPeriod, AccountingPeriod> ap2apDict = new Dictionary<AccountingPeriod, AccountingPeriod>();

            foreach (var sr in recordDCS)
            {
                if (sr.ServiceDescription.Category.IsBillable && sr.Start.HasValue)
                {
                    if (sr.GroupOid == null || !groupBookingDict.ContainsKey(sr.GroupOid.Value))
                    {
                        
                        AccountingPeriod ap = GetAccountingPeriodForServiceRecord(relDC, sr, span);

                        if (ap != null)
                        {
                            if (ap2apDict.ContainsKey(ap))
                            {
                                ap2apDict[ap].ServiceRecordsInPeriod.Add(sr);
                            }
                            else
                            {
                                ap2apDict.Add(ap, ap);
                                apList.Add(ap);
                            }
                        }
                        if (sr.GroupOid != null && !groupBookingDict.ContainsKey(sr.GroupOid.Value))
                        {
                            groupBookingDict.Add(sr.GroupOid.Value, true);
                        }
                    }
                }
            }
            return apList;
        }

        public virtual AccountingPeriod GetAccountingPeriodForServiceRecord(SupportConceptCostBearerRelDC relDC, ServiceRecordDC sr, DateTimeSpan span)
        {
            CostRatePeriodDC stundensatzCrp = null;
            CostRatePeriodDC previousStundensatzCrp = null;
            AccountingIntervalType intervalType = AccountingIntervalType.Hourly;
            ServiceCategoryDC category = null;

            var scap = FindApprovalPeriodForDateAndCategory(relDC, sr.Start.Value,
                                                                sr.ServiceDescription.Category);

            if (scap != null)
            {
                category = scap.ServiceCategory;

                stundensatzCrp =
                sr.ServiceDescription.CostRatePeriods.GetCostRatePeriodForDate(CostRatePeriodType.AmountOfMoney,
                                                                                sr.Start.Value);
                if (stundensatzCrp != null)
                {
                    previousStundensatzCrp = GetPreviousCrp(stundensatzCrp, sr.ServiceDescription.CostRatePeriods);
                    intervalType = sr.ServiceDescription.AccountingInterval ?? AccountingIntervalType.Hourly;
                    category = sr.ServiceDescription.Category;
                }
                else
                {
                    stundensatzCrp =
                    sr.ServiceDescription.Category.CostRatePeriods.GetCostRatePeriodForDate(CostRatePeriodType.AmountOfMoney,
                                                                                    sr.Start.Value);
                    if (stundensatzCrp != null)
                    {
                        previousStundensatzCrp = GetPreviousCrp(stundensatzCrp, sr.ServiceDescription.Category.CostRatePeriods);
                        intervalType = sr.ServiceDescription.Category.AccountingInterval ??
                                        AccountingIntervalType.Hourly;
                        category = sr.ServiceDescription.Category;
                    }
                }

                if (stundensatzCrp == null)
                {
                    if (scap.ApprovedFixedAmount.HasValue && scap.ApprovedFixedAmountInterval.HasValue)
                    {
                        stundensatzCrp = new CostRatePeriodDC();
                        stundensatzCrp.CostRateValue = scap.ApprovedFixedAmount.Value;
                        stundensatzCrp.CostRateType = CostRatePeriodType.AmountOfMoney;

                        intervalType = ConvertApprovalToAccountingIntervalType(scap.ApprovedFixedAmountInterval.Value);
                    }
                }


                if (stundensatzCrp == null)
                {
                    stundensatzCrp = relDC.CostBearer.CostRatePeriods.GetCostRatePeriodForDate(CostRatePeriodType.HourlyRate,
                                                                                    sr.Start.Value);


                    previousStundensatzCrp = GetPreviousCrp(stundensatzCrp, relDC.CostBearer.CostRatePeriods);
                }

                if (stundensatzCrp != null)
                {
                    CostRatePeriodDC rateFactor = relDC.CostBearer.CostRatePeriods.GetCostRatePeriodForDate(CostRatePeriodType.RateFactor,
                        sr.Start.Value);
                    CostRatePeriodDC previousRateFactor = null;
                    if (rateFactor != null)
                    {
                        previousRateFactor = GetPreviousCrp(rateFactor, relDC.CostBearer.CostRatePeriods);
                    }
                    CostRatePeriodDC unit = relDC.CostBearer.CostRatePeriods.GetCostRatePeriodForDate(CostRatePeriodType.MinutesPerServiceUnit,
                        sr.Start.Value);


                    AccountingPeriod ap = new AccountingPeriod();
                    ap.PeriodStart = scap.StartDate ?? DateTime.MinValue;
                    ap.PeriodEnd = scap.EndDate ?? DateTime.MaxValue;

                    if (span != null)
                    {
                        if (span.StartDate > ap.PeriodStart)
                            ap.PeriodStart = span.StartDate;
                        if (span.EndDate < ap.PeriodEnd)
                            ap.PeriodEnd = span.EndDate;
                    }

                    ap.Amount = stundensatzCrp.CostRateValue ?? 0;
                    ap.AccountingInterval = intervalType;
                    ap.ServiceCategory = category;

                    ap.ServiceRecordsInPeriod.Add(sr);

                    ap.CostRatesInPeriod = new List<CostRatePeriodDC>();
                    ap.CostRatesInPeriod.Add(stundensatzCrp);

                    if (stundensatzCrp.EndDate.HasValue && stundensatzCrp.EndDate.Value.Date < ap.PeriodEnd.Date)
                        ap.PeriodEnd = stundensatzCrp.EndDate.Value;
                    if (rateFactor != null && rateFactor.EndDate.HasValue && rateFactor.EndDate.Value.Date < ap.PeriodEnd.Date)
                        ap.PeriodEnd = rateFactor.EndDate.Value;
                    if (previousStundensatzCrp != null && previousStundensatzCrp.EndDate.HasValue && previousStundensatzCrp.EndDate.Value.Date >= ap.PeriodStart.Date)
                    {
                        ap.PeriodStart = previousStundensatzCrp.EndDate.Value.Date.AddDays(1);
                    }
                    if (previousRateFactor != null && previousRateFactor.EndDate.HasValue && previousRateFactor.EndDate.Value.Date >= ap.PeriodStart.Date)
                    {
                        ap.PeriodStart = previousRateFactor.EndDate.Value.Date.AddDays(1);
                    }

                    if (rateFactor != null)
                    {
                        ap.CostRatesInPeriod.Add(rateFactor);
                        ap.RateFactor = rateFactor.CostRateValue ?? 0;
                    }

                    if (unit != null)
                    {
                        ap.CostRatesInPeriod.Add(unit);
                        ap.UnitName = unit.UnitName;
                    }
                    CalculateApprovedAmounts(ap, scap);

                    if (sr.ServiceDescription.Category.Name.ToLower().Contains("fehlkontakt") || sr.ServiceDescription.Name.ToLower().Contains("fehlkontakt") 
                        || (sr.ServiceDescription.ProzentAbrechnung.HasValue && sr.ServiceDescription.ProzentAbrechnung.Value < 100 && sr.ServiceDescription.ProzentAbrechnung.Value > 0))
                    {
                        ap.Notice = "Fehlkontakte";
                        ap.RateFactor = 0;
                    }
                    return ap;
                }
            }

            return null;
        }

        private CostRatePeriodDC GetPreviousCrp(CostRatePeriodDC crp, List<CostRatePeriodDC> allCrpList)
        {
            if (allCrpList == null || crp == null)
            {
                return null;
            }
            var oldList = allCrpList.GetOldRates(crp.CostRateType).OrderBy(i => i.EndDate);

            if (!crp.EndDate.HasValue)
                return oldList.LastOrDefault(c => c.EndDate.HasValue);
            else
                return oldList.LastOrDefault(c => c.EndDate < crp.EndDate);

        }

        public virtual void CalculateApprovedAmounts(AccountingPeriod ap, SupportConceptApprovalPeriodDC scap)
        {
            ap.SupportConceptApprovalPeriod = scap;

            if (scap.ApprovedBETotal.HasValue)
            {
                if (scap.ApprovedBEPerInterval.HasValue && scap.ApprovedBEInterval.HasValue && scap.ApprovedBEInterval.Value == SupportConceptApprovalInterval.Weekly)
                {
                    ap.ApprovedPerUnit = scap.ApprovedBEPerInterval.Value;
                    ap.ApprovalUnit = AccountingIntervalType.Weekly;
                }
                else
                {
                    ap.ApprovedPerUnit = scap.ApprovedBETotal.Value;
                    ap.ApprovalUnit = AccountingIntervalType.FlatRate;
                }
                
            }
            else if (scap.ApprovedBEPerInterval.HasValue && scap.ApprovedBEInterval.HasValue)
            {
                ap.ApprovedPerUnit = scap.ApprovedBEPerInterval.Value;
                switch (scap.ApprovedBEInterval.Value)
                {
                    case SupportConceptApprovalInterval.Daily:
                        ap.ApprovalUnit = AccountingIntervalType.Daily;
                        break;
                    case SupportConceptApprovalInterval.Weekly:
                        ap.ApprovalUnit = AccountingIntervalType.Weekly;
                        break;
                    case SupportConceptApprovalInterval.Fortnightly:
                        ap.ApprovalUnit = AccountingIntervalType.Fortnightly;
                        break;
                    case SupportConceptApprovalInterval.Monthly:
                        ap.ApprovalUnit = AccountingIntervalType.Monthly;
                        break;
                    case SupportConceptApprovalInterval.Quarterly:
                        ap.ApprovalUnit = AccountingIntervalType.Quarterly;
                        break;
                    case SupportConceptApprovalInterval.HalfYearly:
                        ap.ApprovalUnit = AccountingIntervalType.HalfYearly;
                        break;
                    case SupportConceptApprovalInterval.Yearly:
                        ap.ApprovalUnit = AccountingIntervalType.Yearly;
                        break;
                    case SupportConceptApprovalInterval.Hourly:
                        ap.ApprovalUnit = AccountingIntervalType.Hourly;
                        break;
                }
            }
            //ap.MaxApprovedAmount = GetApprovedAmount(ap, scap);
            ap.MaxApprovedUnitCount = GetApprovedBETotalInPeriod(scap, ap.CostRatesInPeriod, ap.PeriodStart, ap.PeriodEnd);

            //var test2 = GetApprovedAmountDefaultHourlyRate(scap, ap.CostRatesInPeriod);
            //var test3 = GetApprovedAmountDefaultHourlyRateForPeriod(scap, ap.CostRatesInPeriod, ap.PeriodStart, ap.PeriodEnd);
            //var test4 = GetApprovedFixedAmount(scap);
            //var test5 = GetApprovedFixedAmountForPeriod(scap, ap.PeriodStart, ap.PeriodEnd);

            if (scap.ApprovedFixedAmount.HasValue)
            {
                ap.MaxApprovedAmount = scap.ApprovedFixedAmount.Value;
            }
        }

        public virtual decimal? GetApprovedAmount(AccountingPeriod ap, SupportConceptApprovalPeriodDC scap)
        {
            decimal t1, t2;

            return scap.ApprovedFixedAmount.HasValue
                       ? this.GetApprovedFixedAmountForPeriod(scap, ap.PeriodStart, ap.PeriodEnd, out t1, out t2)
                       : this.GetApprovedAmountDefaultHourlyRateForPeriod(scap, ap.CostRatesInPeriod, ap.PeriodStart, ap.PeriodEnd);
        }


        public virtual decimal? GetApprovedBETotalInPeriod(SupportConceptApprovalPeriodDC scap,
                                                   List<CostRatePeriodDC> costRatePeriods,
                                                   DateTime start, DateTime end)
        {
            IList<AccountingPeriod> splittedPeriods = SplitPeriodsByRateFactors(scap, costRatePeriods, start, end);

            decimal? approvedTotal = null;
            foreach (var ap in splittedPeriods)
            {
                decimal? approvedHours = GetApprovedHoursForPeriod(ap.SupportConceptApprovalPeriod, ap.CostRatesInPeriod, ap.PeriodStart, ap.PeriodEnd);
                
                if (approvedHours.HasValue)
                {
                    if (!approvedTotal.HasValue)
                    {
                        approvedTotal = 0;
                    }
                    approvedTotal += approvedHours;
                }
            }
            

            return costRatePeriods.GetCurrentlyValidRate(CostRatePeriodType.MinutesPerServiceUnit).GetHoursInBE(approvedTotal);
        }



        public virtual int GetRoundedDuration(DataContracts.Compact.CompactOrganisationDC org, decimal durationInMinutes)
        {
            int minuteInterval = org.ActualMinuteIntervall;
            return GetRoundedDuration(minuteInterval, durationInMinutes);
        }

        public virtual int GetRoundedDuration(DataContracts.Compact.CompactOrganisationDC org, DateTime date, decimal durationInMinutes)
        {
            int minuteInterval = org.ActualMinuteIntervall;

            var crv = org.CostRatePeriods.GetCostRatePeriodForDate(CostRatePeriodType.MinutesIntervall, date);

            if (crv != null && crv.CostRateValue.HasValue)
            {
                minuteInterval = (int)crv.CostRateValue.Value;
            }

            return GetRoundedDuration(minuteInterval, durationInMinutes);
        }

        public virtual int GetRoundedDuration(int minuteInterval, decimal durationInMinutes)
        {
            decimal lRoundedDuration = durationInMinutes;

            if (minuteInterval > 0)
            {
                lRoundedDuration = durationInMinutes % minuteInterval != 0
                                        ? durationInMinutes + (minuteInterval - (durationInMinutes % minuteInterval))
                                        : durationInMinutes;
            }

            return (int)Math.Round(lRoundedDuration, 0, MidpointRounding.AwayFromZero);
        }

        public static AccountingIntervalType ConvertApprovalToAccountingIntervalType(SupportConceptApprovalInterval supportConceptApprovalInterval)
        {
            switch (supportConceptApprovalInterval)
            {
                case SupportConceptApprovalInterval.Daily:
                    return AccountingIntervalType.Daily;
                case SupportConceptApprovalInterval.Weekly:
                    return AccountingIntervalType.Weekly;
                case SupportConceptApprovalInterval.Fortnightly:
                    return AccountingIntervalType.Fortnightly;
                case SupportConceptApprovalInterval.Monthly:
                    return AccountingIntervalType.Monthly;
                case SupportConceptApprovalInterval.Quarterly:
                    return AccountingIntervalType.Quarterly;
                case SupportConceptApprovalInterval.HalfYearly:
                    return AccountingIntervalType.HalfYearly;
                case SupportConceptApprovalInterval.Hourly:
                    return AccountingIntervalType.Hourly;
                default:
                    return AccountingIntervalType.Yearly;
            }
        }

        public virtual Dictionary<DateTimeSpan, decimal> GetAbsencesTimesNotBillable(IList<AbsenceTimeDC> absenceTimeDcs)
        {
            var lResult = new Dictionary<DateTimeSpan, decimal>();
            foreach (AbsenceTimeDC at in absenceTimeDcs)
            {

                DateTimeSpan span = new DateTimeSpan();
                if (at.Start.HasValue && at.Start.Value <= DateTime.MaxValue.AddDays(-1))
                {
                    span.StartDateTime = at.Start.Value.AddDays(1).Date;
                }
                if (at.End.HasValue && at.End.Value > DateTime.MinValue.AddDays(1))
                {
                    span.EndDateTime = at.End.Value.AddDays(-1).Date;
                }
                else
                {
                    span.EndDateTime = DateTime.MaxValue;
                    ;
                }
                IEnumerable<DateTimeSpan> weeks = GetAbsenceWeeks(span);
                foreach (DateTimeSpan weekSpan in weeks)
                {
                    if (at.Reason.BillableMinutes.HasValue && at.Reason.BillableMinutes.Value > 0 && !lResult.ContainsKey(weekSpan))
                    {
                        lResult.Add(weekSpan, at.Reason.BillableMinutes.Value);
                    }
                }

            }


            return lResult;
        }

        public virtual IEnumerable<DateTimeSpan> GetAbsenceWeeks(DateTimeSpan span)
        {
            var lResult = new List<DateTimeSpan>();

            DateTime startDate = span.StartDate;
            DateTime endDate = span.StartDate;

            if (span.StartDate < DateTime.MaxValue.AddDays(-6))
            {
                endDate = span.StartDate.AddDays(6);
            }
            DateTime totalEnddate = span.EndDate;
            if (totalEnddate == DateTime.MaxValue.Date && span.StartDate < DateTime.MaxValue.AddYears(-1))
                totalEnddate = span.StartDate.AddYears(1);

            while (startDate <= totalEnddate && startDate < DateTime.MaxValue)
            {
                var lCurrentWorkWeek = new DateTimeSpan
                {
                    StartDateTime = startDate,
                    EndDateTime = endDate
                };
                if (lCurrentWorkWeek.EndDateTime > totalEnddate)
                {
                    lCurrentWorkWeek.EndDateTime = totalEnddate;
                }
                lResult.Add(lCurrentWorkWeek);

                if (endDate < DateTime.MaxValue.Date.AddDays(-7))
                {
                    startDate = endDate.AddDays(1);
                    endDate = startDate.AddDays(6);
                }
                else
                {
                    startDate = DateTime.MaxValue;
                }

            }

            return lResult;
        }
    }
}