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 Sleis.Export ;
using System.Threading.Tasks;

namespace Sleis.Service
{
    public abstract class ReleasePointService : BaseService, Sleis.Service.IReleasePointService
    {

        public IReleasePointData ReleasePointData  { get; set; }  
        public IUnitProcessData UnitProcessData { get; set; }
        public IReleasePointIdentifierData ReleasePointIdentifierData { get; set; }
        public IEmissionUnitData EmissionUnitData { get; set; }
        public ICommentData CommentData { get; set; }

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

        public abstract List<ReleasePoint> GetReleasePoints(int reportId);
        public abstract List<Sleis.Models.ReleasePoint> GetReleasePoints(int reportId, int pageNum, int pageSize);
        public abstract List<Sleis.Models.ReleasePoint> GetReleasePointsByFacility(int facilityId, int pageNum, int pageSize);
        public abstract ReleasePoint GetReleasePoint(int reportId, int id);
        public abstract void AddReleasePoint(ReleasePoint releasePoint, List<CustomFieldView> customFields);
        public abstract bool UpdateReleasePoint(ReleasePoint releasePoint, List<CustomFieldView> customFields);
        public abstract int CountReleasePointsByFacility(int facilityId);
        public abstract int CountReleasePointsByReport(int reportId);

        public List<ReleasePoint> GetReleasePointsByUnitProcess(int unitProcessId)
        {
            return ReleasePointData.GetReleasePointsByUnitProcess(unitProcessId);
        }
        public List<ReleasePoint> GetReleasePointsByEmissionUnit(int emissionUnitId)
        {
            return ReleasePointData.GetReleasePointsByEmissionUnit(emissionUnitId);
        }
        public List<ReleasePoint> GetMasterReleasePoints(int facilityId)
        {
            List<ReleasePoint> rps = ReleasePointData.GetMasterReleasePoints(facilityId);
            foreach(AgencyReleasePoint r in rps)
            {
                r.Facility = FacilityData.GetById<AgencyFacilityModel>(r.FacilityId);
                LoadModel(r);
                r.MasterRecordComments = ReleasePointData.Get<AgencyReleasePointComment>(c => c.ReleasePointId == r.Id).ToList<Comment>();
            }

            return rps;
        }
        public List<ReleasePoint> GetOperationalMasterReleasePoints(int facilityId)
        {
            List<ReleasePoint> rps = ReleasePointData.GetMasterReleasePoints(facilityId).Where(x=>x.StatusCode.ToUpper() == "OP" || x.StatusAsOfDate.Value.Year > DateTime.Now.Year).ToList<ReleasePoint>();
            foreach (AgencyReleasePoint r in rps)
            {
                r.Facility = FacilityData.GetById<AgencyFacilityModel>(r.FacilityId);
                LoadModel(r);
                r.MasterRecordComments = ReleasePointData.Get<AgencyReleasePointComment>(c => c.ReleasePointId == r.Id).ToList<Comment>();
            }

            return rps;
        }

        /*
        public IExport Export(int reportId, int reportYear, Dictionary<string, PageFieldModel> Fields)
        {
            ReleasePointExport export = new ReleasePointExport();
            export.FieldPropertyMapping = FieldPropertyNameMapping;
            export.Fields = Fields;
 
            List<ReleasePointModel> rps = new List<ReleasePointModel>();
            foreach (SimpleReleasePointModel srp in ReleasePointData.GetReleasePoints(FacilityData.GetReportFacility<PublicFacilityModel>(reportId).Id).OrderBy(x=>x.Id))
            {
                rps.Add(GetReleasePoint(reportId,srp.Id));
                export.EntityCustomFields.Add(srp.Id,
                    GetCustomFields<ReleasePointCustomFieldValue>(srp.Id, reportYear, CustomFieldEntityType.ReleasePoint));
            }

            export.ReportingYear = reportYear ;
            export.Entity = rps;
            export.GenerateReport();
            return export;
        }
        */


		protected void LoadModel(List<ReleasePoint> list)
        {
            foreach (ReleasePoint model in list)
            {
                LoadModel(model);
            }
            //Parallel.ForEach(list, model =>LoadModel(model));            
        }
        protected void LoadModel(ReleasePoint model)
        {            
                model.Status = LookupUtility.Get<EpaReleasePointStatus>(model.StatusCode);
                model.Type = LookupUtility.Get<EpaReleasePointType>(model.TypeCode);
                //model. = string.Join(", ", UnitProcessData.GetUnitProcessIdentifiers(model.Id, reportId).ToArray()); 
                if (model.Location != null)
                {
                    model.Location.CollectionMethod = LookupUtility.Get<EpaFacilityCollectionMethod>(model.Location.CollectionMethodCode);
                    model.Location.ReferencePoint = LookupUtility.Get<EpaFacilityGeoReferencePoint>(model.Location.ReferencePointCode);
                    model.Location.ReferenceSystem = LookupUtility.Get<EpaFacilityGeodeticRefSystem>(model.Location.ReferenceSystemCode);
                }
                else
                {
                    model.Location = new GeographicLocation();
                }
        }
        public abstract void DeleteReleasePoint(int id, List<CustomFieldView> customFields);
        
        protected void CleanReleasePointValues(ReleasePoint releasePoint)
        {
            #region Massage the ReleasePoint data
            if (releasePoint.UsesFacilitySiteLocation)
            {
                //make sure location info is null
                releasePoint.Location = new GeographicLocation();
            }
            //is a stack, therefor clear fugitive fields
            if (releasePoint.TypeCode != "1")
            {
                releasePoint.FugitiveAngle = null;
                releasePoint.FugitiveHeight = null;
                releasePoint.FugitiveHeightUom = null;
                releasePoint.FugitiveLength = null;
                releasePoint.FugitiveLengthUom = null;
                releasePoint.FugitiveWidth = null;
                releasePoint.FugitiveWidthUom = null;
                releasePoint.StackHeightUomCode = "FEET";
                releasePoint.StackDiameterUomCode = "FEET";
            }
            else
            {
                //is a fugitive, clear stack fields
                releasePoint.StackDiameterMeasurement = null;
                releasePoint.StackDiameterUomCode = null;
                releasePoint.StackHeightMeasurement = null;
                releasePoint.StackHeightUomCode = null;
                releasePoint.FugitiveHeightUom = "FEET";
                releasePoint.FugitiveLengthUom = "FEET";
                releasePoint.FugitiveWidthUom = "FEET";
            }
            releasePoint.FenceLineDistanceUomCode = "FEET";

            #endregion
        }
        
       
        

    }
}