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;
using System.Collections;
using System.Net.Mail;
using System.IO;
using System.Web;

namespace Sleis.Service
{
	public abstract class ReportService : BaseService, IReportService
	{        
		//public IFacilityData ReportFacilityData { get; set; }
		public IReportData ReportData { get; set; }
		public IReportData PublicReportData { get; set; }

        //Moved to base service
        //public RepudiationData RepudiationData { get; set; }
        //public AmendmentRequestData AmendmentRequestData { get; set; }
		public IFacilityNaicsData FacilityNaicsData { get; set; }
		public IFacilityMailAddressData FacilityMailAddressData { get; set; }
		public IFacilitySiteAddressData FacilitySiteAddressData { get; set; }
		public IFacilityContactData FacilityContactData { get; set; }
        public IFacilityContactMethodData FacilityContactMethodData { get; set; }
        public IReleasePointService ReleasePointService { get; set; }
        public ControlDeviceService ControlDeviceService { get; set; }
        public IEmissionUnitService EmissionUnitService { get; set; }
        public UnitProcessService UnitProcessService { get; set; }
        public ProcessEmissionService ProcessEmissionService { get; set; }
        public string ReportSubmissionSuccessEmailTemplate { get; set; }

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

			//ArgumentValidationUtility.ThrowOnNull(ReportFacilityData, "ReporFacilityData");
			ArgumentValidationUtility.ThrowOnNull(FacilityNaicsData, "FacilityNaicsData");
			ArgumentValidationUtility.ThrowOnNull(FacilityMailAddressData, "FacilityMailAddrData");
			ArgumentValidationUtility.ThrowOnNull(FacilitySiteAddressData, "FacilitySiteAddrData");
			ArgumentValidationUtility.ThrowOnNull(FacilityContactData, "FacilityContactData");
            ArgumentValidationUtility.ThrowOnNull(FacilityContactMethodData, "FacilityContactMethodData");
            ArgumentValidationUtility.ThrowOnNull(ReleasePointService, "ReleasePointService");
            ArgumentValidationUtility.ThrowOnNull(PublicReportData, "PublicReportData");
            ArgumentValidationUtility.ThrowOnNull(ControlDeviceService, "ControlDeviceService");
            ArgumentValidationUtility.ThrowOnNull(EmissionUnitService, "EmissionUnitService");
            ArgumentValidationUtility.ThrowOnNull(UnitProcessService, "UnitProcessService");
            ArgumentValidationUtility.ThrowOnNull(ProcessEmissionService, "ProcessEmissionService");
            ArgumentValidationUtility.ThrowOnNull(ReportSubmissionSuccessEmailTemplate, "ReportSubmissionSuccessEmailTemplate");
		}
        public abstract void DeleteReport(int reportId);
		public abstract List<int> GetStageableReportingYears();
		public void SetReportReadyIndicator(int reportId, int readyIndicator)
		{
			PublicReportModel model = PublicReportData.GetSingle<PublicReportModel>(r => r.ReportId == reportId);
			model.ReadyIndicator = readyIndicator;
			PublicReportData.Update(model);
		}

        public void SetReportAsSubmitted(int reportId, DateTime submittedOn, ISession session)
        {
            PublicReportModel publicReport = PublicReportData.GetSingle<PublicReportModel>(r => r.ReportId == reportId);
            publicReport.SubmittedIndicator = 1;
            publicReport.ReadyIndicator = 0;
            publicReport.ReportSubmissionDate = submittedOn;
            PublicReportData.Update(publicReport, session);
            PublicFacilityModel facility = FacilityData.GetSingle<PublicFacilityModel>(f=>f.ReportId == publicReport.Id);
            AgencyReport mgrReport = ReportData.GetSingle<AgencyReport>(r => r.Id == reportId);
            if (mgrReport.ReceivedDate == null || !mgrReport.ReceivedDate.HasValue)
            {
                mgrReport.ReceivedDate = submittedOn;
                ReportData.Update(mgrReport, session);
            }
            int documentId = SessionUtility.Get<int>(Constants.LastDocumentId);
            SubmissionDocumentModel submission = PublicReportData.GetSingle<SubmissionDocumentModel>(x => x.Id == documentId);
            SubmissionCor cor = PublicReportData.GetSingle<SubmissionCor>(session, x => x.Submission.Id == submission.Id);
            Dictionary<string, object> emailArgs = new Dictionary<string, object>();
            emailArgs.Add("Name", SessionUtility.CurrentUser.FullName);
            emailArgs.Add("ReportYear", mgrReport.Number);
            emailArgs.Add("FacilityName", facility.FacName);
            emailArgs.Add("ReportSubmissionDate", submittedOn);
            emailArgs.Add("SubmissionConfirmationNumber", submission.Number);

            //using (MemoryStream doc = new MemoryStream(submission.UnsignedContent))
            //{
                //Send email            
            EmailUtility.SendArgs(SessionUtility.CurrentUser.Email, 
                ReportSubmissionSuccessEmailTemplate, 
                emailArgs, 
                new Attachment(
                    new MemoryStream(cor.SignedContent), 
                    submission.Name, 
                    submission.ContenType)
                );
            Audit(new AppEventModel(EventType.Audit, 
                SessionUtility.CurrentUser.Email, 
                "Successful report submission. Submission number: " + submission.Number,
                HttpContext.Current.Request.UserHostAddress));
            //}
        }

		public bool CompleteReview(int reportId, bool promote)
		{
			if (promote)
			{
				return ReportData.CompleteReview(reportId);
			}
			else
			{
				AgencyReport report = ReportData.GetSingle<AgencyReport>(x => x.Id == reportId);
				report.CompleteDate = DateTime.Now;                
				ReportData.Update<AgencyReport>(report);
				return true;
			}
		}

		public bool StartReport(int reportId)
		{
			return ReportData.StartReport(reportId);
		}

		public List<TotalEmissionsReportModel> GetTotalEmissionsReport(EmissionsReportType type, int reportId)
		{
			switch (type)
			{
				case EmissionsReportType.EmissionUnit:
					return (SessionUtility.CurrentUser.IsAgencyUser()) ? ReportData.GetTotalEmissionsByEmissionUnit(reportId) : PublicReportData.GetTotalEmissionsByEmissionUnit(reportId);
				case EmissionsReportType.Facility:
					return (SessionUtility.CurrentUser.IsAgencyUser()) ? ReportData.GetTotalEmissionsByFacility(reportId) : PublicReportData.GetTotalEmissionsByFacility(reportId);
				case EmissionsReportType.ReleasePoint:
					return (SessionUtility.CurrentUser.IsAgencyUser()) ? ReportData.GetTotalEmissionsByReleasePoint(reportId): PublicReportData.GetTotalEmissionsByReleasePoint(reportId);
				default:
					return null;
			}
		}


        public abstract ReportValidationView GetCompleteReport(int facilityId, int reportId);
       

		public int GetSubmittedReportsCount()
		{
			return ReportData.GetSubmittedReportsCount();
		}

		public List<SubmittedReports> GetSubmittedReports()
		{
			return ReportData.GetSubmittedReports();
		}

		public int LoadSubmittedReports(List<int> SelectedReports, out bool isError)
		{
			return ReportData.LoadSubmittedReports(SelectedReports, out isError);
		}

        public abstract FacilityView GetReportFacility(int facilityId, int reportId);
		

		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);

                    //delete all previously saved contact methods
                    FacilityContactMethodData.DeleteContactMethodsByFacility(report.Facility.Id, session);
					//save contact type
					FacilityContactData.SaveFacilityContacts(session, report.Facility.Id, report.EmissionContact,
																						report.PermitContact,
																						report.ComplianceContact);

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

					if (report.ComplianceContact.HasData)
					{
						FacilityContactMethodData.SaveFacilityContactMethods(session, report.ComplianceContact);
					}

					//save NAICS
					FacilityNaicsData.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)
						{
							//TODO: There has to be a better way, right?
							//      Otherwise we have to create a new DAO for each one of the 12 custo 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();

				}
			}
		}

		protected abstract void LoadViewModel(FacilityView model);
		


		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;

		}


		public void SaveAmendmentRequest(AmendmentRequestModel model)
		{
			using (ISession session = FacilityData.GetSession())
			{
				using (ITransaction tran = session.BeginTransaction())
				{
					AmendmentRequestData.Create(model, session);
					tran.Commit();
				}
			}
		}

		public int GenerateEmissionsReports(string selectedFacilities, bool repPublished, int repReportingYear, DateTime repDueDate, DateTime startDate, DateTime endDate)
		{
			string[] agencyFacilities = selectedFacilities.Split(',');
			int count = 0;
			foreach (string facility in agencyFacilities) {
				AgencyReport report = new AgencyReport();
				report.FacilityId = int.Parse(facility);
				report.IsPublished = repPublished ? 1 : 0;
				report.Number = repReportingYear;
				report.DueDate = repDueDate;
				report.StartDate = startDate;
				report.EndDate = endDate;
				count += ReportData.GenerateEmissionsReport(report);
			}
			return count;
		}

		public AgencyReport GetAgencyReport(int agencyFacilityId, int reportId)
		{
            if (reportId > 0)
            {
                AgencyReport report = ReportData.Get<AgencyReport>(x => x.FacilityId == agencyFacilityId && x.Id == reportId).FirstOrDefault<AgencyReport>();
                using (ISession session = FacilityData.GetSession())
                {
                    AgencyReport.LoadReportStatus(session, report);
                }
                report.PublicReport = ReportData.GetSingle<PublicReportModel>(x => x.ReportId == report.Id);
                return report;
            }
            return null; //
		}

		public void SaveAgencyReport(AgencyReport report)
		{
			using (ISession session = ReportData.GetSession())
			{
				using (ITransaction tran = session.BeginTransaction())
				{
					ReportData.SaveOrUpdate<AgencyReport>(report, session);
					tran.Commit();
				}
			}
		}
         
    }
}