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

namespace Sleis.Service
{
    public class PublicReportService : ReportService, IReportService
    {
		public override List<int> GetStageableReportingYears()
		{
			throw new NotImplementedException();
		}
        public override void DeleteReport(int reportId)
        {
            ReportData.Delete<PublicReportModel>(reportId);
        }
        public override FacilityView GetReportFacility(int facilityId, int reportId)
        {
            FacilityView model = new FacilityView();
            model.Facility = FacilityData.GetReportFacility<PublicFacilityModel>(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);
            //TODO: Refactor somewhere else if possible?
            //this fix prevents mail address and site address from being null and causing validate report null ref errors.
            if (model.Facility.MailAddress == null) { model.Facility.MailAddress = new PublicFacilityMailAddressModel(); }
            if (model.Facility.SiteAddress == null) { model.Facility.SiteAddress = new PublicFacilitySiteAddressModel(); }
            return model;
        }
        protected override void LoadViewModel(FacilityView model)
        {
            PublicFacilityNaicsModel naics = FacilityNaicsData.GetPrimaryNaics<PublicFacilityNaicsModel>(model.Facility.Id);
            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);

            if (naics != null)
            {
                model.Facility.Naics = naics.Naics;
                model.Facility.FacNaics = FacilityNaicsData.GetSingle<EpaFacilityNaics>(x => x.Code == naics.Naics);

            }
            List<FacilityContactModel> contacts = FacilityContactData.GetAllFacilityContacts<PublicFacilityContactModel>(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);
            }
            
            //Load custom fields for this facility
            List<CustomFieldView> customFields = new List<CustomFieldView>();

            //Get all custom fields for this type of identity
            foreach (CustomFieldModel field in CustomFieldData.Get(CustomFieldEntityType.Facility))
            {
                //Create an instance of the custom field view
                CustomFieldView fieldView = new CustomFieldView(field);
                //Set field vuew value in case this is an edit
                fieldView.Value = CustomFieldValueData.Get<FacilityCustomFieldValue>(model.Facility.Id, fieldView.Field.Id);
                if (
                    (field.LastReportingYear == 0) ||                       //End year has not been set
                    (field.LastReportingYear >= model.Report.Number) ||     //End year >= reporting year
                    (!fieldView.ValueIsNullOrEmpty)                         //Regardless of the reporting year, if the value is there
                   )
                {
                    //if the value has not been set
                    if (fieldView.Value == null)
                    {
                        fieldView.Value = new CustomFieldEntityValue();
                    }
                    customFields.Add(fieldView);
                }
            }
            //Set all views to the facilty
            model.CustomFields = customFields;
        }
        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 (ReleasePoint releasePoint in ReleasePointService.GetReleasePoints(reportId))
                            {
								ReleasePointDetailView dv = new ReleasePointDetailView(model.FacilityIdentity.Report, releasePoint);
                                //Redundant------
                                //dv.CurrentReleasePoint = ReleasePointService.GetReleasePoint(reportId, releasePoint.Id);
                                dv.CustomFields = GetCustomFields<ReleasePointCustomFieldValue>(releasePoint.Id, model.FacilityIdentity.Report.Number, CustomFieldEntityType.ReleasePoint);
                                model.ReleasePoints.Add(dv);
                            }                            
                        }),
                        Task.Factory.StartNew(() => 
                        {
                            //Control Devices
                            foreach (PublicControlDevice controlDevice in ControlDeviceService.GetControlDeviceListByReport(reportId))
                            {
                                ControlDeviceDetailView cdv = new ControlDeviceDetailView();
                                //Redundant------
                                //cdv.Item = ControlDeviceService.GetControlDevice(controlDevice.Id);
                                cdv.Report = model.FacilityIdentity.Report;
                                cdv.Item = controlDevice;                                
                                cdv.CustomFields = GetCustomFields<ControlDeviceCustomFieldValue>(controlDevice.Id, model.FacilityIdentity.Report.Number, CustomFieldEntityType.ControlDevice);
                                model.ControlDevices.Add(cdv);
                            }
                        }),
                        Task.Factory.StartNew(() => 
                        {
                            //Emission Units
                            foreach (PublicEmissionUnit emissionUnit in EmissionUnitService.GetEmissionUnitListByReport(reportId))
                            {
                                EmissionUnitDetailView euv = new EmissionUnitDetailView();
                                //Redundant------
                                //euv.Item = EmissionUnitService.GetEmissionUnit(emissionUnit.Id);
                                euv.Report = model.FacilityIdentity.Report;
                                euv.Item = emissionUnit;                                
                                euv.CustomFields = GetCustomFields<EmissionUnitCustomFieldValue>(emissionUnit.Id, model.FacilityIdentity.Report.Number, CustomFieldEntityType.EmissionUnit);
                                model.EmissionUnits.Add(euv);
                            }
                        }),
                        Task.Factory.StartNew(() => 
                        {
                            //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
                            //Unit Processes
                            foreach(PublicUnitProcess unitProcess in UnitProcessService.GetUnitProcessListByReport(reportId))
                            //Parallel.ForEach(UnitProcessService.GetUnitProcessListByReport(reportId), unitProcess =>
                            {
                                UnitProcessDetailView upv = new UnitProcessDetailView();
                                upv.Item = unitProcess;
                                upv.Report = model.FacilityIdentity.Report;
                                //upv.Item = UnitProcessService.GetUnitProcess(unitProcess.Id);
                                //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<UnitProcessCustomFieldValue>(unitProcess.Id, model.FacilityIdentity.Report.Number, CustomFieldEntityType.UnitProcess);
                                model.UnitProcesses.Add(upv);
                            }
                        }, TaskCreationOptions.LongRunning)
                        
                    };
                    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;
            }
        }
    }
}