using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using Sleis.Models;
using Sleis.ViewModels;
using Sleis.Models.CustomFields;
using Sleis.Utility;
using System.Threading.Tasks;

namespace Sleis.Service
{
    public class AgencyReportService: ReportService, IReportService
    {
		public override List<int> GetStageableReportingYears()
		{
			return ReportData.GetStageableReportingYears();
		}

        public override void DeleteReport(int reportId)
        {
            ReportData.Delete<AgencyReport>(reportId);
        }
        [Obsolete("Moved to Facility Service logic.  View building logic moved to being handled on controller.")]
        public override FacilityView GetReportFacility(int facilityId, int reportId)
        {
            if (reportId > 0)
            {
                FacilityView model = new FacilityView();
                model.Facility = FacilityData.GetReportFacility<AgencyFacilityModel>(reportId);
                model.Facility.MailAddress = FacilityMailAddressData.GetFacilityMailAddress(model.Facility.Id);
                model.Facility.SiteAddress = FacilitySiteAddressData.GetFacilitySiteAddress(model.Facility.Id);
                model.Report = FacilityData.GetReport(facilityId, reportId);
                LoadViewModel(model);
                return model;
            }
            return null;
        }
        protected override void LoadViewModel(FacilityView model)
            {
			AgencyFacilityNaicsModel naics = FacilityNaicsData.GetPrimaryNaics<AgencyFacilityNaicsModel>(model.Facility.Id);
			if (naics != null)
			{
				model.Facility.Naics = naics.Naics;
			}
            model.Facility.Status = LookupUtility.Get<EpaFacilityStatus>(model.Facility.FacilityStatus);
            model.Facility.Category = LookupUtility.Get<EpaFacilityCategory>(model.Facility.FacilityCategory);
            model.Facility.Location.CollectionMethod = LookupUtility.Get<EpaFacilityCollectionMethod>(model.Facility.Location.CollectionMethodCode);
            model.Facility.Location.ReferencePoint = LookupUtility.Get<EpaFacilityGeoReferencePoint>(model.Facility.Location.ReferencePointCode);
            model.Facility.Location.ReferenceSystem = LookupUtility.Get<EpaFacilityGeodeticRefSystem>(model.Facility.Location.ReferenceSystemCode);

            List<FacilityContactModel> contacts = FacilityContactData.GetAllFacilityContacts<AgencyFacilityContact>(model.Facility.Id).ToList<FacilityContactModel>();
            model.Facility.Contacts = new List<FacilityContact>();
            foreach (FacilityContactModel cm in contacts)
            {
                FacilityContact fc = new FacilityContact(cm);
                if (fc.HasData)
                {
                    fc.Contacts = FacilityContactMethodData.GetFacilityContactMethods(fc.Id);
                }
                model.Facility.Contacts.Add(fc);
            }	

	   }
        public override ReportValidationView GetCompleteReport(int facilityId, int reportId)
        {
            {
                ReportValidationView model = new ReportValidationView();

                //Facility
                model.FacilityIdentity = GetReportFacility(facilityId, reportId);

                if (model.FacilityIdentity != null)
                {
                    Task[] tasks = new Task[4]
                    {
                        Task.Factory.StartNew(() => 
                        {   
                            //Release Points
                            foreach (SimpleReleasePointModel releasePoint in ReleasePointService.GetReleasePoints(reportId))
                            {
								ReleasePointDetailView dv = new ReleasePointDetailView(model.FacilityIdentity.Report, ReleasePointService.GetReleasePoint(reportId, releasePoint.Id));
                                dv.CustomFields = GetCustomFields<AgencyReleasePointCustomFieldValue>(releasePoint.Id, model.FacilityIdentity.Report.Number, CustomFieldEntityType.ReleasePoint);
                                model.ReleasePoints.Add(dv);
                            }
                        }),
                        Task.Factory.StartNew(() => 
                        {
                            //Control Devices
                            foreach (AgencyControlDevice controlDevice in ControlDeviceService.GetControlDeviceListByReport(reportId))
                            {
                                ControlDeviceDetailView cdv = new ControlDeviceDetailView();
                                cdv.Item = ControlDeviceService.GetControlDevice(controlDevice.Id);
                                cdv.Report = model.FacilityIdentity.Report;
                                cdv.CustomFields = GetCustomFields<AgencyControlDeviceCustomFieldValue>(controlDevice.Id, model.FacilityIdentity.Report.Number, CustomFieldEntityType.ControlDevice);
                                model.ControlDevices.Add(cdv);
                            }
                        }),
                        Task.Factory.StartNew(() => 
                        {
                            //Emission Units
                            foreach (AgencyEmissionUnit emissionUnit in EmissionUnitService.GetEmissionUnitListByReport(reportId))
                            {
                                EmissionUnitDetailView euv = new EmissionUnitDetailView();
                                euv.Item = EmissionUnitService.GetEmissionUnit(emissionUnit.Id);
                                euv.Report = model.FacilityIdentity.Report;
                                euv.CustomFields = GetCustomFields<AgencyEmissionUnitCustomFieldValue>(emissionUnit.Id, model.FacilityIdentity.Report.Number, CustomFieldEntityType.EmissionUnit);
                                model.EmissionUnits.Add(euv);
                            }
                        }),

                            //Process Emissions
                            //TODO: Not sure why this one is so different. Looks like it has the complete set of data, but
                            //      the validation rules may need to be modified.
                            //model.ProcessEmissions = ProcessEmissionService.GetProcessEmissionList(reportId, true);
                            //make sure UnitProcess has a Process Emission loaded. Relationship is 1:1
                        Task.Factory.StartNew(() => 
                        {
                            //Unit Processes
                            foreach (AgencyUnitProcess unitProcess in UnitProcessService.GetUnitProcessListByReport(reportId))
                            {
                                UnitProcessDetailView upv = new UnitProcessDetailView();
                                upv.Item = unitProcess;
                                upv.Report = model.FacilityIdentity.Report;
                                //upv.Item.ProcessEmission = model.ProcessEmissions.SingleOrDefault(pe => pe.UnitProcessId == unitProcess.Id);
                                upv.Item.ProcessEmission = ProcessEmissionService.GetProcessEmission(0, unitProcess);                                
                                upv.Item.ProcessEmission.UnitProcess = unitProcess;
                                upv.Item.ProcessEmission.SetContext("~");
                                upv.CustomFields = GetCustomFields<AgencyUnitProcessCustomFieldValue>(unitProcess.Id, model.FacilityIdentity.Report.Number, CustomFieldEntityType.UnitProcess);
                                model.UnitProcesses.Add(upv);

                            }
                        })
                    };
                    Task.WaitAll(tasks);
                    foreach (var up in model.UnitProcesses)
                    {
                        foreach (var rp in up.Item.UnitProcessReleasePoints)
                        {
                            rp.ReleasePoint = model.ReleasePoints.SingleOrDefault(x => x.CurrentReleasePoint.Id == rp.ReleasePointId).CurrentReleasePoint;
                        }
                    }
                }
                return model;
            }
            
        }
    }
}