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;

namespace Sleis.Service
{
    public class AgencyFacilityService : FacilityService, IFacilityService
    {
        public override void SaveFacility(FacilityModel facility, FacilityAddressModel siteAddress, FacilityAddressModel mailAddress, List<CustomFieldView> customFields)
        {
            AgencyFacilityModel agencyFac = facility as AgencyFacilityModel;
            using (ISession session = FacilityData.GetSession())
            {
                using (ITransaction tran = session.BeginTransaction())
                {
                    facility.LastUpdated = DateTime.Now;
                    facility.LastUpdatedBy = SessionUtility.CurrentUser;
                    string masterComment = "";
                    if (agencyFac.IsMaster && !String.IsNullOrWhiteSpace(facility.Comment))
                    {
                        masterComment = agencyFac.Comment;
                        agencyFac.Comment = ""; //make sure to clear value
                    }
                    //save facility                    
                    FacilityData.SaveOrUpdate(agencyFac, session);
                    /*
                    //delete identifiers and save all idens as new
                    AgencyFacilityIdentifierData.DeleteAllByFacility(agencyFac.Id, session);
                    if (agencyFac.Identifiers != null && agencyFac.Identifiers.Count > 0)
                    {
                        foreach (AgencyFacilityIdentifierModel iden in agencyFac.Identifiers)
                        {
                            iden.Id = 0; // clear so always saves as new
                            iden.FacilityId = agencyFac.Id;
                            AgencyFacilityIdentifierData.Create<AgencyFacilityIdentifierModel>(iden, session);
                        }
                    }
                     * */
                    //add comment.  We never delete these. keep a running tally.                    
                    if (agencyFac.IsMaster && !String.IsNullOrWhiteSpace(masterComment))
                    {
                        AgencyFacilityCommentModel comment = new AgencyFacilityCommentModel();
                        comment.Text = masterComment;
                        comment.FacilityId = facility.Id;
                        comment.UserId = SessionUtility.CurrentUser.Id;
                        comment.Date = DateTime.Now;
                        AgencyFacilityCommentData.SaveOrUpdate(comment, session);
                    }

                    //save addresses
                    FacilitySiteAddressData.UpdateSiteAddress(session, agencyFac.Id, siteAddress);
                    FacilityMailAddressData.UpdateMailAddress(session, agencyFac.Id, mailAddress);
                    
                    //remove previous facility identifiers
                   
                    //remove previous facility alternate names
                    AlternateNameData.DeleteAllByFacility(agencyFac.Id, session);
                    if (agencyFac.AlternateNames != null && agencyFac.AlternateNames.Count > 0)
                    {
                        //save all alt names as new
                        foreach (AlternateName name in agencyFac.AlternateNames)
                        {
                            name.Id = 0; // clear so always saves as new.
                            name.FacilityId = agencyFac.Id;
                            AlternateNameData.SaveOrUpdate<AlternateName>(name, session);
                        }
                    }
                    //save contact connections
                    //save contact type
                    //delete all first. Save everything as new

                    
                    FacilityContactMethodData.DeleteContactMethodsByFacility(agencyFac.Id, session);
                    FacilityContactData.SaveFacilityContacts(session, agencyFac.Id, agencyFac.Contacts[0], agencyFac.Contacts[1], agencyFac.Contacts[2]);
                    
                    foreach (FacilityContact c in agencyFac.Contacts)
                    {
                        if (c.HasData)
                        {
                            FacilityContactMethodData.SaveFacilityContactMethods(session, c);
                        }
                    }  
                    
                    //save NAICS
                    FacilityNaicsData.SaveOrUpdate(session, agencyFac.Id, agencyFac.Naics);
                    //Custom Fields - Only if there are any
                    SaveCustomFields<AgencyFacilityCustomFieldValue>(customFields, agencyFac.Id, session);
                    /* Removed Per Bret 10/24/2012 iTest#1077
                    if (String.Equals(facility.FacilityStatus, "PS", StringComparison.OrdinalIgnoreCase))
                    {
                        
                        //Set Related Control Devices Status
                        List<ControlDeviceModel> controlDevs = ControlDeviceData.GetControlDevicesByFacility(facility.Id);
                        controlDevs.ForEach(x =>
                        {
                            x.StatusCode = "PS";
                            x.StatusEffectiveDate = facility.FacilityStatusAsOfDate;
                            x.LastUpdated = DateTime.Now;
                            x.LastUpdatedBy = SessionUtility.CurrentUser;
                            ControlDeviceData.Update<AgencyControlDevice>(x as AgencyControlDevice, session);
                        });
                        
                        //Set Related Release Points Status
                        List<ReleasePoint> releasePoints = ReleasePointData.GetReleasePointsByFacility(facility.Id);
                        releasePoints.ForEach(x =>
                        {
                            x.StatusCode = "PS";
                            x.StatusAsOfDate = facility.FacilityStatusAsOfDate;
                            x.LastUpdated = DateTime.Now;
                            x.LastUpdatedBy = SessionUtility.CurrentUser;
                            ControlDeviceData.Update<AgencyReleasePoint>(x as AgencyReleasePoint, session);
                        });
                        //Set Related Emission Units Status
                        List<EmissionUnit> emisUnits = EmissionUnitData.GetEmissionUnitsByFacility(facility.Id);
                        emisUnits.ForEach(x =>
                        {
                            x.StatusCode = "PS";
                            x.StatusEffectiveDate = facility.FacilityStatusAsOfDate;
                            x.LastUpdated = DateTime.Now;
                            x.LastUpdatedBy = SessionUtility.CurrentUser;
                            ControlDeviceData.Update<AgencyEmissionUnit>(x as AgencyEmissionUnit, session);
                        });
                      
                     
                    }
                     */
                    //commit
                    tran.Commit();

                }
            }
        }
        public override FacilityModel GetFacility(int id)
        {
            AgencyFacilityModel facility = FacilityData.GetById<AgencyFacilityModel>(id);
            if (facility.IsMaster)
            {
                facility.Comments = AgencyFacilityCommentData.Get(c => c.FacilityId == id).ToList<Comment>();
                foreach(Comment comment in facility.Comments)
                {
                    comment.User = UserData.GetSingle(u => u.Id == comment.UserId);
                }
                facility.AlternateNames = AlternateNameData.Get<AlternateName>(n => n.FacilityId == facility.Id);                
            }
            LoadFacility(facility);            
            return facility;
        }
        public override FacilityModel GetFacilityByReport(int reportId)
        {
            FacilityModel fac = FacilityData.GetReportFacility<AgencyFacilityModel>(reportId);
            LoadFacility(fac);
            return fac;
        }
        public override void LoadFacility(FacilityModel facility)
        {
            facility.SiteAddress = FacilitySiteAddressData.GetFacilitySiteAddress(facility.Id);
            facility.MailAddress = FacilityMailAddressData.GetFacilityMailAddress(facility.Id);
            if(facility.LastUpdatedBy!=null && facility.LastUpdatedBy.Id > 0)
            {
                facility.LastUpdatedBy = UserData.GetById(facility.LastUpdatedBy.Id);
            }
            AgencyFacilityNaicsModel naics = FacilityNaicsData.GetPrimaryNaics<AgencyFacilityNaicsModel>(facility.Id);
            if (naics != null)
            {
                facility.Naics = naics.Naics;
                facility.FacNaics = FacilityNaicsData.GetSingle<EpaFacilityNaics>(x => x.Code == naics.Naics);
            }
            List<FacilityContactModel> contacts = FacilityContactData.GetAllFacilityContacts<AgencyFacilityContact>(facility.Id).ToList<FacilityContactModel>();
            facility.Contacts = new List<FacilityContact>();
            foreach (FacilityContactModel cm in contacts)
            {
                FacilityContact fc = new FacilityContact(cm);
                if (fc.HasData)
                {
                    fc.Contacts = FacilityContactMethodData.GetFacilityContactMethods(fc.Id);
                }
                facility.Contacts.Add(fc);
            }
            if (facility.SiteAddress == null || facility.SiteAddress.Id < 1) { facility.SiteAddress = new AgencyFacilitySiteAddress(); }
            if (facility.MailAddress == null || facility.MailAddress.Id < 1) { facility.MailAddress = new AgencyFacilityMailAddress(); }
        }
    }
}