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

namespace BeWo.Report.ReportObjects
{
	public class FinanceRO : AbstractBeWoReportObject<FinanceRO>
	{
		public DateTime? ReportStartDate { get; set; }

		public DateTime? ReportEndDate { get; set; }

		public decimal? RateFactor { get; set; }

		public IList<SupportConceptFinanceRO> SupportConceptFinanceList { get; set; }


		public class SupportConceptFinanceRO
		{
			public string CustomerName { get; set; }

			public string SupportConceptTimeSpanString { get; set; }

			public string CostBearerName { get; set; }

			public decimal AmountTotal { get; set; }

			public decimal AmountPaid { get; set; }

		    public decimal AmountPaidInReportTimeSpan { get; set; }

            public decimal OpenAmount { get; set; }

			public decimal ApprovedHours { get; set; }

			public decimal BillableHours { get; set; }

			public decimal ApprovedHoursInReportTimeSpan { get; set; }

			public decimal BillableHoursInReportTimeSpan { get; set; }

			public decimal BillableHoursInReportTimeSpanWithFactor { get; set; }

		    public decimal BillableAmountInReportTimeSpan { get; set; }

		    public decimal BillableAmountUntilNow { get; set; }

            public decimal? RateFactor { get; set; }

            public decimal? HourlyRate { get; set; }

            public decimal? AmountInReportTimeSpan { get; set; }

            public List<ServiceRecordDC> ServiceRecords { get; set; }

			public bool IsApproved { get; set; }

			public SupportConceptCostBearerRelDC Costbearer2Supportconcept { get; set; }

		    public SupportConceptApprovalPeriodDC SupportConceptApprovalPeriod { get; set; }

		    public String Leistungskategorie { get; set; }

            public string Custom1 { get; set; }

            public string Custom2 { get; set; }

            public string Custom3 { get; set; }

            public string Custom4 { get; set; }

            public string Custom5 { get; set; }

        }

        public static FinanceRO Create(DateTime? start, DateTime? end)
        {

            return Create(start, end, false);
        }

        public static FinanceRO Create(DateTime? start, DateTime? end, bool onlyNotApproved)
	    {

	        return Create(start, end, false, onlyNotApproved);
	    }

	    public static FinanceRO Create(DateTime? start, DateTime? end, bool splitByServiceCategory, bool onlyNotApproved)
		{
			var result = new FinanceRO();
			result.ReportStartDate = start;
			result.ReportEndDate = end;
			result.SupportConceptFinanceList = new List<SupportConceptFinanceRO>();

            var service = new AnalysisServiceImp();
            var financeList = service.GetOutstandingReceivables(false, false, start, end);
			
            foreach (var item in financeList)
            {
                if (item.SupportConcept != null && item.SupportConcept.ActivationType != ActivationTypeId.Deleted)
                {
                    var cb2sc = DAOFactory.GenericDAO.LoadByID<CostBearer2SupportConcept>(item.CostBearer.CostBearer2SupportConceptOid);
                    var relDC = MapperFactory.SupportConceptCostBearerRelDC_CostBearer2SupportConcept.MapToNewDC(cb2sc);

                    bool istBewilligt = (relDC.ApprovedEndDate.HasValue || relDC.ApprovedStartDate.HasValue);

                    if (onlyNotApproved && istBewilligt)
                    {
                        continue; // Überspringen, wenn nur die NICHT bewilligten angezeigt werden sollen.
                    }

                    var costRateDcs = MapperFactory.CostRatePeriodDC_CostRatePeriod.MapToNewDCs(cb2sc.CostBearer.CostRatePeriods);
                    var calc = Calculations.GetInstance(cb2sc.CostBearer.ID);

                    if (splitByServiceCategory)
                    {
                        var allRecords = cb2sc.ServiceRecords.MapToNewDCs();

                        foreach (var scap in cb2sc.ApprovalPeriodList)
                        {
                            var scapDC = MapperFactory.SupportConceptApprovalPeriodDC_SupportConceptApprovalPeriod.MapToNewDC(scap);

                            var ro = new SupportConceptFinanceRO();

                            ro.CustomerName = item.CustomerName;
                            ro.SupportConceptTimeSpanString = item.SupportConceptTimeSpanString;
                            ro.CostBearerName = item.CostBearerName;

                            ro.AmountTotal = item.AmountTotal;
                            ro.AmountPaid = item.AmountPaid;
                            ro.OpenAmount = item.OpenAmount;


                            ro.Costbearer2Supportconcept = relDC;
                            ro.IsApproved = istBewilligt;


                            ro.SupportConceptApprovalPeriod = scapDC;

                            if (scap.ServiceCategory != null)
                            {
                                ro.Leistungskategorie = scap.ServiceCategory.Name;
                                ro.ServiceRecords = allRecords.Where(sr =>
                                        sr.ServiceDescription.Category.ServiceCategoryOid == scap.ServiceCategory.Oid)
                                    .ToList();
                            }
                            else
                            {
                                ro.ServiceRecords = allRecords;
                            }


                            

                            

                            if (end.HasValue && end < DateTime.MaxValue.AddDays(-1))
                            {
                                ro.ApprovedHours = calc.GetApprovedHoursTillNow(scapDC, costRateDcs, end.Value, true) ?? 0;
                                
                                ro.BillableHours = calc.GetBillableDurationInMinutes(ro.ServiceRecords.Where(sr => sr.Start.Value.Date < end.Value.AddDays(1)).ToList()) / 60;
                            }
                            else
                            {
                                ro.ApprovedHours = calc.GetApprovedHoursTillNow(scapDC, costRateDcs, null, true) ?? 0;
                                ro.BillableHours = calc.GetBillableDurationInMinutes(ro.ServiceRecords) / 60;
                            }



                            if (start.HasValue && end.HasValue)
                            {
                                
                                var rfcrEnd = costRateDcs.GetCostRatePeriodForDate(CostRatePeriodType.RateFactor, end.Value);
                                if (rfcrEnd != null && rfcrEnd.CostRateValue.HasValue)
                                {
                                    ro.RateFactor = (rfcrEnd.CostRateValue.Value + 100m) / 100m;

                                    if (!result.RateFactor.HasValue)
                                    {
                                        result.RateFactor = ro.RateFactor;
                                    }
                                }

                                var hcrEnd = costRateDcs.GetCostRatePeriodForDate(CostRatePeriodType.HourlyRate, end.Value);
                                if (hcrEnd != null && hcrEnd.CostRateValue.HasValue)
                                {

                                    ro.HourlyRate = hcrEnd.CostRateValue.Value;
                                }
                                ro.ApprovedHoursInReportTimeSpan = calc.GetApprovedHoursForPeriod(scapDC, costRateDcs, start, end) ?? 0;

                                
                                ro.AmountInReportTimeSpan = 0;
                                foreach (var srDc in ro.ServiceRecords)
                                {
                                    if (srDc.Start >= start && srDc.Start.Value.Date <= end.Value.Date)
                                    {
                                        
                                        var billable = calc.GetBillableDurationInMinutes(srDc, true) / 60;
                                        ro.BillableHoursInReportTimeSpan += billable;

                                        var rfcr = costRateDcs.GetCostRatePeriodForDate(CostRatePeriodType.RateFactor, srDc.Start.Value);
                                        if (rfcr != null && rfcr.CostRateValue.HasValue)
                                        {
                                            var billableRateFactor = billable * (rfcr.CostRateValue.Value + 100m) / 100m;
                                            ro.BillableHoursInReportTimeSpanWithFactor += billableRateFactor;

                                            billable = billableRateFactor;
                                        }

                                        decimal stundensatz = 0;

                                        var hcr = costRateDcs.GetCostRatePeriodForDate(CostRatePeriodType.HourlyRate, srDc.Start.Value);
                                        if (hcr != null && hcr.CostRateValue.HasValue)
                                        {
                                            stundensatz = hcr.CostRateValue.Value;
                                        }

                                        var betrag = billable * stundensatz;

                                        ro.AmountInReportTimeSpan += betrag;
                                    }
                                }




                            }



                            result.SupportConceptFinanceList.Add(ro);
                        }
                    }
                    else
                    {
                        var ro = new SupportConceptFinanceRO();

                        ro.CustomerName = item.CustomerName;
                        ro.SupportConceptTimeSpanString = item.SupportConceptTimeSpanString;
                        ro.CostBearerName = item.CostBearerName;

                        ro.AmountTotal = item.AmountTotal;
                        ro.AmountPaid = item.AmountPaid;
                        ro.OpenAmount = item.OpenAmount;

                        ro.ServiceRecords = cb2sc.ServiceRecords.MapToNewDCs();

                        ro.Costbearer2Supportconcept = relDC;
                        ro.IsApproved = (relDC.ApprovedEndDate.HasValue || relDC.ApprovedStartDate.HasValue);




                        if (end.HasValue && end < DateTime.MaxValue.AddDays(-1))
                        {
                            ro.ApprovedHours = calc.GetApprovedHoursTillNow(relDC, end.Value) ?? 0;
                            //ro.ApprovedHours = calc.GetApprovedHoursTillNow(relDC, null) ?? 0;
                            ro.BillableHours =
                                calc.GetBillableDurationInMinutes(ro.ServiceRecords.Where(sr => sr.Start.Value.Date < end.Value.AddDays(1)).ToList()) / 60;
                        }
                        else
                        {
                            ro.ApprovedHours = calc.GetApprovedHoursTillNow(relDC, null) ?? 0;
                            ro.BillableHours = calc.GetBillableDurationInMinutes(ro.ServiceRecords) / 60;
                        }



                        if (start.HasValue && end.HasValue)
                        {
                            var rfcrEnd = costRateDcs.GetCostRatePeriodForDate(CostRatePeriodType.RateFactor, end.Value);
                            if (rfcrEnd != null && rfcrEnd.CostRateValue.HasValue)
                            {
                                ro.RateFactor = (rfcrEnd.CostRateValue.Value + 100m) / 100m;

                                if (!result.RateFactor.HasValue)
                                {
                                    result.RateFactor = ro.RateFactor;
                                }
                            }

                            var hcrEnd = costRateDcs.GetCostRatePeriodForDate(CostRatePeriodType.HourlyRate, end.Value);
                            if (hcrEnd != null && hcrEnd.CostRateValue.HasValue)
                            {

                                ro.HourlyRate = hcrEnd.CostRateValue.Value;
                            }
                            ro.ApprovedHoursInReportTimeSpan = calc.GetApprovedHoursForPeriod(relDC, start.Value, end.Value);

                            //ro.BillableHoursInReportTimeSpan =
                            // calc.GetBillableDurationInMinutes(
                            //  cb2sc.ServiceRecords.Where(sr => sr.Start >= start && sr.Start.Value.Date <= end.Value.Date).ToList().
                            //   MapToNewDCs())/60;


                           

                            ro.AmountInReportTimeSpan = 0;
                            foreach (var serviceRecordtemp in cb2sc.ServiceRecords)
                            {
                                if (serviceRecordtemp.Start >= start && serviceRecordtemp.Start.Value.Date <= end.Value.Date)
                                {
                                    var dc = MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewDC(serviceRecordtemp);

                                    var billable = calc.GetBillableDurationInMinutes(dc, true) / 60;
                                    ro.BillableHoursInReportTimeSpan += billable;

                                    var rfcr = costRateDcs.GetCostRatePeriodForDate(CostRatePeriodType.RateFactor, serviceRecordtemp.Start.Value);
                                    if (rfcr != null && rfcr.CostRateValue.HasValue)
                                    {
                                        var billableRateFactor = billable * (rfcr.CostRateValue.Value + 100m) / 100m;
                                        ro.BillableHoursInReportTimeSpanWithFactor += billableRateFactor;

                                        billable = billableRateFactor;
                                    }

                                    decimal stundensatz = 0;

                                    var hcr = costRateDcs.GetCostRatePeriodForDate(CostRatePeriodType.HourlyRate, serviceRecordtemp.Start.Value);
                                    if (hcr != null && hcr.CostRateValue.HasValue)
                                    {
                                        stundensatz = hcr.CostRateValue.Value;
                                    }

                                    var betrag = billable * stundensatz;

                                    ro.AmountInReportTimeSpan += betrag;
                                }
                            }


                            

                        }



                        result.SupportConceptFinanceList.Add(ro);
                    }
                    
                }
            }

			return result;
		}

        public void CalculateBillableAmountInReportTimeSpan()
	    {
	        if (this.SupportConceptFinanceList != null)
	        {
	            foreach (var scRo in SupportConceptFinanceList)
	            {
	                if (scRo.Costbearer2Supportconcept != null)
	                {
	                    CalculateBillableAmountInReportTimeSpan(scRo);
	                }
	            }
	        }
	    }

	    public void CalculateBillableAmountInTimeSpan()
	    {
	        if (this.SupportConceptFinanceList != null)
	        {
	            foreach (var scRo in SupportConceptFinanceList)
	            {
	                if (scRo.Costbearer2Supportconcept != null)
	                {
	                    CalculateBillableAmountInTimeSpan(scRo, scRo.Costbearer2Supportconcept.StartDate, ReportEndDate, true);
	                }
	            }
	        }
	    }

        private void CalculateBillableAmountInReportTimeSpan(SupportConceptFinanceRO scRo)
        {
            CalculateBillableAmountInTimeSpan(scRo, ReportStartDate, ReportEndDate, false);
        }

	    private void CalculateBillableAmountInTimeSpan(SupportConceptFinanceRO scRo, DateTime? start, DateTime? end, bool totalOrReportTimeSpan)
	    {
	        String tenant = null;

	        if (MultitenancyOperationContextExt.Current != null)
	            tenant = MultitenancyOperationContextExt.Current.Tenant;
	        else
	            tenant = SessionFacade.Tenant;

	        var factory = PluginLoader.FindClass<InvoiceFactory>(tenant);
	        if (factory == null)
	        {
	            factory = InvoiceFactory.GetInstance(tenant);
	        }
	        Dictionary<CompactSupportConceptDC, List<ServiceRecordDC>> dict = new Dictionary<CompactSupportConceptDC, List<ServiceRecordDC>>();

	        CompactSupportConceptDC sc = CreateCompactSupportConcept(scRo.Costbearer2Supportconcept);
	        if (scRo.ServiceRecords != null)
	        {
	            foreach (var sr in scRo.ServiceRecords)
	            {
	                sr.AlreadyAccounted = false;
	            }
	        }

	        dict.Add(sc, scRo.ServiceRecords);

	        var creator = factory.CreateInvoiceCreator("Finanzauswertung", tenant, dict);

	        //String text = String.Format("Tenant={0}, Context=Null? {1}, Factory = {2}", tenant,
	        //	MultitenancyOperationContextExt.Current == null, factory);

	        //Utils.SendErrorMail("CB DEBUG", text);
	        DateTimeSpan span = null;
	        if (start.HasValue && end.HasValue)
	        {
	            span = new DateTimeSpan();
	            span.StartDate = start.Value;
	            span.EndDate = end.Value;
	        }

	        if (scRo.CustomerName.Contains("Löb"))
	        {
	            int test = 0;
	        }
	        var invoices = creator.GenerateServiceInvoices(scRo.Costbearer2Supportconcept.CostBearer.CostBearerOid.Value, span, dict);

	        if (invoices != null && invoices.Count == 1)
	        {
	            //var i = invoices[0];
	            if (totalOrReportTimeSpan)
	            {
	                scRo.BillableAmountUntilNow = invoices[0].ClaimSum ?? 0;

                }
	            else
	            {
	                scRo.BillableAmountInReportTimeSpan = invoices[0].ClaimSum ?? 0;
                }
	            
	        }
	    }

        private CompactSupportConceptDC CreateCompactSupportConcept(SupportConceptCostBearerRelDC c2s)
	    {
            var dc = new CompactSupportConceptDC();
	        dc.SupportConceptOid = c2s.SupportConcept.SupportConceptOid;
            dc.CostBearerRelOids = new List<long>();
            dc.CostBearerRelOids.Add(c2s.CostBearer2SupportConceptOid.Value);
            //dc.IsApproved = c2s.ApprovedStartDate.HasValue && c2s.ApprovedEndDate.HasValue;
	        dc.IsApproved = true;
            return dc;
        }

	    public void CalculatePaidAmountInReportTimeSpan()
	    {
	        if (this.SupportConceptFinanceList != null)
	        {
	            foreach (var scRo in SupportConceptFinanceList)
	            {
	                if (scRo.Costbearer2Supportconcept != null)
	                {
	                    CalculatePaidAmountInReportTimeSpan(scRo, this.ReportStartDate ?? DateTime.MinValue, this.ReportEndDate ?? DateTime.MaxValue);
	                }
	            }
	        }

            
        }

        private void CalculatePaidAmountInReportTimeSpan(SupportConceptFinanceRO scRo, DateTime start, DateTime end)
        {
            var c2s = DAOFactory.GenericDAO.LoadByID<CostBearer2SupportConcept>(scRo.Costbearer2Supportconcept
                .CostBearer2SupportConceptOid.Value);

            var bookingList = c2s.AccountingTransactions;

            bookingList = bookingList.Where(i => i.GueltigkeitsDatum.HasValue && i.GueltigkeitsDatum.Value.Date <= end && i.GueltigkeitsDatum >= start).ToList();

            decimal abschlZahlungen = 0;
            foreach (var item in bookingList)
            {
                abschlZahlungen += item.Amount;
            }

            DateTimeSpan span = new DateTimeSpan();
            span.StartDateTime = start;
            span.EndDateTime = end.AddDays(1).AddTicks(-1);

            decimal rechnungsBetrag = 0;

            //if (c2s.SupportConcept.Customer.Person.LastName.StartsWith("Art"))
            //{
            //    int test = 0;
            //}

            var invoices = DAOFactory.SearchDAO.GetServiceInvoices(c2s.Oid.Value, span);
            foreach (var i in invoices)
            {
                foreach (var sip in i.ServiceInvoicePeriodList)
                {
                    rechnungsBetrag += sip.Claim ?? 0;
                }
                
            }

            scRo.AmountPaidInReportTimeSpan = abschlZahlungen + rechnungsBetrag;
        }
    }
}