using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using BeWo.Data.Access;
using BeWo.Data.Entities;
using BeWo.Report;
using BeWo.Report.DefaultReports;
using BeWo.Report.ReportObjects;
using BeWo.Service.DCEntityMapper;
using BeWo.Service.Invoicing;
using BeWo.Service.Plugins;
using BS.Shared.Core;
using BS.Shared.DataContracts;
using BS.Shared.DataContracts.Compact;
using DevExpress.XtraReports.UI;

namespace FeidPartnerReports
{
    public class CustomReportCreator : DefaultReportCreator
    {
        public override XtraReport CreateQueryReport(long queryOid, string queryReportId)
        {
            if (queryOid == 100 || queryOid == 101)
            {
                return CreateRechnungslaufUnbewilligte(queryOid, queryReportId);
            }

            if (queryOid == 200)
            {
                return CreatePersonalplanung(queryOid, queryReportId);
            }

            return base.CreateQueryReport(queryOid, queryReportId);
        }

        public override XtraReport CreateServiceInvoiceReport(string dcIds, long? invoiceBaseOid)
        {
            if (String.IsNullOrEmpty(dcIds) && invoiceBaseOid.HasValue)
            {
                var serviceInvoice = DAOFactory.SearchDAO.GetServiceInvoiceByInvoiceBaseOid(invoiceBaseOid.Value);
                dcIds = String.Format("{0}", serviceInvoice.Oid);
            }

            if (!string.IsNullOrEmpty(dcIds))
            {
                var dcList = new List<ServiceInvoiceDC>();
                var dcidStrs = dcIds.Split(';');

                foreach (var oidStr in dcidStrs)
                {
                    var oid = long.Parse(oidStr);
                    var invoice = DAOFactory.GenericDAO.LoadByID<ServiceInvoice>(oid);
                    var dc = MapperFactory.ServiceInvoiceDC_ServiceInvoice.MapToNewDC(invoice);
                    dcList.Add(dc);
                }

                return CreateInvoiceReport(dcList);
            }
            return new XtraReport();
        }

        private XtraReport CreateInvoiceReport(List<ServiceInvoiceDC> invoices)
        {
            XtraReport allReports = null;
            foreach (var iDC in invoices)
            {
                XtraReport invoiceReport = null;
                IBeWoReport<ServiceInvoiceRO> singleReport = FindReportImp<ServiceInvoiceRO>(iDC.InvoiceBase.InvoiceId);

                var ro = ServiceInvoiceRO.Create(iDC);
                singleReport.SetReportDataSource(ro);
                ((XtraReport)singleReport).CreateDocument();
                invoiceReport = singleReport as XtraReport;

                if (iDC.InvoiceBase.InvoiceId == "Sammelrechnung")
                {
                    var anhang = new Invoice();
                    anhang.SetReportDataSource(ro);
                    anhang.CreateDocument();
                    ((XtraReport)singleReport).Pages.AddRange(((XtraReport)anhang).Pages);
                    invoiceReport = singleReport as XtraReport;
                }
                if (allReports == null)
                    allReports = invoiceReport;
                else
                    ((XtraReport)allReports).Pages.AddRange(invoiceReport.Pages);
            }

            return allReports as XtraReport;
        }

        private XtraReport CreateRechnungslaufUnbewilligte(long queryOid, string queryReportId)
        {
            var query = DAOFactory.GenericDAO.LoadByID<Query>(queryOid);

            if (query == null)
                return new XtraReport();

            // ggf. noch nach Kostenträger differenzieren
            var path = Path.Combine(TempPath, queryReportId + ".xml");
            var table = Utils.XMLDeserialize<DataTable>(path);
            var qro = QueryRO.Create(query, table);

            if (qro.Rows.Count > 0)
            {
                DateTime start = DateTime.Parse(qro.Rows[0].Field1.ToString());
                DateTime end = start.AddMonths(1).AddDays(-1);

                DateTimeSpan span = new DateTimeSpan();
                span.StartDate = start.Date;
                span.EndDate = end.Date;  //.AddDays(1).AddTicks(-1);
                List<ServiceInvoiceDC> firstInv = new List<ServiceInvoiceDC>();
                if (queryOid == 100)
                {
                    firstInv = GenerateInitialServiceInvoices(22, span);
                }
                if (queryOid == 101)
                {
                    firstInv = GenerateInitialServiceInvoices(21, span);
                }
                var anhang = new SammelrechnungTab();
                if (firstInv != null)
                {
                    var count = 0;
                    foreach (var i in firstInv)
                    {
                        count += 1;
                        if (count > 1 && i.ServiceInvoicePeriods != null && i.ServiceInvoicePeriods.Count > 0)
                        {
                            foreach (var sip in i.ServiceInvoicePeriods)
                            {
                                firstInv[0].ServiceInvoicePeriods.Add(sip);
                            }
                        }
                    }
                    ServiceInvoiceRO ro = ServiceInvoiceRO.Create(firstInv[0]);
                    anhang.SetReportDataSource(ro);
                    anhang.CreateDocument();
                    return anhang;
                }
            }
            return new XtraReport();
        }

        public List<ServiceInvoiceDC> GenerateInitialServiceInvoices(long costBearerOid, DateTimeSpan invoicePeriod)
        {
            var cs = PluginLoader.FindClass<CustomerService>();
            IEnumerable<CompactSupportConceptDC> supportConcepts;
            // GetAllActiveSupportConceptCostbearer returns a "Flat" SupportConcept List, one for each CostBearer2SupportConcept!
            supportConcepts = cs.GetAllActiveSupportConceptCostbearer(false, true, 0)
                    .Where(i => i.CostBearerOids2CostBearerRelOids.ContainsKey(costBearerOid));

            supportConcepts = supportConcepts.Where(sc => sc.StartDate < invoicePeriod.EndDateTime && sc.EndDate >= invoicePeriod.StartDate && !sc.IsApproved);

            var supportConcepts2ServiceRecords = supportConcepts.ToDictionary(
                i => i,
                i => MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewDCs(
                                                                            DAOFactory.SearchDAO.FindServiceRecordsInSpan(i.CostBearerRelOids[0], invoicePeriod)));
            var cb = DAOFactory.GenericDAO.LoadByID<CostBearer>(costBearerOid);
            String tenant = PluginLoader.Tenant;
            var factory = PluginLoader.FindClass<InvoiceFactory>(cb.ID);
            if (factory == null)
            {
                factory = InvoiceFactory.GetInstance(cb.ID, tenant);
            }

            var creator = factory.CreateInvoiceCreator(cb.ID, tenant, supportConcepts2ServiceRecords);
            var newInvoices = creator.GenerateServiceInvoices(costBearerOid, invoicePeriod, supportConcepts2ServiceRecords);

            return newInvoices;
        }

        private XtraReport CreatePersonalplanung(long queryOid, string queryReportId)
        {
            var query = DAOFactory.GenericDAO.LoadByID<Query>(queryOid);
            if (query == null)
                return new XtraReport();

            var path = Path.Combine(TempPath, queryReportId + ".xml");
            var table = Utils.XMLDeserialize<DataTable>(path);
            var qro = QueryRO.Create(query, table);

            DateTime reportMonth = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1);
            if (qro.Rows.Count > 0 && qro.Rows[0].Field1 != null
                && DateTime.TryParse(qro.Rows[0].Field1.ToString(), out DateTime parsedMonth))
            {
                reportMonth = new DateTime(parsedMonth.Year, parsedMonth.Month, 1);
            }

            string costBearerFilter = null;
            if (qro.Rows.Count > 0 && qro.Rows[0].Field2.ToString() != "0")
            {
                costBearerFilter = qro.Rows[0].Field2.ToString();
            }

            var ro = PersonalplanungRO.Create(reportMonth, costBearerFilter);
            var report = new FeidPartnerReports.PersonalplanungReport();
            report.SetReportDataSource(ro);
            return report;
        }
    }
}