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

namespace Sleis.Service
{
    public class PublicReleasePointService : ReleasePointService, IReleasePointService
    {
        public override List<ReleasePoint> GetReleasePoints(int reportId)
        {
            List<ReleasePoint> list = ReleasePointData.GetReleasePointsByReport(reportId);
            LoadModel(list);
            return list;
        }
        public override List<ReleasePoint> GetReleasePoints(int reportId, int pageNum, int pageSize)
        {
            FacilityModel facility = FacilityData.GetReportFacility<PublicFacilityModel>(reportId);
            if (facility != null && facility.Id > 0)
            {
                return GetReleasePointsByFacility(facility.Id, pageNum, pageSize);
            }
            return new List<ReleasePoint>();
        }
        public override List<ReleasePoint> GetReleasePointsByFacility(int facilityId, int pageNum, int pageSize)
        {
            List<ReleasePoint> list = ReleasePointData.Get<PublicReleasePoint>(x => x.FacilityId == facilityId, o => o.Asc(rp => rp.Identifier), pageNum, pageSize).ToList<ReleasePoint>();
            LoadModel(list);
            return list;
        }
        public override int CountReleasePointsByFacility(int facilityId)
        {
            return ReleasePointData.Count<PublicReleasePoint>(x => x.FacilityId == facilityId);
        }
        public override int CountReleasePointsByReport(int reportId)
        {
            FacilityModel facility = FacilityData.GetReportFacility<PublicFacilityModel>(reportId);
            if (facility != null && facility.Id > 0)
            {
                return CountReleasePointsByFacility(facility.Id);
            }
            throw new Exception("No facility associated with current report.");
        }
        public override ReleasePoint GetReleasePoint(int reportId, int id)
        {
            ReleasePoint rp = ReleasePointData.GetReleasePoint(id);
            if (rp!= null && rp.Id > 0)
            {
                //TODO: Get Releated Unit Processes Based on Context
                rp.RelatedUnitProcesses = UnitProcessData.GetReleasePointUnitProcesses(reportId, id); //TODO REFACTOR 
                if (rp.LastUpdatedBy != null && rp.LastUpdatedBy.Id > 0)
                {
                    rp.LastUpdatedBy = UserData.GetById(rp.LastUpdatedBy.Id);
                }
                foreach (UnitProcess up in rp.RelatedUnitProcesses)
                {
                    up.EmissionUnit = EmissionUnitData.GetById<PublicEmissionUnit>(up.EmissionUnitId);
                    up.EmissionIdentifier = up.EmissionUnit.Identifier;
                }
                if (rp.UsesFacilitySiteLocation)
                {
                    //not needed anymore...?
                    rp.Location = FacilityData.GetById<PublicFacilityModel>(rp.FacilityId).Location;
                }
                rp.Status = LookupUtility.Get<EpaReleasePointStatus>(rp.StatusCode);
                rp.Type = LookupUtility.Get<EpaReleasePointType>(rp.TypeCode);
                
            }
            return rp;// != null ? rp : new PublicReleasePoint();
        }
        public override void AddReleasePoint(ReleasePoint releasePoint, List<CustomFieldView> customFields)
        {
            UpdateReleasePoint(releasePoint, customFields);
        }
        public override bool UpdateReleasePoint(ReleasePoint releasePoint, List<CustomFieldView> customFields)
        {
            //massage the data
            CleanReleasePointValues(releasePoint);
            using (ISession session = ReleasePointData.GetSession())
            {
                using (ITransaction trans = session.BeginTransaction())
                {
                    releasePoint.LastUpdated = DateTime.Now;
                    releasePoint.LastUpdatedBy = SessionUtility.CurrentUser;
					if (!ReleasePointData.IsIdentifierUnique(releasePoint))
					{
						throw new Utility.UniqueIdentifierException("Release Point Identifier must be unique.");
					}

                    trans.Begin();
                    ReleasePointData.SaveOrUpdate(releasePoint, session);
                    
                    //save customFieldValue
                    foreach (CustomFieldView customFeild in customFields)
                    {
                        ReleasePointCustomFieldValue val = customFeild.Value.Convert<ReleasePointCustomFieldValue>();
                        val.EntityId = releasePoint.Id;
                        val.FieldValue.CustomFieldId = customFeild.Field.Id;
                        CustomFieldValueData.UpdateOrSave<ReleasePointCustomFieldValue>(session, val);
                    }
                    trans.Commit();
                    return trans.WasCommitted;
                }
            }
        }

        public override void DeleteReleasePoint(int id, List<CustomFieldView> customFields)
        {
            
            using (ISession session = ReleasePointData.GetSession())
            {
                using (ITransaction trans = session.BeginTransaction())
                {
                    trans.Begin();
                    //check if we can delete
                    PublicReleasePoint rp = ReleasePointData.GetById<PublicReleasePoint>(id);
                    if (!rp.IsAdd || rp.MasterReleasePointId.HasValue)
                    {
                        throw new CannotDeleteException(Properties.Get(Constants.PublicReleasePointCannotDeleteMessage));
                    }
                    foreach (CustomFieldView customFeild in customFields)
                    {
                        ReleasePointCustomFieldValue val = customFeild.Value.Convert<ReleasePointCustomFieldValue>();
                        val.EntityId = id;
                        val.FieldValue.CustomFieldId = customFeild.Field.Id;
                        CustomFieldValueData.Delete<ReleasePointCustomFieldValue>(session, val);
                    }
                    ReleasePointData.Delete<PublicReleasePoint>(id, session);  //onle one record should have been deleted
                    trans.Commit();
                }
            }
            
        }

    }

}