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 System.Linq.Expressions;

namespace Sleis.Service
{
	public abstract class FacilityService : BaseService, Sleis.Service.IFacilityService
	{

		public IFacilityEmissionReportData FacilityEmissionReportData { get; set; }
        
		public IRoleData RoleData { get; set; }
		public IFacilitySiteAddressData FacilitySiteAddressData { get; set; }
        public IFacilityMailAddressData FacilityMailAddressData { get; set; }
		public IFacilityNaicsData FacilityNaicsData { get; set; }
        public IFacilityContactData FacilityContactData { get; set; }
		public IFacilityCommentData AgencyFacilityCommentData { get; set; }
		public IFacilityIdentifierData AgencyFacilityIdentifierData { get; set; }
        public IFacilityContactMethodData FacilityContactMethodData { get; set; }
        public IAlternateNameData AlternateNameData { get; set; }
        public IControlDeviceData ControlDeviceData { get; set; }
        public IReleasePointData ReleasePointData { get; set; }
        public IEmissionUnitData EmissionUnitData { get; set; }

		public override void Init()
		{
			base.Init();
			ArgumentValidationUtility.ThrowOnNull(FacilityEmissionReportData, "FacEmisReportData");
			ArgumentValidationUtility.ThrowOnNull(RoleData, "RoleData");
			ArgumentValidationUtility.ThrowOnNull(UserData, "UserData");
			ArgumentValidationUtility.ThrowOnNull(FacilitySiteAddressData, "FacilitySiteAddressData");
			ArgumentValidationUtility.ThrowOnNull(FacilityNaicsData, "AgencyFacilityNaicsData");
			ArgumentValidationUtility.ThrowOnNull(AgencyFacilityCommentData, "AgencyFacilityCommentData");
			ArgumentValidationUtility.ThrowOnNull(AgencyFacilityIdentifierData, "AgencyFacilityIdentifierData");
            ArgumentValidationUtility.ThrowOnNull(FacilityContactData, "FacilityContactData");
            ArgumentValidationUtility.ThrowOnNull(FacilityContactMethodData, "FacilityContactMethodData");
            ArgumentValidationUtility.ThrowOnNull(ControlDeviceData, "ControlDeviceData");
            ArgumentValidationUtility.ThrowOnNull(ReleasePointData, "ReleasePointData");
            ArgumentValidationUtility.ThrowOnNull(EmissionUnitData, "EmissionUnitData");
		}
        public abstract FacilityModel GetFacility(int id);
        public abstract void SaveFacility(FacilityModel facility, FacilityAddressModel siteAddress, FacilityAddressModel mailAddress, List<CustomFieldView> customFields);
        public abstract FacilityModel GetFacilityByReport(int reportId);
        public abstract void LoadFacility(FacilityModel facility);
       
        
		public void SaveAgencyFacility(AgencyFacilityModel facility, int userId)
		{
            //FacilityData.GetReportFacility<AgencyFacilityModel>(reportId);
            facility.LastUpdated = DateTime.Now;
            facility.LastUpdatedBy = SessionUtility.CurrentUser;
            //check if identifier exists
            AgencyFacilityModel test = FacilityData.Get<AgencyFacilityModel>(x => x.FacilityIdentifier == facility.Identifier && x.IsMaster ==true).FirstOrDefault();
            if (test != null && test.Id > 0)
            {
                throw new Utility.UniqueIdentifierException("Facility Identifier must be unique.");
            }
			using (ISession session = FacilityData.GetSession())
			{
				using (ITransaction tran = session.BeginTransaction())
				{
					//save facility
					facility.IsMaster = true;
					FacilityData.SaveOrUpdate(facility, session);

					AgencyFacilityCommentModel comment = facility.Comments.FirstOrDefault() as AgencyFacilityCommentModel;
                    if (!String.IsNullOrWhiteSpace(comment.Text))
                    {
                        comment.FacilityId = facility.Id;
                        comment.UserId = userId;
                        AgencyFacilityCommentData.SaveOrUpdate(comment, session);
                    }
                    
                    if (((AgencyFacilityModel)facility).IsMaster)
                    {
                        AgencyFacilityIdentifierModel masterIden = ((AgencyFacilityModel)facility).Identifiers[0] as AgencyFacilityIdentifierModel;
                        AgencyFacilityIdentifierModel id = new AgencyFacilityIdentifierModel()
                        {
                            FacilityId = facility.Id,
                            IdentifierText = facility.Identifier,
                            ProSysCode = "SLEIS",
                            EffectiveDate = DateTime.Now,
                            CountyStateFips = masterIden.CountyStateFips
                        };
                        AgencyFacilityIdentifierData.SaveOrUpdate<AgencyFacilityIdentifierModel>(id, session);
                        //if adding new (master) facility, check to see if comment is present, and add it
                        if (!String.IsNullOrWhiteSpace(facility.Comment))
                        {
                            comment.FacilityId = facility.Id;
                            comment.UserId = userId;
                            comment.Text = facility.Comment;
                            AgencyFacilityCommentData.SaveOrUpdate(comment, session);
                        }
                    }
                    /* Primary Identifier is stored at Facility Level now. These are alt identifiers only.
					AgencyFacilityIdentifierModel iden = facility.Identifiers.FirstOrDefault() as AgencyFacilityIdentifierModel;
					iden.EffectiveDate = DateTime.Today;
					iden.EndDate = null;
					iden.FacilityId = facility.Id;
					AgencyFacilityIdentifierData.SaveOrUpdate(iden, session);
                    */
					//save NAICS
					if (facility.Naics != null)
					{
						FacilityNaicsData.SaveOrUpdate(session, facility.Id, facility.Naics);
					}

					//commit
					tran.Commit();

				}
			}
		}

		public List<AgencyFacilityModel> GetFacilitiesByCategoriesAndYears(string[] categoryCodes, int[] years, bool hasNullCategoryCode, bool hasNoReportsSubmitted)
		{
            List<AgencyFacilityModel> facility = FacilityData.GetFacilitiesByCategoriesAndYears(categoryCodes, years, hasNullCategoryCode, hasNoReportsSubmitted);
			foreach (AgencyFacilityModel fac in facility)
			{
				fac.Category = LookupUtility.Get<EpaFacilityCategory>(fac.FacilityCategory);
				fac.Status = LookupUtility.Get<EpaFacilityStatus>(fac.FacilityStatus);
			}
			return facility;
		}
       
        public FacilityModel GetFacility(int id, bool isMaster)
        {
            return FacilityData.GetById<AgencyFacilityModel>(id, isMaster);
        }
        public List<FacilityModel> GetFacilities(Expression<Func<AgencyFacilityModel, bool>> where, Expression<Func<AgencyFacilityModel, AgencyFacilityModel>> select)
        {
            return FacilityData.Get<AgencyFacilityModel>(where, select).ToList<FacilityModel>();
        }
        public List<FacilityModel> GetFacilitiesByUserId(int userId)
        {
            return FacilityData.GetUserFacilities(userId);
        }
        
		public List<CurrentUserFacility> GetFacilities(int userId)
		{
            List<FacilityModel> userFacs = GetFacilitiesByUserId(userId);

			//List<CurrentUserFacility> list = FacilityData.GetFacilities(userId);
            List<CurrentUserFacility> list = new List<CurrentUserFacility>();
			//foreach (CurrentUserFacility fac in list)
            foreach(FacilityModel fac in userFacs)
			{
                list.Add(new CurrentUserFacility()
                {
                    Report = FacilityData.GetReportList(fac.Id),
                    
                    Roles = RoleData.GetFacilityRoles(userId, fac.Id),
                    FacilityIdentifier = fac.FacilityIdentifier,
                    Id = fac.Id,
                    FacName = fac.FacName
                });
				//fac.Roles = RoleData.GetFacilityRoles(userId, fac.Id);
				//fac.Report = FacilityData.GetFacilityReports(userId, fac.Id);
			}

			return list;
		}
        
		//Fixed 9/2/11 public List<FacilityUserModel> GetFacilityUsers(int facilityId)
        public List<UserModel> GetFacilityUsers(int facilityId)
		{
			List<UserModel> list = new List<UserModel>();

			foreach (UserModel user in UserData.GetFacilityUsers(facilityId))
			{
				//FacilityUserModel model = new FacilityUserModel(user.Id, user.FullName);
				//TODO: There may be a way to load this from a join in SQL?
				user.Roles = RoleData.GetFacilityRoles(user.Id, facilityId);
				user.Status = user.Status;
				list.Add(user);
			}

			return list;
		}

		public AgencyReport GetFacilityEmissionReport(int facilityId, int reportId)
		{
            if (facilityId > 0 && reportId > 0)
            {
                return FacilityData.GetReport(facilityId, reportId);
            }
            else
            {
                return null;
            }
		}

		public void AddFacilityEmissionReport(AgencyReport report)
		{
			if (report.Status == ReportStatus.NotStarted)
			{
				using (ISession session = FacilityEmissionReportData.GetSession())
				{
					using (ITransaction trans = session.BeginTransaction())
					{
						PublicReportModel publicReport = new PublicReportModel();
						publicReport.ReportId = report.Id;
						FacilityEmissionReportData.SaveOrUpdate(publicReport);
						trans.Commit();
						report.Status = ReportStatus.InProcess;
					}
				}
			}
		}
	}
}