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

namespace Sleis.Service
{
    public class PublicEmissionUnitService : EmissionUnitService, IEmissionUnitService
    {
        public override EmissionUnit GetEmissionUnit(int emissionUnitId)
        {
            PublicEmissionUnit emissionUnit = new PublicEmissionUnit();
            if (emissionUnitId > 0)
            {
                emissionUnit = EmissionUnitData.GetSingle<PublicEmissionUnit>(x => x.Id == emissionUnitId);
                LoadModel(emissionUnit as PublicEmissionUnit, true);
                //load EmissionUnitRegulationProgram
                LoadRegulationPrograms(emissionUnit);
                emissionUnit.ControlApproach = ControlApproachData.GetSingle<PublicEmissionUnitControlApproach>(a => a.EmissionUnitId == emissionUnit.Id);
                if (emissionUnit.ControlApproach != null && emissionUnit.ControlApproach.Id > 0)
                {
                    emissionUnit.ControlApproach.EntityControlDevices = ControlApproachData.Get<PublicEmissionUnitControlDevice>(cd => cd.ControlApproachId == emissionUnit.ControlApproach.Id).OrderBy(x=>x.SequenceNumber).ToList<EntityControlDevice>();
                    foreach (PublicEmissionUnitControlDevice cd in emissionUnit.ControlApproach.EntityControlDevices)
                    //Parallel.ForEach(emissionUnit.ControlApproach.EntityControlDevices, cd =>
                    {
                        cd.ControlDevice = ControlDeviceData.GetSingle<PublicControlDevice>(c => c.Id == cd.ControlDeviceId);
                    };
                }
                //}
                emissionUnit.UnitProcessIdentifiers = UnitProcessData.GetUnitProcessIdentifiers(emissionUnitId);
            }
            return emissionUnit;
        }
        public override void Update(EmissionUnit emissionUnit, List<CustomFieldView> customFields)
        {
            FacilityModel facility = FacilityData.GetById<PublicFacilityModel>(emissionUnit.FacilityId);
            EmissionUnit oldEu = GetEmissionUnit(emissionUnit.Id);
            using (ISession session = EmissionUnitData.GetSession())
            {
                using (ITransaction trans = session.BeginTransaction())
                {
                    emissionUnit.LastUpdated = DateTime.Now;
                    emissionUnit.LastUpdatedBy = SessionUtility.CurrentUser;
					if (!EmissionUnitData.IsIdentifierUnique(emissionUnit))
					{
						throw new Utility.UniqueIdentifierException("Emission Unit Identifier must be unique.");
					}

					//update the emission unit
                    if (emissionUnit.Id == 0)
                    {
                        ((PublicEmissionUnit)emissionUnit).IsAdd = 1;                        
                    }
                    //update emission unit
                    EmissionUnitData.SaveOrUpdate<PublicEmissionUnit>(emissionUnit as PublicEmissionUnit, session);
                    //update EmissionUnitControlDeviceApproach
                    //emissionUnit.EntityControlDeviceApproach.EntityId = emissionUnit.EmissionUnit.Id;
                    if (Properties.Get(Constants.UseEmissionUnitControlApproach) == "true")
                    {
                        emissionUnit.ControlApproach.EmissionUnitId = emissionUnit.Id;
                        if (emissionUnit.ControlApproach.NotControlled)
                        {
                            //make sure values are always set to this.
                            emissionUnit.ControlApproach.Efficency = 0;
                            emissionUnit.ControlApproach.EntityControlDevices = new List<EntityControlDevice>();
                        }
                        ControlApproachData.SaveOrUpdate(emissionUnit.ControlApproach as PublicEmissionUnitControlApproach, session);
                        //update emission control device 
                        //delete all
                        EntityControlDeviceData.DeleteAllEmissionUnitRelatedByControlApproach(emissionUnit.ControlApproach.Id, session);
                        //update all changes as new.
                        foreach (PublicEmissionUnitControlDevice pcd in emissionUnit.ControlApproach.EntityControlDevices)
                        {
                            pcd.ControlApproachId = emissionUnit.ControlApproach.Id;
                            if (pcd.ControlDeviceId > 0)
                            {
                                EntityControlDeviceData.SaveOrUpdate<PublicEmissionUnitControlDevice>(pcd, session);
                            }
                        }
                    }                       

                    //update emission regulatory programs                    
                    if (Properties.Get(Constants.EnableRegulatoryProgramIn) == Constants.EnableRegulatoryProgramInEmissionUnit)
                    {
                        //delete programs
                        RegulationProgramData.DeleteAllByEmissionUnit(emissionUnit.Id, session);
                        //save all programs as new
                        foreach (PublicEmissionUnitRegulationProgram rp in emissionUnit.RegulationPrograms)
                        {
                            rp.EmissionUnitId = emissionUnit.Id;
                            if (!String.IsNullOrWhiteSpace(rp.ProgramCode))
                            {
                                RegulationProgramData.SaveOrUpdate<PublicEmissionUnitRegulationProgram>(rp, session);
                            }
                        }
                    }                    
                    
                    //save customFieldValue
                    SaveCustomFields<EmissionUnitCustomFieldValue>(customFields, emissionUnit.Id, session);
                    trans.Commit();
                }
            }
            CheckAndUpdateReleatedEmissions(oldEu, emissionUnit);
        }
        public override void Delete(EmissionUnit emissionUnit, List<CustomFieldView> customFields)
        {

            FacilityModel facility = FacilityData.GetById<PublicFacilityModel>(emissionUnit.FacilityId);
            using (ISession session = EmissionUnitData.GetSession())
            {
                using (ITransaction trans = session.BeginTransaction())
                {
                    //delete emission-unit -control-device
                    /*foreach (PublicEmissionUnitControlDevice device in emissionUnit.EntityControlDevice.EntityControlDevices)
                    {
                        EntityControlDeviceData.Delete<PublicEmissionUnitControlDevice>(session, device);
                    }*/
                    if (emissionUnit.ControlApproach != null)
                    {
                        foreach (PublicEmissionUnitControlDevice device in emissionUnit.ControlApproach.EntityControlDevices)
                        {
                            EntityControlDeviceData.Delete(device, session);
                        }
                        //delete emission-unit-control-device-approach
                        ControlApproachData.Delete<PublicEmissionUnitControlApproach>(emissionUnit.ControlApproach as PublicEmissionUnitControlApproach, session);
                    }
                    if (emissionUnit.RegulationPrograms != null)
                    {
                        //delete emission-unit-regulatory-programs
                        foreach (EmissionUnitRegulationProgram prog in emissionUnit.RegulationPrograms)
                        {
                            RegulationProgramData.Delete<EmissionUnitRegulationProgram>(prog, session);
                        }
                    }
                    //Delete custom fields
                    //Note: facility.ReportId should always have value....
                    DeleteCustomFieldsForEntity<EmissionUnitCustomFieldValue>(emissionUnit.Id, facility.ReportId.Value, CustomFieldEntityType.EmissionUnit, session);

                    //delete emission-unit
                    EmissionUnitData.Delete(emissionUnit, session);
                    trans.Commit();
                }
            }
        }
        protected override List<EmissionUnitRegulationProgram> GetRegulationPrograms(int emissionUnitId)
        {
            using (ISession session = RegulationProgramData.GetSession())
            {
                return (from d in RegulationProgramData.Get<PublicEmissionUnitRegulationProgram>(p => p.EmissionUnitId == emissionUnitId)
                select d).ToList<EmissionUnitRegulationProgram>();                
            }
        }
        public override List<EmissionUnitListItem> GetEmissionUnitListItemsByFacility(int facilityId)
        {
            return EmissionUnitData.Get<PublicEmissionUnitListItem>(x => x.FacilityId == facilityId).ToList<EmissionUnitListItem>();
        }
        public override List<EmissionUnitListItem> GetEmissionUnitListItemsByReport(int reportId)
        {
            PublicFacilityModel facility = FacilityData.GetReportFacility<PublicFacilityModel>(reportId);
            return GetEmissionUnitListItemsByFacility(facility.Id);
        }
        public override List<EmissionUnitListItem> GetEmissionUnitListItemsByFacility(int facilityId, int pageNum, int pageSize)
        {
            List<EmissionUnitListItem> list = EmissionUnitData.Get<PublicEmissionUnitListItem>(x => x.FacilityId == facilityId, o => o.Asc(rp => rp.Identifier), pageNum, pageSize).ToList<EmissionUnitListItem>();
            LoadList(list);
            return list;
        }
        public override List<EmissionUnitListItem> GetEmissionUnitListItemsByReport(int reportId, int pageNum, int pageSize)
        {
            FacilityModel facility = FacilityData.GetReportFacility<PublicFacilityModel>(reportId);
            if (facility != null && facility.Id > 0)
            {
                return GetEmissionUnitListItemsByFacility(facility.Id, pageNum, pageSize);
            }
            return new List<EmissionUnitListItem>();
        }
        public override int CountEmissionUnitsByFacility(int facilityId)
        {
            return EmissionUnitData.Count<PublicEmissionUnitListItem>(x => x.FacilityId == facilityId);
        }
        public override int CountEmissionUnitsByReport(int reportId)
        {
            FacilityModel facility = FacilityData.GetReportFacility<PublicFacilityModel>(reportId);
            if (facility != null && facility.Id > 0)
            {
                return CountEmissionUnitsByFacility(facility.Id);
            }
            throw new Exception("No facility assoicated with current report.");
        }
    }
}