using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Mvc;
using NHibernate;
using NHibernate.Linq;
using Sleis.Models;
using Sleis.Models.CustomFields;
using Sleis.ViewModels;
using Sleis.Infrastructure;
using log4net;
using Sleis.Utility;
using Sleis.Data;

namespace Sleis.Service
{
    public class ReportFacilityService : BaseService
    {

        //public ReportFacilityData ReportFacilityData { get; set; }
        public FacilityNaicsData FacilityNacisData { get; set; }
        public FacilityMailAddressData FacilityMailAddressData { get; set; }
        public PublicFacilitySiteAddressData FacilitySiteAddressData { get; set; }
        public FacilityContactData FacilityContactData { get; set; }
        public FacilityContactMethodData FacilityContactMethodData { get; set; }
        //public CustomFieldData CustomFieldData { get; set; }
        //public CustomFieldValueData CustomFieldValueData { get; set; }

        public new void Init()
        {
            base.Init();

            //ArgumentValidationUtility.ThrowOnNull(ReportFacilityData, "ReporFacilityData");
            ArgumentValidationUtility.ThrowOnNull(FacilityNacisData, "FacilityNacisData");
            ArgumentValidationUtility.ThrowOnNull(FacilityMailAddressData, "FacilityMailAddrData");
            ArgumentValidationUtility.ThrowOnNull(FacilitySiteAddressData, "FacilitySiteAddrData");
            ArgumentValidationUtility.ThrowOnNull(FacilityContactData, "FacilityContactData");
            ArgumentValidationUtility.ThrowOnNull(FacilityContactMethodData, "FacilityContactMethodData");
            ArgumentValidationUtility.ThrowOnNull(CustomFieldData, "CustomFieldData");
            ArgumentValidationUtility.ThrowOnNull(CustomFieldValueData, "CustomFieldValueData");

        }

        public FacilityView GetReportFacility(int facilityId, int reportId)
        {
            FacilityView model = new FacilityView();
            model.Facility = FacilityData.GetReportFacility<FacilityModel>(reportId);            
			model.Facility.MailAddress = FacilityMailAddressData.GetFacilityMailAddress(model.Facility.Id);
			model.Facility.SiteAddress = FacilitySiteAddressData.GetFacilitySiteAddress(model.Facility.Id);
            model.Report = FacilityData.GetReport(facilityId, reportId);

            LoadViewModel(model);

            return model;
        }

        public void SaveReportFacility(FacilityView report)
        {

            using (ISession session = FacilityData.GetSession())
            {
                using (ITransaction tran = session.BeginTransaction())
                {
                    //save facility
                    FacilityData.SaveOrUpdate(report.Facility, session);

                    //save addresses
                    FacilitySiteAddressData.UpdateSiteAddress(session, report.Facility.Id, report.Facility.SiteAddress);
                    FacilityMailAddressData.UpdateMailAddress(session, report.Facility.Id, report.Facility.MailAddress);


                    //save contact type
                    FacilityContactData.SaveFacilityContacts(session, report.Facility.Id, report.EmissionContact,
                                                                                        report.PermitContact,
                                                                                        report.ComplianceContact);

                    //save contact connections
                    if (report.EmissionContact != null && report.EmissionContact.HasData)
                    {
                        FacilityContactMethodData.SaveFacilityContactMethods(session, report.EmissionContact);
                    }
                    if (report.PermitContact != null && report.PermitContact.HasData)
                    {
                        FacilityContactMethodData.SaveFacilityContactMethods(session, report.PermitContact);
                    }

                    if (report.ComplianceContact != null && report.ComplianceContact.HasData)
                    {
                        FacilityContactMethodData.SaveFacilityContactMethods(session, report.ComplianceContact);
                    }

                    //save NAICS
                    FacilityNacisData.SaveOrUpdate(session, report.Facility.Id, report.Facility.Naics);

                    //Custom Fields - Delete all for this facility
                    //CustomFieldValueData.Delete<FacilityCustomFieldValue>(session, report.Facility.Id);

                    //Custom Fields - Only if there are any
                    if (report.CustomFields != null)
                    {
                        foreach (CustomFieldView customFeild in report.CustomFields)
                        {
                            //Custom Fields - Only if it has any data
                            if (!customFeild.ValueIsNullOrEmpty)
                            {
                                //TODO: There has to be a better way, right?
                                //      Otherwise we have to create a new DAO for each one of the 12 custom field tables
                                FacilityCustomFieldValue facCustomField = customFeild.Value.Convert<FacilityCustomFieldValue>();

                                facCustomField.EntityId = report.Facility.Id;
                                facCustomField.FieldValue.CustomFieldId = customFeild.Field.Id;

                                session.SaveOrUpdate(facCustomField);
                            }
                        }
                    }

                    //commit
                    tran.Commit();

                }
            }
        }

        private void LoadViewModel(FacilityView model)
        {
            PublicFacilityNaicsModel naics = FacilityNacisData.GetPrimaryNaics(model.Facility.Id) as PublicFacilityNaicsModel;
            if (naics != null)
            {
                model.Facility.Naics = naics.Naics;
            }
            model.EmissionContact = GetFacilityContact(model.Facility.Id, FacilityContactType.Emissions);
            model.PermitContact = GetFacilityContact(model.Facility.Id, FacilityContactType.Permit);
            model.ComplianceContact = GetFacilityContact(model.Facility.Id, FacilityContactType.Compliance);
            //model.Facility.Location.CollectionMethodCode = LookupUtility.Get< 
            //Load custom fields for this facility
            List<CustomFieldView> customFields = new List<CustomFieldView>();

            //Get all custom fields for this type of identity
            foreach (CustomFieldModel field in CustomFieldData.Get(CustomFieldEntityType.Facility))
            {
                //Create an instance of the custom field view
                CustomFieldView fieldView = new CustomFieldView(field);
                //Set field vuew value in case this is an edit
                fieldView.Value = CustomFieldValueData.Get<FacilityCustomFieldValue>(model.Facility.Id, fieldView.Field.Id);


                if (
                    (field.LastReportingYear == 0) ||                       //End year has not been set
                    (field.LastReportingYear >= model.Report.Number) ||     //End year >= reporting year
                    (!fieldView.ValueIsNullOrEmpty)                         //Regardless of the reporting year, if the value is there
                   )
                {
                    //if the value has not been set
                    if (fieldView.Value == null)
                    {
                        fieldView.Value = new CustomFieldEntityValue();
                    }

                    customFields.Add(fieldView);

                }
            }
            //Set all views to the facilty
            model.CustomFields = customFields;

       }


        private FacilityContact GetFacilityContact(int facilityId, FacilityContactType type)
        {

            FacilityContact contact = new FacilityContact(
                FacilityContactData.GetFacilityContact(facilityId, type));

            if (contact.HasData)
            {
                contact.Contacts =
                    FacilityContactMethodData.GetFacilityContactMethods(contact.Id);
            }

            return contact;

        }



    }
}