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

namespace Sleis.Service
{
	public class PublicUnitProcessService : UnitProcessService, IUnitProcessService
	{
		protected override void LoadModel(UnitProcess model)
		{            
			model.Type = LookupUtility.Get<EpaUnitProcessClass>(model.UnitProcessClassCode);
            model.EmissionUnit = EmissionUnitData.GetSingle<PublicEmissionUnit>(eu => eu.Id == model.EmissionUnitId);            
			model.Scc = EmissionUnitData.GetSingle<EpaUnitProcessClass>(x => x.Code == model.UnitProcessClassCode);
            if(model.LastUpdatedBy!=null && model.LastUpdatedBy.Id > 0)
            {
                model.LastUpdatedBy = UserData.GetById(model.LastUpdatedBy.Id);
            }
			model.EmissionIdentifier = model.EmissionUnit.Identifier;
            model.UnitProcessReleasePoints = UnitProcessReleasePointData.GetUnitProcessReleasePoints<PublicUnitProcessReleasePoint>(model.Id).ToList<UnitProcessReleasePoint>();
            model.ControlApproach = ControlApproachData.GetSingle<PublicUnitProcessControlApproach>(x => x.UnitProcessId == model.Id);
            if (model.ControlApproach == null) { model.ControlApproach = new PublicUnitProcessControlApproach(); } //prevent view from crashing on null ref.
            else
            {
                model.ControlApproach.EntityControlDevices = ControlApproachData.Get<PublicUnitProcessControlDevice>(cd => cd.ControlApproachId == model.ControlApproach.Id).OrderBy(x=>x.SequenceNumber).ToList<EntityControlDevice>();
                foreach (PublicUnitProcessControlDevice cd in model.ControlApproach.EntityControlDevices)                
                {
                    cd.ControlDevice = ControlDeviceData.GetSingle<PublicControlDevice>(c => c.Id == cd.ControlDeviceId);
                };
            }
		}
        public override List<UnitProcessListItem> GetUnitProcessListItemsByReport(int reportId, int pageNum, int pageSize)
        {
            FacilityModel facility = FacilityData.GetReportFacility<PublicFacilityModel>(reportId);
            if (facility != null && facility.Id > 0)
            {
                return GetUnitProcessListItemsByFacility(facility.Id, pageNum, pageSize);
            }
            return new List<UnitProcessListItem>();
        }
        public override List<UnitProcessListItem> GetUnitProcessListItemsByFacility(int facilityId, int pageNum, int pageSize)
        {
            return UnitProcessData.Get<PublicUnitProcessListItem>(x => x.EmissionUnit.FacilityId == facilityId, o => o.Asc(p => p.EmissionUnit.Identifier, d => d.Identifier), pageNum, pageSize).ToList<UnitProcessListItem>();
        }
        public override int CountUnitProcessesByFacility(int facilityId)
        {
            return UnitProcessData.Count<PublicUnitProcessListItem>(x => x.EmissionUnit.FacilityId == facilityId);
        }
        public override int CountUnitProcessesByReport(int reportId)
        {
            FacilityModel facility = FacilityData.GetReportFacility<PublicFacilityModel>(reportId);
            if (facility != null && facility.Id > 0)
            {
                return CountUnitProcessesByFacility(facility.Id);
            }
            throw new Exception("No facility associated with current report.");
        }
		public override List<UnitProcess> GetUnitProcessListByReport(int reportId)
		{
			//int facilityId = FacilityData.GetReportFacility<PublicFacilityModel>(reportId).Id;
			List<UnitProcess> list = UnitProcessData.GetUnitProcessesByAgencyReport(reportId);			
			LoadModel(list);			
			return list;
		}
        public override List<UnitProcess> GetUnitProcessListByFacility(int facilityId)
        {
            List<UnitProcess> list = UnitProcessData.GetUnitProcessesByFacility(facilityId);
            LoadModel(list);
            return list;
        }
        public override List<UnitProcess> GetUnitProcessListByEmissionUnit(int emissionUnitId)
        {
            List<UnitProcess> list = UnitProcessData.Get<PublicUnitProcess>(x => x.EmissionUnitId == emissionUnitId).ToList<UnitProcess>();
            //LoadModel(list);            
            return list;
        }
        public override List<UnitProcessListItem> GetUnitProcessListItemsByReport(int reportId)
        {
            FacilityModel facility = FacilityData.GetReportFacility<PublicFacilityModel>(reportId);
            if (facility != null && facility.Id > 0)
            {
                return UnitProcessData.Get<PublicUnitProcessListItem>(x => x.EmissionUnit.FacilityId == facility.Id).ToList<UnitProcessListItem>();
            }
            return new List<UnitProcessListItem>();
        }
        public override List<UnitProcessListItem> GetUnitProcessListItemsByFacility(int facilityId)
        {
            return UnitProcessData.Get<PublicUnitProcessListItem>(x => x.EmissionUnit.FacilityId == facilityId).ToList<UnitProcessListItem>();
        }
        public override List<UnitProcessListItem> GetUnitProcessListItemsByEmissionUnit(int emissionUnitId)
        {
            return UnitProcessData.Get<PublicUnitProcessListItem>(x => x.EmissionUnit.Id == emissionUnitId).ToList<UnitProcessListItem>();
        }
		public override UnitProcess GetUnitProcess(int unitProcessId)
		{
			UnitProcess unitProcess = UnitProcessData.GetUnitProcess(unitProcessId); //TODO REFACTOR
			LoadModel(unitProcess);
			LoadRegulationPrograms(unitProcess);
			unitProcess.ReleasePoints = ReleasePointData.GetReleasePointsByUnitProcess(unitProcessId);			
			return unitProcess;
		}
        public override List<SimpleEmissionUnit> GetEmissionUnitsByFacility(int facilityId)
        {
            throw new NotImplementedException();
        }
        public override List<SimpleEmissionUnit> GetEmissionUnitsByReport(int reportId)
        {
            int facilityId = FacilityData.GetReportFacility<PublicFacilityModel>(reportId).Id;
            return (from d in EmissionUnitData.Get<PublicEmissionUnit>(u => u.FacilityId == facilityId)
                    select new SimpleEmissionUnit { Id = d.Id, Identifier = d.Identifier, Description = d.Description }).ToList<SimpleEmissionUnit>();
        }
       
        public override void Update(UnitProcess detail, List<CustomFieldView> customFields)
        {
            UnitProcess oldProc = detail.Id > 0 ? GetUnitProcess(detail.Id) : new PublicUnitProcess();
            using (ISession session = UnitProcessData.GetSession())
            {
                using (ITransaction trans = session.BeginTransaction())
                {
                    detail.LastUpdated = DateTime.Now;
                    detail.LastUpdatedBy = SessionUtility.CurrentUser;
					if (!UnitProcessData.IsIdentifierUnique(detail))
					{
						throw new Utility.UniqueIdentifierException("Unit Process Identifier must be unique.");
					}

                    bool isAdded = false;
                    //update the emission unit
                    if (detail.Id == 0)
                    {
                        ((PublicUnitProcess)detail).IsAdd = 1;
                        isAdded = true;
                    }
                    
                    //update unit process
                    UnitProcessData.SaveOrUpdate(detail, session);

                  
                    //Create and save associated PE if new UnitProc
                    if (isAdded)
                    {
                        PublicProcessEmission pe = new PublicProcessEmission()
                        {
                            UnitProcessId = detail.Id,
                            TypeCode = "A",
                            OperatingTypeCode = "R",
                            IsReported = true,
                            IsCbi = false
                        };
                        UnitProcessData.SaveOrUpdate(pe, session);
                    }
                    
                                       
                    //update unit process regulatory programs                    
                    if (Properties.Get(Constants.EnableRegulatoryProgramIn) == Constants.EnableRegulatoryProgramInUnitProcess)
                    {
                        //delete programs
                        RegulationProgramData.DeleteAllByUnitProcess(detail.Id, session);
                        //save all programs as new
                        foreach (PublicUnitProcessRegulationProgram rp in detail.RegulationPrograms)
                        {
                            rp.UnitProcessId = detail.Id;
                            rp.Id = 0; //clear to make sure always being saved as new.
                            if(!String.IsNullOrWhiteSpace(rp.ProgramCode))
                            {
                                RegulationProgramData.SaveOrUpdate<PublicUnitProcessRegulationProgram>(rp, session);
                            }
                        }
                    }

                    //Update control approach and control devices. DELETE ALL PREVIOUS RECORDS. SAVE UPDATES AS NEW
                    if (Properties.Get(Constants.UseEmissionUnitControlApproach) == "false")
                    {
                        if (detail.ControlApproach.NotControlled)
                        {
                            detail.ControlApproach.Efficency = 0;
                            detail.ControlApproach.EntityControlDevices = new List<EntityControlDevice>();
                        }
                        detail.ControlApproach.UnitProcessId = detail.Id;
                        ControlApproachData.SaveOrUpdate(detail.ControlApproach as PublicUnitProcessControlApproach, session);
                        //update unit process control device 
                        //delete all
                        EntityControlDeviceData.DeleteAllUnitProcessRelatedByControlApproach(detail.ControlApproach.Id, session);
                        //update all changes as new.
                        foreach (PublicUnitProcessControlDevice pcd in detail.ControlApproach.EntityControlDevices)
                        {
                            pcd.ControlApproachId = detail.ControlApproach.Id;
                            if (pcd.ControlDeviceId > 0)
                            {
                                EntityControlDeviceData.SaveOrUpdate<PublicUnitProcessControlDevice>(pcd, session);
                            }
                        }
                    }
                    
                    //update the unit process release point apportionment. Delete ALL PREVIOUS RECORDS. SAVE UPDATES AS NEW
                    UnitProcessReleasePointData.DeleteAllByUnitProcess(detail.Id, session);                    
                    //update 
                    foreach (PublicUnitProcessReleasePoint rp in detail.UnitProcessReleasePoints)
                    {                        
                        rp.UnitProcessId = detail.Id;
                        rp.Id = 0; //clear to make sure always being saved as new.
                        if (rp.ReleasePointId > 0)
                        {
                            UnitProcessReleasePointData.SaveOrUpdate<PublicUnitProcessReleasePoint>(rp, session);
                        }
                    }                   
                    
                    //save customFieldValue
                    SaveCustomFields<UnitProcessCustomFieldValue>(customFields, detail.Id, session);
                    trans.Commit();
                }
            }
            CheckAndUpdateReleatedEmissions(oldProc, detail);
        }
        public override void Delete(UnitProcess detail, List<CustomFieldView> customFields)
        {
            {
                using (ISession session = UnitProcessData.GetSession())
                {
                    using (ITransaction trans = session.BeginTransaction())
                    {
                        //delete process emission
                        ProcessEmissionService.DeleteProcessEmission(ProcessEmissionService.GetProcessEmission(0, detail.Id));
                       
                        //delete unit process release points
                        UnitProcessReleasePointData.DeleteAllByUnitProcess(detail.Id, session);

                        //delete regulatory programs
                        if (detail.RegulationPrograms != null)
                        {
                            foreach (PublicUnitProcessRegulationProgram program in detail.RegulationPrograms)
                            {
                                RegulationProgramData.Delete<PublicUnitProcessRegulationProgram>(program, session);
                            }
                        }
                        //delete unit process control device
                        if (detail.EntityControlDevice != null)
                        {
                            foreach (PublicUnitProcessControlDevice device in detail.EntityControlDevice.EntityControlDevices)
                            {
                                EntityControlDeviceData.Delete<PublicUnitProcessControlDevice>(device, session);
                            }
                        }

                        //delete unit process control device approach
                        ControlApproachData.Delete<PublicUnitProcessControlApproach>(detail.ControlApproach as PublicUnitProcessControlApproach, session);

                        //delete custom fields
                        foreach (CustomFieldView customFeild in customFields)
                        {
                            UnitProcessCustomFieldValue val = customFeild.Value.Convert<UnitProcessCustomFieldValue>();
                            val.EntityId = detail.Id;
                            val.FieldValue.CustomFieldId = customFeild.Field.Id;
                            CustomFieldValueData.Delete<UnitProcessCustomFieldValue>(session, val);
                        }

                        //delete unit process
                        UnitProcessData.Delete(detail, session);
                        trans.Commit();
                    }
                }
            }
        }
        protected override void LoadRegulationPrograms(UnitProcess model)
        {
            if (Properties.Get(Constants.EnableRegulatoryProgramIn) == Constants.EnableRegulatoryProgramInUnitProcess)
            {
                List<UnitProcessRegulationProgram> list = new List<UnitProcessRegulationProgram>();
                using (ISession session = RegulationProgramData.GetSession())
                {
                    list = RegulationProgramData.Get<PublicUnitProcessRegulationProgram>(p => p.UnitProcessId == model.Id).ToList<UnitProcessRegulationProgram>();
                }

                if (list != null && list.Count > 0)
                {
                    model.EpaRegulationPrograms.Clear();
                    model.RegulationPrograms.Clear();
                    model.RegulationPrograms = list;
                    foreach (UnitProcessRegulationProgram prog in list)
                    {
                        SimpleLookupItem item = LookupUtility.Get<EpaRegulationProgram>(prog.ProgramCode);
                        SimpleLookupItem it = new SimpleLookupItem();
                        it.Code = item.Code;
                        it.Value = item.Value;
                        it.Year = item.Year;
                        it.Value = string.Format("{0} - {1}", it.Code, it.Value);
                        model.EpaRegulationPrograms.Add(it);
                    }
                }
            }
            else
            {
                model.EpaRegulationPrograms = null;
                model.RegulationPrograms = null;
            }
        }
        
	}
}