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;
namespace Sleis.Service
{
    public abstract class ControlDeviceService : BaseService, IControlDeviceService
    {

        public IControlDeviceData ControlDeviceData { get; set; }        
        public IControlDevicePollutantData ControlDevicePollutantData { get; set; }
        public IEmissionUnitData EmissionUnitData { get; set; }
        public IUnitProcessData UnitProcessData { get; set; }
        public IControlDeviceIdentifierData ControlDeviceIdentifierData { get; set; }
        public IProcessEmissionService ProcessEmissionService { get; set; }
      

        public override void Init()
        {
            base.Init();
            ArgumentValidationUtility.ThrowOnNull(ControlDeviceData, "ControlDeviceData");            
            ArgumentValidationUtility.ThrowOnNull(ControlDevicePollutantData, "ControlDevicePollutantData");
            ArgumentValidationUtility.ThrowOnNull(EmissionUnitData, "EmissionUnitData");
            ArgumentValidationUtility.ThrowOnNull(UnitProcessData, "UnitProcessData");          
        }

        public abstract List<ControlDeviceModel> GetControlDeviceListByReport(int reportId);
        public abstract List<ControlDeviceModel> GetControlDeviceListByFacility(int facilityId);
        public abstract List<ControlDeviceModel> GetControlDeviceListByReport(int reportId, int pageNum, int pageSize);
        public abstract List<ControlDeviceModel> GetControlDeviceListByFacility(int facilityId, int pageNum, int pageSize);
        public abstract int CountControlDevicesByFacility(int facilityId);
        public abstract int CountControlDevicesByReport(int reportId);
        public abstract ControlDeviceModel GetControlDevice(int id);


        public abstract void Delete(ControlDeviceModel controlDevice, List<CustomFieldView> customFields);
        
        public void Update(ControlDeviceDetailView dv)
        {
            //ValidateRules(dv);
            Update(dv.Item, dv.CustomFields);
        }
        public int CheckAndRecalculateEmissions(ControlDeviceModel oldCd, ControlDeviceModel cd)
        {            
            //if list of pollutants changed at all
            if (oldCd.Pollutants.Count != cd.Pollutants.Count) 
            { 
                return ProcessEmissionService.RecalculateEmissionsByControlDevice(cd.Id); 
            }
            foreach (ControlDevicePollutant pollutant in cd.Pollutants)
            {
                //if we find one that changed, no need to continue looping.
                if (!oldCd.Pollutants.Exists(p => p.Code == pollutant.Code && p.Efficency == pollutant.Efficency))
                {
                    return ProcessEmissionService.RecalculateEmissionsByControlDevice(cd.Id);
                }
            }
            return 0; //no need to update
        }
        public List<ControlDeviceModel> GetControlDevicesByUnitProcess(int unitProcessId)
        {
            return ControlDeviceData.GetControlDevicesByUnitProcess(unitProcessId);
        }
        public List<ControlDeviceModel> GetControlDevicesByEmissionUnit(int emissionUnitId)
        {
            return ControlDeviceData.GetControlDevicesByEmissionUnit(emissionUnitId);
        }
        public abstract void Update(ControlDeviceModel controlDevice, List<CustomFieldView> customFields);
        /*{
            using (ISession session = ControlDeviceData.GetSession())
            {
                using (ITransaction trans = session.BeginTransaction())
                {
                    trans.Begin();
                    if (detail.ControlDevice.Id == 0)
                    {
                        detail.ControlDevice.IsAdd = 1;
                    }
                    ControlDeviceData.SaveOrUpdate(detail.ControlDevice,session);
                  
                    //update Epa pollutants
                    //first we need delete some data not in the passed list
                    List<PublicControlDevicePollutant> list =ControlDevicePollutantData.GetControlDevicePollutant<PublicControlDevicePollutant>(detail.ControlDevice.Id);

                    //find the common pollutants in list and user passed in list
                    List<PublicControlDevicePollutant> commons = (from d in list
                                                                  join e in detail.Pollutants
                                                                  on d.Pollutant.Code equals e.Pollutant.Code
                                                                  select d).ToList();
                    
                    foreach (PublicControlDevicePollutant pollutant in list)
                    {
                        PublicControlDevicePollutant po = commons.Find(x => x.Pollutant.Code == pollutant.Pollutant.Code);
                        if (po==null)
                        {
                            ControlDevicePollutantData.Delete<PublicControlDevicePollutant>(session, pollutant);
                        }
                    }

                    session.Flush();
                    foreach (PublicControlDevicePollutant pollutant in detail.Pollutants)
                    {
                        PublicControlDevicePollutant po = commons.Find(x => x.Pollutant.Code == pollutant.Pollutant.Code);
                        //updated
                        pollutant.Id = commons.Find(x => x.Pollutant.Code == pollutant.Pollutant.Code) == null ? 0 : list.Find(x => x.Pollutant.Code == pollutant.Pollutant.Code).Id;
                        pollutant.DeviceId = detail.ControlDevice.Id;
                        ControlDevicePollutantData.SaveOrUpdate<PublicControlDevicePollutant>(session, pollutant);
                         
                    }

                    //save customFieldValue
                    foreach (CustomFieldView customFeild in customFields)
                    {
                        ControlDeviceCustomFieldValue val = customFeild.Value.Convert<ControlDeviceCustomFieldValue>();
                        val.EntityId = detail.ControlDevice.Id;
                        val.FieldValue.CustomFieldId = customFeild.Field.Id;
                        CustomFieldValueData.UpdateOrSave<ControlDeviceCustomFieldValue>(session, val);
                        
                    }

                    trans.Commit();
                    
                } 
            }
   
        }
         */
        protected void LoadSimpleLookupItems(List<ControlDeviceModel> devices)
        {
            foreach (ControlDeviceModel cd in devices)
            {
                LoadSimpleLookupItems(cd);
            }
        }
        protected void LoadSimpleLookupItems(ControlDeviceModel model)
        {
            model.Status = LookupUtility.Get<EpaControlDeviceStatus>(model.StatusCode);
            model.Type = LookupUtility.Get<EpaControlDeviceMeasure>(model.MeasureCode);
            model.TypeCode = model.MeasureCode;
           
        }

        protected void LoadModel(ControlDeviceModel controlDevice)
        {
           
            controlDevice.RelatedEmissionUnits = EmissionUnitData.GetEmissionUnitsByControlDevice(controlDevice.Id);
            controlDevice.RelatedUnitProcesses = UnitProcessData.GetUnitProcessesByControlDevice(controlDevice.Id);
            
            //controlDevice.EmissionIdentifierName = string.Join(", ", EmissionUnitData.GetEmissionUnitIdentifiers(controlDevice.Id, reportId).ToArray());
            //controlDevice.UnitProcessIdentifierName = string.Join(", ", UnitProcessData.GetRelatedUnitProcessIdentifiers(controlDevice.Id).ToArray());
        }
        
        private void ValidateRules(ControlDeviceDetailView dv)
        {
            //added a new control device
            //check identifier uniqueness
            if (dv.Item.Id == 0)
            {
                List<PublicControlDevice> list =ControlDeviceData.Get<PublicControlDevice>(c=>c.Facility.ReportId == dv.ReportId).ToList();
                List<string> identifiers = (from d in list select d.Identifier).ToList<string>();
                if (identifiers.Contains(dv.Item.Identifier))
                {
                    throw new ApplicationException("The Identifier value must be unique for a facility.");
                }
            }

            //check pollutant code uniqueness
            List<string> dup = new List<string>();
            HashSet<string> uniq = new HashSet<string>();
            foreach(PublicControlDevicePollutant p in dv.Item.Pollutants)
            {
                if (uniq.Contains(p.Code))
                {
                    dup.Add(p.Code);
                }
                else
                {
                    uniq.Add(p.Code);
                }
            }

            if (dup.Count > 0)
            {
                string msg = string.Join(", ", dup.ToArray());
                msg = string.Format("{0} {1}", msg, dup.Count > 1 ? "are duplicate Pollutant Codes. The Pollutant Code must be unique." : "is duplicate Pollutant Code. The Pollutant Code must be unique.");
                throw new ApplicationException(msg);
            }
        }
    }
}