using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel.Dispatcher;
using System.Text;
using System.Web;
using System.Windows.Forms.VisualStyles;
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;
using DevExpress.Data.Helpers;

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 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? 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 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)
		{
			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 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;
                    

                    var cb2sc = DAOFactory.GenericDAO.LoadByID<CostBearer2SupportConcept>(item.CostBearer.CostBearer2SupportConceptOid);

                    

                    var calc = Calculations.GetInstance(cb2sc.CostBearer.ID);
                    var relDC =
                        MapperFactory.SupportConceptCostBearerRelDC_CostBearer2SupportConcept.MapToNewDC(cb2sc);

                    
	                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)
	                {
	                    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;

	                    
		                var costRateDcs =
			                MapperFactory.CostRatePeriodDC_CostRatePeriod.MapToNewDCs(cb2sc.CostBearer.CostRatePeriods);

	                    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) / 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;
                            }
                        }


                        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;
                        }
	                    
	                }

					

	                result.SupportConceptFinanceList.Add(ro);
                }
            }

			return result;
		}

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

        private void CalculateBillableAmountInReportTimeSpan(SupportConceptFinanceRO scRo)
        {
            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);

            dict.Add(sc, scRo.ServiceRecords);

            var creator = factory.CreateInvoiceCreator(null, 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 (ReportStartDate.HasValue && ReportEndDate.HasValue)
            {
                span = new DateTimeSpan();
                span.StartDate = this.ReportStartDate.Value;
                span.EndDate = this.ReportEndDate.Value;
            }

            var invoices = creator.GenerateServiceInvoices(scRo.Costbearer2Supportconcept.CostBearer.CostBearerOid.Value, span, dict);

            if (invoices != null && invoices.Count == 1)
            {
                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);
	        
            return dc;
        }
	}
}