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

namespace Sleis.Service
{
    public class AgencyProcessEmissionService : 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<AgencyFacilityModel>(reportId);
            AgencyReport report = ProcessEmissionData.GetSingle<AgencyReport>(x => x.Id == reportId);
            //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.GetUnitProcessesByAgencyReport(reportId);
            var unitProcesses = ProcessEmissionData.Get<AgencyUnitProcessListItem>(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>();
            List<ProcessEmission> list = new List<ProcessEmission>();
            foreach (var up in unitProcesses)
            {
                ProcessEmission pe = ProcessEmissionData.GetSingle<AgencyProcessEmission>(p => p.UnitProcessId == up.Id);
                //perform mock left join...
                if (pe == null)
                {
                    pe = new AgencyProcessEmission(); // TODO: refactor for agency.
                }
                pe.UnitProcess = new AgencyUnitProcess(up);
                pe.UnitProcess.EmissionUnit = EmissionUnitData.GetSingle<AgencyEmissionUnit>(e => e.Id == pe.UnitProcess.EmissionUnitId,
                                                                                  e => new AgencyEmissionUnit { 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<AgencyFacilityModel>(reportId);
            return ProcessEmissionData.Count<AgencyProcessEmissionListItem>(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)
                {
                    LoadCompleteModel(p);
                }
            }
            return processes;
        }
        public override List<ProcessEmissionListItem> GetProcessEmissionListItemsByReport(int reportId, int reportYear)
        {
            if (reportId > 0)
            {
                FacilityModel facility = FacilityData.GetReportFacility<AgencyFacilityModel>(reportId);
                List<ProcessEmissionListItem> list = new List<ProcessEmissionListItem>();
                if (facility!=null && facility.Id > 0)
                {
                    
                    return ProcessEmissionData.Get<AgencyProcessEmissionListItem>(p => p.UnitProcess.EmissionUnit.FacilityId == facility.Id && p.IsOperational(reportYear))
                                                                                .OrderBy(x=>x.UnitProcess.EmissionUnit.Identifier)
                                                                                .ThenBy(x=>x.UnitProcess.Identifier)
                                                                                .ToList<ProcessEmissionListItem>();
                }
                return list;
            }
            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<AgencyFacilityModel>(reportId);
                List<ProcessEmissionListItem> list = new List<ProcessEmissionListItem>();
                if (facility != null && facility.Id > 0)
                {
                    return ProcessEmissionData.Get<AgencyProcessEmissionListItem>(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<AgencyProcessEmissionListItem>(x => x.UnitProcess.EmissionUnit.Id == emissionUnitId).ToList<ProcessEmissionListItem>();
        }
        public override List<ProcessEmissionListItem> GetProcessEmissionListItemsByUnitProcess(int unitProcessId)
        {
            return ProcessEmissionData.Get<AgencyProcessEmissionListItem>(x => x.UnitProcess.Id == unitProcessId).ToList<ProcessEmissionListItem>();
        }
        public override ProcessEmission GetProcessEmission(int id)
        {
            ProcessEmission pe = ProcessEmissionData.GetById<AgencyProcessEmission>(id);
            LoadCompleteModel(pe);
            LoadEmissions(pe);
                    
            return pe;
        }
        public override ProcessEmission GetProcessEmission(int id, int unitProcessId)
        {
            ProcessEmission pe = new AgencyProcessEmission();
            //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<AgencyProcessEmission>(x => x.UnitProcessId == unitProcessId); }
            if (pe == null)
            {
                pe = new AgencyProcessEmission();
            }
            if (pe.UnitProcessId == 0)
            {
                pe.UnitProcessId = unitProcessId;
            }
            LoadUnitProcessDetails(pe);
            return pe;            
        }
        public override ProcessEmission GetProcessEmission(int id, UnitProcess unitProcess)
        {
            ProcessEmission pe = new AgencyProcessEmission();
            //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<AgencyProcessEmission>(x => x.UnitProcessId == unitProcess.Id); }
            if (pe == null)
            {
                pe = new AgencyProcessEmission();
            }
            else
            {
                LoadModel(pe);
            }
            if (pe.UnitProcessId == 0)
            {
                pe.UnitProcessId = unitProcess.Id;
            }            
            return pe;   
        }
        public override void LoadEmissions(ProcessEmission pe)
        {
            pe.Emissions = EmissionData.Get<AgencyEmission>(e => e.ProcessEmissionId == pe.Id).OrderBy(m => m.PollutantCode).ToList<Emission>(); //TODO: Fix this for public / agency.  
        }
        public override void LoadUnitProcessDetails(ProcessEmission processEmission)
        {
            //AgencyReport report = ReportDataSessionUtility.CurrentUserView.SelectedFacility
            if (processEmission.LastUpdatedBy != null && processEmission.LastUpdatedBy.Id > 0)
            {
                processEmission.LastUpdatedBy = UserData.GetById(processEmission.LastUpdatedBy.Id);
            }
            if (processEmission.UnitProcess == null || processEmission.UnitProcess.Id == 0)
            {
                processEmission.UnitProcess = UnitProcessData.GetById<AgencyUnitProcess>(processEmission.UnitProcessId);  //TODO REFACTOR
            }
            //calculate ControlEfficiency
            foreach (AgencyEmission 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<AgencyUnitProcess>(u => u.Id == processEmission.UnitProcessId);
            }
            processEmission.UnitProcess.Type = LookupUtility.Get<EpaUnitProcessClass>(processEmission.UnitProcess.UnitProcessClassCode);
            processEmission.UnitProcess.EmissionUnit = EmissionUnitData.GetSingle<AgencyEmissionUnit>(e => e.Id == processEmission.UnitProcess.EmissionUnitId,
                                                                                  e => new AgencyEmissionUnit { 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<AgencyProcessEmission>(processEmission as AgencyProcessEmission, 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 (AgencyEmission 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.SaveOrUpdate<AgencyEmission>(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<AgencyProcessEmission>(id);
                    EmissionData.DeleteAllByProcessEmission(id, session);                    
                    trans.Commit();
                }
            }
        }
        
        /*public override int RecalculateEmissions(List<ProcessEmission> processes)
        {
            int count = 0;
            using (ISession session = ProcessEmissionData.GetSession())
            {
                foreach (ProcessEmission pe in processes)
                {
                    foreach (Emission emis in pe.Emissions)
                    {
                        EmissionCalculation cal = new EmissionCalculation
                        (
                            pe.UnitProcessId,
                            pe.Value,
                            pe.ValueUomCode,
                            emis.PollutantCode,
                            emis.CalculationMethodCode,
                            emis.Factor,
                            emis.FactorDenomenatorUomCode
                        );
                        //recalculate total emissions
                        ProcessEmissionData.CalculateEmissions(cal);
                        //set new total - TODO://Might need to check for error code....                        
                        emis.TotalEmissions = cal.TotalEmissions;

                        //save
                        EmissionData.SaveOrUpdate(emis as AgencyEmission, session);
                        count++;
                    }
                }
            }
            return count;
        }
         * */
    }
}