using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Mvc;
using NHibernate;
using NHibernate.Linq;
using Sleis.Models;
using Sleis.ViewModels;
using Sleis.Infrastructure;
using Sleis.Service;
using Sleis.Utility;
using Sleis.Validation;
using Sleis.Validation.Attribute;

namespace Sleis.Controllers
{
    [HandleError]
    public class ReportController : BaseController
    {

        public IReportService ReportService { get; set; }
        public ValidationService ValidationService { get; set; }
		public DocumentService DocumentService { get; set; }
        public bool EnableUTMCorordinate { get; set; }
        public string ErrorOnReportFacilitySaveText { get; set; }
        

        public override void Init()
        {
            base.Init();
            ArgumentValidationUtility.ThrowOnNull(ReportService, "ReportService");
            ArgumentValidationUtility.ThrowOnEmpty(ErrorOnReportFacilitySaveText, "ErrorOnReportFacilitySaveText");
        }

        protected override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            base.OnActionExecuting(filterContext);

            TempData[Constants.GlobalErrorMessageKey] = ErrorOnReportFacilitySaveText;
            
        }
        [Authorize, HttpGet]
        public ActionResult ListAsJson(int facilityId)
        {
            //JsonResult result = new JsonResult();
            //result.Data = ReportService.
            throw new NotImplementedException();
        }
		[Authorize]
		public ActionResult Submissions()
		{
			return View();
		}

		[Authorize, HttpPost]
		public ActionResult Submissions(List<int> SelectedReports)
		{
			int count = 0;
			try
			{
				bool isError;
				count = ReportService.LoadSubmittedReports(SelectedReports, out isError);
				string message = "Loaded 1 report.";
				if (count != 1)
				{
					message = "Loaded " + count + " reports.";
				}
				if (isError)
				{
					message += " Not all reports were loaded.";
				}
				TempData[Constants.GlobalMessageKey] = new SimpleMessage(message, isError);
			}
			catch (Exception ex)
			{
				Log.Error("Forgot", ex);
				TempData[Constants.GlobalMessageKey] = new SimpleMessage(Constants.SavingDataErrorMessage, true);
			}
			return RedirectToAction("Home", "Agency");
		}

		[Authorize]
		public JsonResult GetSubmittedReports()
		{
			ListView<SubmittedReports> result = new ListView<SubmittedReports>();
			result.List = ReportService.GetSubmittedReports();
			return Json(result, JsonRequestBehavior.AllowGet);
		}

		[Authorize]
		public ActionResult TotalEmissionsReport(EmissionsReportType type, int reportId, int facilityId) 
		{
			EmissionReportView model = new EmissionReportView();
			model.ReportData = ReportService.GetTotalEmissionsReport(type, reportId);

			FacilityView facilityView = GetFacilityReportViewModel(reportId, facilityId);
			model.ReportYear = facilityView.Report.Number.ToString();
			model.FacilityName = facilityView.Facility.FacName;

			return View(model);
		}

		[Authorize]
		public ActionResult GetPdf(int Id)
		{
            SubmissionDocumentModel doc = DocumentService.View(Id);
            return File(doc.SubmissionCor!=null 
                && doc.SubmissionCor.SignedContent!=null ? doc.SubmissionCor.SignedContent : doc.UnsignedContent,
                doc.ContenType, 
                doc.Name);
		}

		[Authorize, AppFacilityRoleValidation(AppUserRoleType.AgencyEditor,AppUserRoleType.AgencyAcceptor)]
		public ActionResult ReviewComplete(int reportId, int facilityId, bool promote)
		{
			try
			{
                //validate first
                if (ValidationService.ValidateReport(
                   ReportService.GetCompleteReport(facilityId, reportId),
                   facilityId,
                   reportId).Count > 0)
                {
                    throw new Exception("The report did not pass validation, and cannot be set as Complete. Please run Validate Report for validation details.");
                }
            
				if (!ReportService.CompleteReview(reportId, promote))
				{
					throw new Exception("Complete Report unsucessful.");
				}
				TempData[Constants.GlobalMessageKey] = new SimpleMessage("Report Completed.", false);
				return RedirectToAction("Home", "Facility", new System.Web.Routing.RouteValueDictionary { { "Id", reportId }, { "facilityId", facilityId } });
			}
			catch (Exception ex)
			{
				Log.Error("Review Complete", ex);
				TempData[Constants.GlobalMessageKey] = new SimpleMessage(ex.Message, true);
				return RedirectToAction("Report", "Facility", new System.Web.Routing.RouteValueDictionary { { "Id", reportId }, { "facilityId", facilityId } });
			}
		}

		[Authorize, AppFacilityRoleValidation(AppUserRoleType.AgencyEditor, AppUserRoleType.AgencyAdmin, AppUserRoleType.FacilityAdmin, AppUserRoleType.FacilityEditor)]
		public ActionResult Start(int reportId, int facilityId)
		{
			try
			{
				if (!ReportService.StartReport(reportId))
				{
					throw new Exception("Start Report unsucessful.");
				}				
			}
			catch (Exception ex)
			{
				Log.Error("Start Report unsuccessful", ex);
				TempData[Constants.GlobalMessageKey] = new SimpleMessage(Constants.SavingDataErrorMessage, true);
                
			}
            if (SessionUtility.CurrentUser.IsAgencyUser())
            {
                return RedirectToAction("Home", "Facility", new System.Web.Routing.RouteValueDictionary { { "Id", reportId }, { "facilityId", facilityId } });                
            }
            return RedirectToAction("Report", "Facility", new System.Web.Routing.RouteValueDictionary { { "Id", reportId }, { "facilityId", facilityId } });
            
		}

		[Authorize, AppFacilityRoleValidation(AppUserRoleType.AgencyEditor)]
		public ActionResult ResetToUnderReview(int reportId, int facilityId)
		{
			try
			{
				AgencyReport report = ReportService.GetAgencyReport(facilityId, reportId);
				report.CompleteDate = null;
				ReportService.SaveAgencyReport(report);
			}
			catch (Exception ex)
			{
				Log.Error("Forgot", ex);
				TempData[Constants.GlobalMessageKey] = new SimpleMessage(Constants.SavingDataErrorMessage, true);
			}
			return RedirectToAction("Report", "Facility", new System.Web.Routing.RouteValueDictionary { { "Id", reportId }, { "facilityId", facilityId } });
		}

		[Authorize]
		public ActionResult Repudiate(int Id, int reportId, int facilityId)
		{
			FacilityView model = GetFacilityReportViewModel(reportId, facilityId);
			model.User = AppUser;
			return View(model);
		}

		[Authorize, HttpPost]
		public ActionResult Repudiate(int Id, int reportId, int facilityId, string RequestReason)
		{
			if (!string.IsNullOrWhiteSpace(RequestReason))
			{
				UserService.Audit(new AppEventModel(EventType.Audit, AppUser.User.Email, "Submit Report Repudiation Request", Request.UserHostAddress));

				RepudiateRequestModel model = new RepudiateRequestModel();
				model.RequestReason = RequestReason;
				model.SubmissionId = Id;
				model.RequestByUserId = AppUser.User.Id;
				model.RequestDate = DateTime.Now;
                model.Report = ReportService.GetAgencyReport(facilityId, reportId);
				try
				{
                    if (SessionUtility.CurrentUser.IsAgencyUser())
                    {
                        DocumentService.SetStatus(Id, SubmissionDocumentStatus.Repudiated);
                    }
                    else
                    {
                        DocumentService.SetStatus(Id, SubmissionDocumentStatus.RepudiationRequested);
                    }
					DocumentService.SaveRepudiateRequest(model);                    
					TempData[Constants.GlobalMessageKey] = new SimpleMessage("Repudiation request submitted.");
					return RedirectToAction("History", "Report", new System.Web.Routing.RouteValueDictionary { { "Id", reportId }, { "facilityId", facilityId } });
				}
				catch (Exception ex)
				{
					Log.Error("Forgot", ex);
					TempData[Constants.GlobalMessageKey] = new SimpleMessage(Constants.SavingDataErrorMessage, true);
				}
			}
			else
			{
				ViewData.ModelState.AddModelError("RequestReason", Constants.RequiredErrorMessage);
			}

			FacilityView facilityModel = GetFacilityReportViewModel(reportId, facilityId);
			facilityModel.User = AppUser;

			return View(facilityModel);
		}

		[Authorize, AppFacilityRoleValidation(AppUserRoleType.Agency), HttpGet]
		public JsonResult AgencyRepudiate(int Id)
		{
			object result; 
			try
			{
                DocumentService.RepudiateSubmissionByAgency(Id, SessionUtility.CurrentUser);
				result = new { @Id = Id, @Text = "Submission Repudiated.", @IsError = false }; 
			}
			catch (Exception ex)
			{
				Log.Error("Forgot", ex);
				result = new { @Id = Id, @Text = Constants.SavingDataErrorMessage, @IsError = true }; 
			}
			return Json(result, JsonRequestBehavior.AllowGet);
		}

		[Authorize]
		public ActionResult Amendment(int Id, int facilityId)
		{
			FacilityView model = GetFacilityReportViewModel(Id, facilityId);
			model.User = AppUser;
			return View(model);
		}

		[Authorize, HttpPost]
		public ActionResult Amendment(int Id, int facilityId, string RequestReason)
		{
			AmendmentRequestModel model = new AmendmentRequestModel();
			model.RequestReason = RequestReason;
			model.ReportId = Id;
			model.RequestByUserId = AppUser.User.Id;
			model.RequestDate = DateTime.Now;

			if (!string.IsNullOrWhiteSpace(RequestReason))
			{
				UserService.Audit(new AppEventModel(EventType.Audit, AppUser.User.Email, "Submit Report Amendment Request", Request.UserHostAddress));

				try
				{
					ReportService.SaveAmendmentRequest(model);
					TempData[Constants.GlobalMessageKey] = new SimpleMessage("Report amendment request submitted.");
					return RedirectToAction("Report", "Facility", new System.Web.Routing.RouteValueDictionary { { "Id", Id }, { "facilityId", facilityId } });
				}
				catch (Exception ex)
				{
					Log.Error("Forgot", ex);
					TempData[Constants.GlobalMessageKey] = new SimpleMessage(Constants.SavingDataErrorMessage, true);
				}
			}
			else
			{
                ViewData.ModelState.AddModelError("RequestReason", Constants.RequiredErrorMessage);
			}

			FacilityView facilityModel = GetFacilityReportViewModel(Id, facilityId);
			facilityModel.User = AppUser;            
			return View(facilityModel);
		}

		public ActionResult History(int Id, int facilityId)
		{
			FacilityView model = GetFacilityReportViewModel(Id, facilityId);
			model.User = AppUser;
			return View(model);
		}

		[Authorize, HttpGet]
		public JsonResult GetSubmissionDocumentHistory(int id)
		{
			ListView<SubmissionDocumentModel> model = new ListView<SubmissionDocumentModel>();
			model.List = DocumentService.GetSubmissionDocumentHistory(id);
			return Json(model, JsonRequestBehavior.AllowGet);
		}

        [Authorize, HttpGet]
        public JsonResult GetFacilityReports(int facilityId=0)
        {
            ListView<AgencyReport> model = new ListView<AgencyReport>();
            model.List = FacilityService.FacilityData.GetReportList(facilityId);
            return Json(model, JsonRequestBehavior.AllowGet);
        }

		[Authorize, HttpGet]
		public JsonResult GetFacilityAgencyReports(int id)
		{
			ListView<AgencyReport> model = new ListView<AgencyReport>();
			model.List = FacilityService.FacilityData.GetAgencyReportList(id);
			return Json(model, JsonRequestBehavior.AllowGet);
		}

        [Authorize]
        public ActionResult Facility(int Id, int facilityId)
        {
            FacilityView model = GetFacilityReportViewModel(Id, facilityId);
            model.User = AppUser;
			model.Fields = PageService.GetPageFields("/Facility");
            return View(model);
        }

        [Authorize,AppFacilityRoleValidation(AppUserRoleType.AgencyAdmin, AppUserRoleType.AgencyEditor, AppUserRoleType.FacilityAdmin, AppUserRoleType.FacilityEditor)]
        public ActionResult ManageFacility(int Id, int facilityId)
        {
            FacilityView model = GetFacilityReportViewModel(Id, facilityId);
            model.User = AppUser;
			model.Fields = PageService.GetPageFields("/Facility");
            foreach (FacilityContact c in model.Facility.Contacts)
            {
                //inialize blank record so row gets generated on UI
                if (c.Contacts.Count == 0)
                {
                    c.Contacts = new List<FacilityContactMethodModel>(){
                        new PublicFacilityContactMethod()
                    };
                }
            }
            return View(model);
        }

        [Authorize, HttpPost, AppFacilityRoleValidation(AppUserRoleType.AgencyEditor, AppUserRoleType.FacilityEditor)]
        public ActionResult ManageFacility(int id, int facilityId, FacilityView model, FormCollection args)
        {
            ActionResult resultView = null;
            if (SessionUtility.CurrentUser.IsAgencyUser())
            {
                TryUpdateModel<AgencyFacilityModel>(model.Facility as AgencyFacilityModel, "Facility");
            }
            else
            {
                TryUpdateModel<PublicFacilityModel>(model.Facility as PublicFacilityModel, "Facility");
            }
            model.Facility.Contacts = new List<FacilityContact>();
            model.Facility.Contacts.Add(model.EmissionContact);
            model.Facility.Contacts.Add(model.PermitContact);
            model.Facility.Contacts.Add(model.ComplianceContact);
            //This will populate the model state with the errors if any
            if (Validator.Validate(model, ModelState))
            {
                UserService.Audit(new AppEventModel(EventType.Audit, AppUser.User.Email, "Save Facility Emission Report", Request.UserHostAddress));
                try
                {                    
                    FacilityService.SaveFacility(model.Facility, model.Facility.SiteAddress, model.Facility.MailAddress, model.CustomFields);
                    TempData[Constants.GlobalMessageKey] = new SimpleMessage("The facility was successfully updated.");
                    resultView = RedirectToAction("Report", "Facility", new { id = id, facilityId = facilityId });
                }
                catch (Exception ex)
                {
                    Log.Error("Forgot", ex);
                    TempData[Constants.GlobalMessageKey] = new SimpleMessage(Constants.SavingDataErrorMessage, true);
                }
            }
            else
            {
                TempData[Constants.GlobalMessageKey] = new SimpleMessage(ErrorOnReportFacilitySaveText, true);
            }

            if (resultView == null)
            {
                model.User = AppUser;
				model.Fields = PageService.GetPageFields("/Facility");
                resultView = View(model);
            }

            return resultView;
        }

        private FacilityView GetFacilityReportViewModel(int reportId, int facilityId)
        {
            SetSelectedFacility(facilityId);
            FacilityView model = new FacilityView();//ReportService.GetReportFacility(facilityId, id);
            model.Facility = FacilityService.GetFacilityByReport(reportId);
            model.Report = ReportService.GetAgencyReport(facilityId, reportId);
            model.CustomFields = GetCustomFields(model.Facility.Id, model.Report.Number, CustomFieldEntityType.Facility);            
            return model;
        }

		[Authorize]
		public ActionResult Generate()
		{
			return View();
		}

		[Authorize, HttpPost]
		public ActionResult Generate(string selectedFacilities, bool repPublished, int repReportingYear, DateTime repDueDate)
		{
			DateTime startDate = new DateTime(repReportingYear, 1, 1);
			DateTime endDate = new DateTime(repReportingYear, 12, 31);
			int count = ReportService.GenerateEmissionsReports(selectedFacilities, repPublished, repReportingYear, repDueDate, startDate, endDate);
			TempData[Constants.GlobalMessageKey] = new SimpleMessage(string.Format("Added {0} new Emission" + (count != 1 ? "s" : "") + " Reports", count), false);
			Session["SelectedFacilities"] = null; //clear facility selection.
			return RedirectToAction("Home", "Agency");
		}

		[Authorize]
		public ActionResult Add(int agencyFacilityId)
		{
			return View();
		}

		[Authorize, HttpPost]
		public ActionResult Add(int agencyFacilityId, bool repPublished, int repReportingYear, DateTime repDueDate)
		{
			DateTime startDate = new DateTime(repReportingYear, 1, 1);
			DateTime endDate = new DateTime(repReportingYear, 12, 31);
			int count = ReportService.GenerateEmissionsReports(agencyFacilityId.ToString(), repPublished, repReportingYear, repDueDate, startDate, endDate);
			TempData[Constants.GlobalMessageKey] = new SimpleMessage(string.Format("Added {0} new Emission" + (count != 1 ? "s" : "") + " Reports", count), false);
			Session["SelectedFacilities"] = null; //clear facility selection.
			return RedirectToAction("Home", "Facility", new { facilityId = agencyFacilityId });
		}

		[Authorize,AppRoleValidation(AppUserRoleType.AgencyAdmin,AppUserRoleType.AgencyEditor)]
		public ActionResult Edit(int agencyFacilityId, int reportId)
		{
			AgencyReport model = ReportService.GetAgencyReport(agencyFacilityId, reportId);
			return View(model);
		}

		[Authorize,AppRoleValidation(AppUserRoleType.AgencyAdmin,AppUserRoleType.AgencyEditor), HttpPost]
		public ActionResult Edit(AgencyReport model, int agencyFacilityId, int reportId)
		{
			try
			{
				ReportService.SaveAgencyReport(model);
			}
			catch (Exception ex)
			{
				Log.Error("Forgot", ex);
				TempData[Constants.GlobalMessageKey] = new SimpleMessage(Constants.SavingDataErrorMessage, true);
				return View(model);
			}

			return RedirectToAction("Home", "Facility", new { id = reportId, facilityId = agencyFacilityId });
		}

    }
}