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

namespace Sleis.Service
{
    public class AgencyEmissionUnitService : EmissionUnitService, IEmissionUnitService
    {
        public override EmissionUnit GetEmissionUnit(int emissionUnitId)
        {
            AgencyEmissionUnit emissionUnit = new AgencyEmissionUnit();
            if (emissionUnitId > 0)
            {
                emissionUnit = EmissionUnitData.GetById<AgencyEmissionUnit>(emissionUnitId);
                emissionUnit.Facility = FacilityData.GetById<AgencyFacilityModel>(emissionUnit.FacilityId);
                LoadModel(emissionUnit as EmissionUnit, true);

                //load EmissionUnitRegulationProgram
                LoadRegulationPrograms(emissionUnit);
                emissionUnit.ControlApproach = ControlApproachData.GetSingle<AgencyEmissionUnitControlApproach>(a => a.EmissionUnitId == emissionUnit.Id);
                if (emissionUnit.ControlApproach != null && emissionUnit.ControlApproach.Id > 0)
                {
                    emissionUnit.ControlApproach.EntityControlDevices = ControlApproachData.Get<AgencyEmissionUnitControlDevice>(cd => cd.ControlApproachId == emissionUnit.ControlApproach.Id).OrderBy(x=>x.SequenceNumber).ToList<EntityControlDevice>();
                    foreach (AgencyEmissionUnitControlDevice cd in emissionUnit.ControlApproach.EntityControlDevices)
                    {
                        cd.ControlDevice = ControlDeviceData.GetSingle<AgencyControlDevice>(c => c.Id == cd.ControlDeviceId);
                    }
                }
                emissionUnit.UnitProcessIdentifiers = UnitProcessData.GetUnitProcessIdentifiers(emissionUnitId);
                emissionUnit.Identifiers = EmissionUnitIdentifierData.Get<AgencyEmissionUnitIdentifier>(x => x.EmissionUnitId == emissionUnit.Id).ToList<Identifier>();
                emissionUnit.MasterRecordComments = UnitProcessData.Get<AgencyEmissionUnitComment>(c => c.EmissionUnitId == emissionUnit.Id).ToList<Comment>();
                foreach (Comment comment in emissionUnit.MasterRecordComments)
                {
                    comment.User = UserData.GetSingle(u => u.Id == comment.UserId);
                }
            }
            return emissionUnit;
        }
        public override void Update(EmissionUnit emissionUnit, List<CustomFieldView> customFields)
        {
            EmissionUnit oldEu = GetEmissionUnit(emissionUnit.Id);
            bool isAdd = emissionUnit.Id < 1;
            using (ISession session = EmissionUnitData.GetSession())
            {
                using (ITransaction trans = session.BeginTransaction())
                {
                    emissionUnit.LastUpdated = DateTime.Now;
                    emissionUnit.LastUpdatedBy = SessionUtility.CurrentUser;
                    string masterComment = "";
                    if (((AgencyEmissionUnit)emissionUnit).IsMaster && !String.IsNullOrEmpty(emissionUnit.Comment))
                    {
                        masterComment = emissionUnit.Comment;
                        emissionUnit.Comment = "";
                    }
					if (!EmissionUnitData.IsIdentifierUnique(emissionUnit))
					{
						throw new Utility.UniqueIdentifierException("Emission Unit Identifier must be unique.");
					}

                    //bool isAdded = false;
                    
                    //update emission unit
                    EmissionUnitData.SaveOrUpdate(emissionUnit as AgencyEmissionUnit, session);

                    //update EmissionUnitControlDeviceApproach                    
                    if (Properties.Get(Constants.UseEmissionUnitControlApproach) == "true")
                    {
                        //make sure we dont save any control devices if not controlled
                        if (emissionUnit.ControlApproach.NotControlled)
                        {
                            emissionUnit.ControlApproach.Efficency = 0;
                            emissionUnit.ControlApproach.EntityControlDevices = new List<EntityControlDevice>();
                        }
                        ((AgencyEmissionUnitControlApproach)emissionUnit.ControlApproach).EmissionUnitId = emissionUnit.Id;
                        ControlApproachData.SaveOrUpdate<AgencyEmissionUnitControlApproach>(emissionUnit.ControlApproach as AgencyEmissionUnitControlApproach, session);
                        //delete all
                        EntityControlDeviceData.DeleteAllEmissionUnitRelatedByControlApproach(emissionUnit.ControlApproach.Id, session);
                        //update all changes as new.
                        foreach (AgencyEmissionUnitControlDevice pcd in emissionUnit.ControlApproach.EntityControlDevices)
                        {
                            pcd.Id = 0;// clear to make sure always saving as new
                            pcd.ControlApproachId = emissionUnit.ControlApproach.Id;
                            if (pcd.ControlDeviceId > 0)
                            {
                                EntityControlDeviceData.SaveOrUpdate<AgencyEmissionUnitControlDevice>(pcd, session);
                            }
                        }
                    }

                    //update emission regulatory programs
                    if (Properties.Get(Constants.EnableRegulatoryProgramIn) == Constants.EnableRegulatoryProgramInEmissionUnit)
                    {
                        RegulationProgramData.DeleteAllByEmissionUnit(emissionUnit.Id, session);
                        foreach (AgencyEmissionUnitRegulationProgram program in emissionUnit.RegulationPrograms)
                        {
                            program.Id = 0; //make sure always saving as new.
                            program.EmissionUnitId = emissionUnit.Id;
                            if (!String.IsNullOrWhiteSpace(program.ProgramCode))
                            {
                                RegulationProgramData.SaveOrUpdate<AgencyEmissionUnitRegulationProgram>(program, session);
                            }
                        }
                    }
                    /*
                    //delete all previously stored Ids
                    EmissionUnitIdentifierData.DeleteAllByEmissionUnit(emissionUnit.Id, session);
                    //save all ids as new
                    if (((AgencyEmissionUnit)emissionUnit).Identifiers != null)
                    {
                        foreach (AgencyEmissionUnitIdentifier id in ((AgencyEmissionUnit)emissionUnit).Identifiers)
                        {
                            id.EmissionUnitId = emissionUnit.Id;
                            EmissionUnitIdentifierData.SaveOrUpdate<AgencyEmissionUnitIdentifier>(id, session);
                        }
                    }*/
                    //add master iden on add..then it never changes
                    if (((AgencyEmissionUnit)emissionUnit).IsMaster && isAdd)
                    {
                        AgencyEmissionUnitIdentifier id = new AgencyEmissionUnitIdentifier()
                        {
                            EmissionUnitId = emissionUnit.Id,
                            IdentifierText = emissionUnit.Identifier,
                            ProSysCode = "SLEIS",
                            EffectiveDate = DateTime.Now
                        };
                        EmissionUnitIdentifierData.SaveOrUpdate<AgencyEmissionUnitIdentifier>(id, session);
                    }
                    //add comment.  We never delete these. keep a running tally.                    
                    if (((AgencyEmissionUnit)emissionUnit).IsMaster && !String.IsNullOrWhiteSpace(masterComment))
                    {
                        AgencyEmissionUnitComment comment = new AgencyEmissionUnitComment();
                        comment.Text = masterComment;
                        comment.EmissionUnitId = emissionUnit.Id;
                        comment.UserId = SessionUtility.CurrentUser.Id;
                        comment.Date = DateTime.Now;
                        EmissionUnitData.SaveOrUpdate(comment, session);
                    }
                    //save customFieldValue
                    SaveCustomFields<AgencyEmissionUnitCustomFieldValue>(customFields, emissionUnit.Id, session);
                    trans.Commit();
                }
            }
            CheckAndUpdateReleatedEmissions(oldEu, emissionUnit);
        }
        public override void Delete(EmissionUnit emissionUnit, List<CustomFieldView> customFields)
        {
            if (!EmissionUnitData.CanDelete(emissionUnit.Id) || emissionUnit.MasterEmissionUnitId.HasValue) { throw new CannotDeleteException(Properties.Get(Constants.AgencyEmissionUnitCannotDeleteMessage)); }

            FacilityModel facility = FacilityData.GetById<AgencyFacilityModel>(emissionUnit.FacilityId);
            using (ISession session = EmissionUnitData.GetSession())
            {
                using (ITransaction trans = session.BeginTransaction())
                {
                    //delete master identifiers
                    EmissionUnitIdentifierData.DeleteAllByEmissionUnit(emissionUnit.Id, session);
                    //delete master comments
                    foreach (AgencyEmissionUnitComment cmnt in ((AgencyEmissionUnit)emissionUnit).MasterRecordComments)
                    {
                        EmissionUnitData.Delete(cmnt, session);
                    }
                    //delete emission-unit -control-device
                    /*foreach (PublicEmissionUnitControlDevice device in emissionUnit.EntityControlDevice.EntityControlDevices)
                    {
                        EntityControlDeviceData.Delete<PublicEmissionUnitControlDevice>(session, device);
                    }*/
                    if (emissionUnit.ControlApproach != null)
                    {
                        foreach (AgencyEmissionUnitControlDevice device in emissionUnit.ControlApproach.EntityControlDevices)
                        {
                            EntityControlDeviceData.Delete(device, session);
                        }
                        //delete emission-unit-control-device-approach
                        ControlApproachData.Delete<AgencyEmissionUnitControlApproach>(emissionUnit.ControlApproach as AgencyEmissionUnitControlApproach, session);
                    }
                    if (emissionUnit.RegulationPrograms != null)
                    {
                        //delete emission-unit-regulatory-programs
                        foreach (AgencyEmissionUnitRegulationProgram prog in emissionUnit.RegulationPrograms)
                        {
                            RegulationProgramData.Delete(prog, session);
                        }
                    }
                    //Delete CustomFields
                    foreach (CustomFieldView customField in customFields)
                    {
                        AgencyEmissionUnitCustomFieldValue val = customField.Value.Convert<AgencyEmissionUnitCustomFieldValue>();
                        val.EntityId = emissionUnit.Id;
                        val.FieldValue.CustomFieldId = customField.Field.Id;
                        CustomFieldValueData.Delete(session, val);
                    }
                    
                    //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<AgencyEmissionUnitRegulationProgram>(p => p.EmissionUnitId == emissionUnitId)
                        select d).ToList<EmissionUnitRegulationProgram>();                
            }
        }
        public override List<EmissionUnitListItem> GetEmissionUnitListItemsByFacility(int facilityId)
        {
            return EmissionUnitData.Get<AgencyEmissionUnitListItem>(x => x.FacilityId == facilityId).ToList<EmissionUnitListItem>();
        }
        public override List<EmissionUnitListItem> GetEmissionUnitListItemsByReport(int reportId)
        {
            AgencyFacilityModel facility = FacilityData.GetSingle<AgencyFacilityModel>(x => x.ReportId == reportId);
            return GetEmissionUnitListItemsByFacility(facility.Id);
        }
        public override List<EmissionUnitListItem> GetEmissionUnitListItemsByFacility(int facilityId, int pageNum, int pageSize)
        {
            List<EmissionUnitListItem> list = EmissionUnitData.Get<AgencyEmissionUnitListItem>(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<AgencyFacilityModel>(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<AgencyEmissionUnitListItem>(x => x.FacilityId == facilityId);
        }
        public override int CountEmissionUnitsByReport(int reportId)
        {
            FacilityModel facility = FacilityData.GetReportFacility<AgencyFacilityModel>(reportId);
            if (facility != null && facility.Id > 0)
            {
                return CountEmissionUnitsByFacility(facility.Id);
            }
            throw new Exception("No facility associated with current report.");
        }
        
    }
}