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

namespace Sleis.Service
{
    public class PublicProcessEmissionService : ProcessEmissionService, IProcessEmissionService
    {
        /// <summary>
        /// Fetches Process Emission List by Report Id.  This is a Left Join on Unit Processes. Does not fully load each object by default.
        /// </summary>
        /// <param name="reportId"></param>
        /// <returns></returns>
        public override List<ProcessEmission> GetProcessEmissionList(int reportId)
        {
            FacilityModel facility = FacilityData.GetReportFacility<PublicFacilityModel>(reportId);
            AgencyReport report = ProcessEmissionData.GetSingle<AgencyReport>(x=>x.Id == reportId);
            List<ProcessEmission> list = new List<ProcessEmission>();
            if (facility != null && facility.Id > 0)
            {
                //TODO: this is a hack right now. left join was returning a null record to the list.  Instead might be better to return a list of Unit Processes.
                //this will work for now to minimalize refactoring on the UI side.  
               // List<UnitProcess> unitProcesses = UnitProcessData.GetUnitProcessesByFacility(facility.Id);  //TODO REFACTOR
                //List<UnitProcess> unitProcesses = UnitProcessService.GetUnitProcessListByFacility(facility.Id);
                var unitProcesses = ProcessEmissionData.Get<PublicUnitProcessListItem>(p => p.EmissionUnit.FacilityId == facility.Id &&
                                                                                        ((p.EmissionUnit.Facility.FacilityStatus.ToUpper() == "OP" || p.EmissionUnit.Facility.FacilityStatusAsOfDate.Value.Year > report.Number)
                                                                                        && (p.EmissionUnit.StatusCode.ToUpper() == "OP" || p.EmissionUnit.StatusEffectiveDate.Value.Year > report.Number)
                                                                                        && (!p.LastEmissionsYear.HasValue || p.LastEmissionsYear.Value >= report.Number)
                                                                                        )).ToList<UnitProcessListItem>();
                //foreach (PublicUnitProcess up in unitProcesses)
                Parallel.ForEach(unitProcesses, up =>
                {
                    ProcessEmission pe = ProcessEmissionData.GetSingle<PublicProcessEmission>(p => p.UnitProcessId == up.Id);
                    //perform mock left join...
                    if (pe == null)
                    {
                        pe = new PublicProcessEmission();
                    }
                    pe.UnitProcess = new PublicUnitProcess(up);
                    pe.UnitProcess.EmissionUnit = EmissionUnitData.GetSingle<PublicEmissionUnit>(e => e.Id == pe.UnitProcess.EmissionUnitId,
                                                                                                  e => new PublicEmissionUnit { Id = e.Id, Identifier = e.Identifier, Description = e.Description });
                    pe.UnitProcess.EmissionIdentifier = pe.UnitProcess.EmissionUnit.Identifier;
                    pe.UnitProcess.Type = LookupUtility.Get<EpaUnitProcessClass>(pe.UnitProcess.UnitProcessClassCode);
                    LoadModel(pe);
                    list.Add(pe);
                });
            }

            //LoadModel(list);
            return list;
        }
        public override int CountProcessEmissions(int reportId)
        {
            FacilityModel facility = FacilityData.GetReportFacility<PublicFacilityModel>(reportId);
            return ProcessEmissionData.Count<PublicProcessEmissionListItem>(x=>x.UnitProcess.EmissionUnit.FacilityId == facility.Id);
        }
        /// <summary>
        /// Fetches Process Emission List by Report Id. 
        /// </summary>
        /// <param name="reportId"></param>
        /// <param name="fullyLoad">Indicates whether or not to fully load each object in the list.</param>
        /// <returns></returns>
        public override List<ProcessEmission> GetProcessEmissionList(int reportId, bool fullyLoad)
        {
            List<ProcessEmission> processes = GetProcessEmissionList(reportId);
            if (fullyLoad)
            {
                foreach (ProcessEmission p in processes)
                {
                    Decimal test = 2.3M;
                    Debug.Write(String.Format("Test default ToString(): {0}", test));
                    Debug.Write(p.WinterActivityPercent.ToString()); //Oracle seems to be adding trailing 0;
                    LoadCompleteModel(p);
                }
            }
            return processes;
        }
        public override List<ProcessEmissionListItem> GetProcessEmissionListItemsByReport(int reportId, int reportYear)
        {
            
            FacilityModel facility = FacilityData.GetReportFacility<PublicFacilityModel>(reportId);            
            //List<ProcessEmissionListItem> list = new List<ProcessEmissionListItem>();
            if (facility != null && facility.Id > 0)
            {                
                return ProcessEmissionData.Get<PublicProcessEmissionListItem>(p => p.UnitProcess.EmissionUnit.FacilityId==facility.Id && p.IsOperational(reportYear))
                    .ToList<ProcessEmissionListItem>();
               
            }
            return new List<ProcessEmissionListItem>();
        }
        public override List<ProcessEmissionListItem> GetProcessEmissionListItemsByReport(int reportId, int pageNum, int pageSize)
        {
            AgencyReport report = ProcessEmissionData.GetSingle<AgencyReport>(x=>x.Id == reportId);
            if (pageSize < 1) { pageSize = GetDefaultPageSize(); }
            if (reportId > 0)
            {
                FacilityModel facility = FacilityData.GetReportFacility<PublicFacilityModel>(reportId);
                List<ProcessEmissionListItem> list = new List<ProcessEmissionListItem>();
                if (facility != null && facility.Id > 0)
                {
                    return ProcessEmissionData.Get<PublicProcessEmissionListItem>(p => p.UnitProcess.EmissionUnit.FacilityId == facility.Id &&
                                                                                        ((p.UnitProcess.EmissionUnit.Facility.FacilityStatus.ToUpper() == "OP" || p.UnitProcess.EmissionUnit.Facility.FacilityStatusAsOfDate.Value.Year > report.Number)
                                                                                        && (p.UnitProcess.EmissionUnit.StatusCode.ToUpper() == "OP" || p.UnitProcess.EmissionUnit.StatusEffectiveDate.Value.Year > report.Number)
                                                                                        && (!p.UnitProcess.LastEmissionsYear.HasValue || p.UnitProcess.LastEmissionsYear.Value >= report.Number)
                                                                                        ),
                                                                                        o => o.Asc(p => p.UnitProcess.EmissionUnit.Identifier, d => d.UnitProcess.Identifier),
                                                                                        pageNum,
                                                                                        pageSize)
                                                                                        .ToList<ProcessEmissionListItem>();
                }
            }
            return new List<ProcessEmissionListItem>();
        }
        public override List<ProcessEmissionListItem> GetProcessEmissionListItems(int reportId, int emissionUnitId)
        {
            return ProcessEmissionData.Get<PublicProcessEmissionListItem>(x => x.UnitProcess.EmissionUnit.Id == emissionUnitId).ToList<ProcessEmissionListItem>();
        }
        public override List<ProcessEmissionListItem> GetProcessEmissionListItemsByUnitProcess(int unitProcessId)
        {
            return ProcessEmissionData.Get<PublicProcessEmissionListItem>(x => x.UnitProcess.Id == unitProcessId,
                x => new PublicProcessEmissionListItem
                {
                    Id = x.Id,
                    UnitProcess = new UnitProcessListItem
                    {
                        Id = x.UnitProcess.Id,
                        Scc = x.UnitProcess.Scc,
                        Identifier = x.UnitProcess.Identifier,
                        EmissionUnit = new PublicEmissionUnitListItem
                        {
                            Id = x.UnitProcess.EmissionUnit.Id, 
                            Identifier = x.UnitProcess.EmissionUnit.Identifier,
                            Description = x.UnitProcess.EmissionUnit.Description
                        }
                    }
                }).ToList<ProcessEmissionListItem>();
        }
        public override ProcessEmission GetProcessEmission(int id)
        {
            ProcessEmission pe = ProcessEmissionData.GetById<PublicProcessEmission>(id);
            LoadCompleteModel(pe);
            LoadEmissions(pe);             
			//calculate ControlEfficiency
			
            //LoadUnitProcessDetails(pe);
            if (pe.LastUpdatedBy != null && pe.LastUpdatedBy.Id > 0)
            {
                pe.LastUpdatedBy = UserData.GetById(pe.LastUpdatedBy.Id);
            }
            return pe;
        }
        public override void LoadEmissions(ProcessEmission pe)
        {
            pe.Emissions = EmissionData.Get<PublicEmission>(e => e.ProcessEmissionId == pe.Id).OrderBy(m => m.PollutantCode).ToList<Emission>(); //TODO: Fix this for public / agency.  
        }
        public override ProcessEmission GetProcessEmission(int id, int unitProcessId)
        {
            ProcessEmission pe = new PublicProcessEmission();
            //try and get object if id is present.
            if (id > 0) { pe = GetProcessEmission(id); }
            //try and get by unit process id since 1 to 1 relationship
            else{ pe = ProcessEmissionData.GetSingle<PublicProcessEmission>(x => x.UnitProcessId == unitProcessId); }
            if (pe == null) {
				pe = new PublicProcessEmission();				
			}
			if (pe.UnitProcessId == 0) 
            {
                pe.UnitProcessId = unitProcessId; 
            }
            LoadUnitProcessDetails(pe);
            return pe;
        }
        /// <summary>
        /// Gets Process Emission. Assumes unit process is already fully hydrated. 
        /// </summary>
        /// <param name="id"></param>
        /// <param name="unitProcess"></param>
        /// <returns></returns>
        public override ProcessEmission GetProcessEmission(int id, UnitProcess unitProcess)
        {
            ProcessEmission pe = new PublicProcessEmission();
            //try and get object if id is present.
            if (id > 0) { pe = GetProcessEmission(id); }
            //try and get by unit process id since 1 to 1 relationship
            else { pe = ProcessEmissionData.GetSingle<PublicProcessEmission>(x => x.UnitProcessId == unitProcess.Id); }
            if (pe == null)
            {
                pe = new PublicProcessEmission();
            }
            else
            {
                LoadModel(pe);
            }
            if (pe.UnitProcessId == 0)
            {
                pe.UnitProcessId = unitProcess.Id;
            }
            return pe;
        }
        public override void LoadUnitProcessDetails(ProcessEmission processEmission)
        {
            if (processEmission.UnitProcess == null || processEmission.UnitProcess.Id == 0)
            {
                processEmission.UnitProcess = UnitProcessData.GetById<PublicUnitProcess>(processEmission.UnitProcessId);  //TODO REFACTOR
            }
            //Parallel.ForEach(processEmission.Emissions, emission =>
            foreach(Emission emission in processEmission.Emissions)            
            {
                emission.ProcessEmission = processEmission;
                emission.ControlEfficiency = ProcessEmissionData.CalculateControlEfficiency(SessionUtility.CurrentReport.Number, processEmission.UnitProcessId, emission.PollutantCode);
            };
            if (processEmission.UnitProcess == null || processEmission.UnitProcess.Id < 1)
            {
                processEmission.UnitProcess = UnitProcessData.GetSingle<PublicUnitProcess>(u => u.Id == processEmission.UnitProcessId);
            }
            processEmission.UnitProcess.Type = LookupUtility.Get<EpaUnitProcessClass>(processEmission.UnitProcess.UnitProcessClassCode);
            processEmission.UnitProcess.EmissionUnit = EmissionUnitData.GetSingle<PublicEmissionUnit>(e => e.Id == processEmission.UnitProcess.EmissionUnitId,
                                                                                              e => new PublicEmissionUnit { Id = e.Id, Identifier = e.Identifier, Description = e.Description, StatusCode=e.StatusCode, StatusEffectiveDate = e.StatusEffectiveDate });
            processEmission.UnitProcess.EmissionIdentifier = processEmission.UnitProcess.EmissionUnit.Identifier;
        }
        public override ProcessEmission SaveProcessEmission(ProcessEmission processEmission, List<CustomFieldView> customFields)
        {
            using (ISession session = ProcessEmissionData.GetSession())
            {
                using (ITransaction trans = session.BeginTransaction())
                {
                    processEmission.LastUpdated = DateTime.Now;
                    processEmission.LastUpdatedBy = SessionUtility.CurrentUser;
                    //Delete related emissions if we are updating
                    if (processEmission.Id > 0)
                    {
                        EmissionData.DeleteAllByProcessEmission(processEmission.Id, session);
                        session.Flush(); //persist to DB. 
                    }

                    //set default values for save. TODO:// will need to add these to UI eventually, but right now always saving same value
                    SetProcessEmissionDefaultValues(processEmission);

                    //Create or Update process emission record
                    ProcessEmissionData.SaveOrUpdate(processEmission, session);

                    //Save related emissions always as new records, since UI will not be aware of ones that are removed, or edited.                    
                    if (processEmission.Emissions != null)
                    {
                        foreach (PublicEmission emission in processEmission.Emissions)
                        {
                            emission.ProcessEmissionId = processEmission.Id;    //set here always in case processEmission was a new record.
                            emission.Id = 0;
                            SetEmissionDefaultValues(emission);
                            //prevent empty records from saving.
                            if (!String.IsNullOrWhiteSpace(emission.PollutantCode))
                            {
                                EmissionData.Create(emission, session);
                            }
                        }
                    }
                    trans.Commit();
                    //return trans.WasCommitted;
                    return processEmission;
                }
            }

        }
        public override void DeleteProcessEmission(int id)
        {
            using (ISession session = ProcessEmissionData.GetSession())
            {
                using (ITransaction trans = session.BeginTransaction())
                {
                    trans.Begin();
                    ProcessEmissionData.Delete<PublicProcessEmission>(id);
                    EmissionData.DeleteAllByProcessEmission(id, session);
                    trans.Commit();
                }
            }
        }
        
    }
}