using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Entity.Validation;
using System.Diagnostics;
using System.Net;
using System.Web.Mvc;
using System.Xml.Linq;
using System.Linq;
using Pilotfish.Afx.ComponentModel;
using Pilotfish.Afx.Mvc;
using Pilotfish.Afx.Services.Integration;
using Pilotfish.Afx.Services.Workflows;
using Pilotfish.Afx.Services.Workflows.Entities;
using Pilotfish.Afx.ViewModels;
using Neo.Legitimate.LicenceUpliftmentExtensionRequest.Models;

using System.Text;
using Neo.Legitimate.Data.Models;
using Pilotfish.Afx.Services.Audits;
using Neo.Legitimate.Common;
using Xceed.Words.NET;
using System.Drawing;
using System.IO;
using Pilotfish.Afx.Services.Documents;

namespace Neo.Legitimate.LicenceUpliftmentExtensionRequest.Controllers
{
    public class LicenceUpliftmentExtensionRequestController : Controller<LicenceExtensionDatabase>
    {
        #region Constructor
        public LicenceUpliftmentExtensionRequestController()
            : base(new LicenceExtensionDatabase())
        {
        }
        #endregion

        #region Console
        public ActionResult Console(long workflowid, long itemid, long? verifiedLicenceID, string returnUrl)
        {
            var consoleUrl = "~/LicenceUpliftmentExtensionRequest/Console?workflowid=" + workflowid + "&itemid=" + itemid + "&verifiedLicenceID=" + verifiedLicenceID + "&t=" + DateTime.Now.Ticks + (!string.IsNullOrEmpty(returnUrl) ? "&returnurl=" + returnUrl : "");

            //ensure t (ticks) parameter is present to prevent caching
            if (Request.QueryString["t"] == null)
            {
                return Redirect(consoleUrl);
            }

            var workflowDatabase = new WorkflowsDatabase();
            if (!workflowDatabase.CheckWorkflowInstanceSecurity(workflowid, itemid, Profile.UserName))
            {
                return Redirect(Url.Content("~/Error/ShowSecurityError?error=WORKFLOWACCESSSECURITY&workflowid=" + workflowid + "&itemid=" + itemid + "&returnUrl=" + Convert.ToBase64String(Encoding.ASCII.GetBytes(consoleUrl))));
            }
            
            return View("Console", GetViewModelInternal(workflowid, itemid, verifiedLicenceID));
        }
        #endregion

        #region Save
        [HttpPost]
        public JsonResult Save(Neo.Legitimate.LicenceUpliftmentExtensionRequest.Models.LicenceUpliftmentExtensionRequestDetail value)
        {
            var changes = new List<string>();
            var memberChanges = new List<string>();
            var licenceChanges = new List<string>();
            var vehicleChanges = new List<string>();
            var auditDb = new AuditsDatabase();
            var legitimateDb = new LegitimateDatabase();

            if (value.LicenceUpliftmentExtensionRequestDetailID == Database.NewID)
            {
                changes.Add("New Extension Request created");

                value.CreatedDate = DateTime.Now;
                value.CreatedByID = Profile.UserID;
                value.UpdatedDate = DateTime.Now;
                value.UpdatedByID = Profile.UserID;

                //do no update licence or member
                value.Licence = null;

                Database.Insert(value);
            }
            else
            {
                var projDb = new LicenceExtensionDatabase(); //don't use database as we need the values refreshed every time
                var existingModel = projDb.GetLicenceUpliftmentExtensionRequest(value.LicenceUpliftmentExtensionRequestDetailID, null, Profile.UserID);
                if (existingModel != null && existingModel.UpdatedDate.ToLongTimeString() != value.UpdatedDate.ToLongTimeString())
                {
                    return Json(new
                    {
                        Result = "CONFLICT",
                        Message = "The record has been modified by someone else. Please try again."
                    });
                }

                #region Check if user is allowed to edit the record at this stage
                try
                {
                    projDb.CheckSecurity(value.LicenceUpliftmentExtensionRequestDetailID, "Save", Profile.UserID);
                }
                catch (Exception ex)
                {
                    return Json(new
                    {
                        Result = "ERROR",
                        Message = new LegitimateDatabase().GetInnermostMessage(ex)
                    });
                }
                #endregion

                value.UpdatedDate = DateTime.Now;
                value.UpdatedByID = Profile.UserID;

                try
                {
                    // Make sure the object we are saving is the same is in the current context
                    var current = Database.Context.LicenceUpliftmentExtensionRequestDetails.Where(a => a.LicenceUpliftmentExtensionRequestDetailID == value.LicenceUpliftmentExtensionRequestDetailID).FirstOrDefault();
                    Database.Context.Entry(current).CurrentValues.SetValues(value);
                    Database.Context.Entry(current).State = System.Data.Entity.EntityState.Modified;


                    #region Licence
                    Database.Update(value.Licence);
                    licenceChanges.AddRange(auditDb.GetEntityDifferences<Neo.Legitimate.LicenceUpliftmentExtensionRequest.Models.Licence>(existingModel.Licence, value.Licence, "LicenceID"));
                    #endregion

                    #region Member
                    Database.Update(value.Licence.Member);
                    memberChanges.AddRange(auditDb.GetEntityDifferences<Neo.Legitimate.LicenceUpliftmentExtensionRequest.Models.Member>(existingModel.Licence.Member, value.Licence.Member, "MemberID"));
                    #endregion

                    #region value.Documents
                    foreach (var document in value.Documents)
                    {
                        Database.Update(document);

                        var existingDocument = existingModel.Documents.Where(a => a.LicenceUpliftmentExtensionRequestDocumentsID == document.LicenceUpliftmentExtensionRequestDocumentsID).FirstOrDefault();
                        if (existingDocument != null)
                        {
                            changes.AddRange(auditDb.GetEntityDifferences<LicenceUpliftmentExtensionRequestDocument>(existingDocument, document, "LicenceUpliftmentExtensionRequestDocumentsID"));
                        }
                    }
                    #endregion

                    #region Licence Issue Detail
                    Database.Update(current);
                    changes.AddRange(auditDb.GetEntityDifferences<Models.LicenceUpliftmentExtensionRequestDetail>(existingModel, value, "LicenceUpliftmentExtensionRequestDetailID"));
                #endregion
            }
                catch (Exception ex)
            {
                return Json(new
                {
                    Result = "ERROR",
                    Message = string.Format("Error: {0}", legitimateDb.GetInnermostMessage(ex))
                });
            }
        }

        try
        {
            Database.Save();
                Database.Context.Pr_LicenceExtensionPostSaveProcess(value.LicenceUpliftmentExtensionRequestDetailID);

                if (changes.Count > 0)
                {
                    auditDb.WriteEntries(2 /*Application*/, 2 /*Updated*/, changes, 1014 /*Licence Issue Details*/, value.LicenceUpliftmentExtensionRequestDetailID, Profile.UserID);
                }

                if (memberChanges.Count > 0)
                {                    
                    auditDb.WriteEntries(2 /*Application*/, 2 /*Updated*/, memberChanges, 1014 /*Licence Issue Details*/, value.LicenceUpliftmentExtensionRequestDetailID, Profile.UserID);                    
                    auditDb.WriteEntries(2 /*Application*/, 2 /*Updated*/, memberChanges, 1009 /*Member*/, value.Licence.MemberID, Profile.UserID);
                }

                if (licenceChanges.Count > 0)
                {
                    auditDb.WriteEntries(2 /*Application*/, 2 /*Updated*/, licenceChanges, 1014 /*Licence Issue Details*/, value.LicenceUpliftmentExtensionRequestDetailID, Profile.UserID);
                    auditDb.WriteEntries(2 /*Application*/, 2 /*Updated*/, licenceChanges, 1011 /*Operating Licence*/, value.Licence.LicenceID, Profile.UserID);
                }

                if (vehicleChanges.Count > 0)
                {
                    auditDb.WriteEntries(2 /*Application*/, 2 /*Updated*/, vehicleChanges, 1014 /*Licence Issue Details*/, value.LicenceUpliftmentExtensionRequestDetailID, Profile.UserID);

                    if (value.Licence != null && value.Licence.VehicleID.HasValue)
                    {
                        auditDb.WriteEntries(2 /*Application*/, 2 /*Updated*/, vehicleChanges, 1012 /*Vehicle Details*/, value.Licence.VehicleID.Value, Profile.UserID);
                    }                    
                }                
            }
            catch (DbEntityValidationException dbEx)
            {
                foreach (var validationError in dbEx.EntityValidationErrors.SelectMany(validationErrors => validationErrors.ValidationErrors))
                {
                    return Json(new
                    {
                        Result = "ERROR",
                        Message = string.Format("Property: {0} Error: {1}", validationError.PropertyName, validationError.ErrorMessage)
                    });
                }
            }
            catch (Exception ex)
            {
                var message = (ex.InnerException != null && ex.InnerException.InnerException != null) ? ex.InnerException.InnerException.Message : ex.Message;
                
                return Json(new
                {
                    Result = "ERROR",
                    Message = string.Format("Error: {0}", message)
                });
            }

            return Json(new WorkflowSaveResult
            {
                Id = value.LicenceUpliftmentExtensionRequestDetailID,
                WorkflowInstanceID = (value.WorkflowInstanceID ?? 0)
            });
        }
        #endregion
        
        #region GetViewModelInternal
        private WorkflowConsoleViewModelBase GetViewModelInternal(long workflowid, long itemid, long? verifiedLicenceID, bool includeLookups = true)
        {
            var projDb = new LicenceExtensionDatabase(); //don't use database as we need the values refreshed every time
            var workflowDatabase = new WorkflowsDatabase();

            var value = projDb.GetLicenceUpliftmentExtensionRequest(itemid, verifiedLicenceID, Profile.UserID);
            if (value == null)
            {
                throw new Exception("Error initialising object data");
            }

            if (Profile.Roles == null)
            {
                throw new Exception("Current user does not have any roles.");
            }

            var vm = workflowDatabase.GetWorkflowConsoleViewModel(workflowid, (value.WorkflowInstanceID.HasValue ? value.WorkflowInstanceID.Value : -1), itemid, Profile.UserID, Profile.Roles, Profile.WorkflowBuddies);
            if (vm == null)
            {
                throw new Exception("Error initialising view model data");
            }

            if (itemid < 0)
            {
                SetWorkflowTemplateDefaults(value, (IEnumerable<WorkflowTemplateDefault>)vm.WorkflowTemplateDefaults);
            }

            #region get defaults if new request
            if (itemid < 0)
            {
                //var integrationStore = new SqlIntegrationStore();
                //try
                //{
                //    integrationStore.Open();

                //    var employee = integrationStore.GetData("Employees", "EmployeeNumber=" + Profile.UserID).FirstNode;

                //    if (employee != null)
                //    {
                //        value.RequestedBy = employee.ToString(SaveOptions.DisableFormatting);
                //    }
                //}
                //finally
                //{
                //    integrationStore.Close();
                //}
            }
            #endregion

            #region load lookups
            var lookups = new List<LookupList>();

            if (includeLookups)
            {
                var integrationStore = new SqlIntegrationStore();
                try
                {
                    integrationStore.Open();

                    lookups.Add(new LookupList("NewOLVehicleTypes", integrationStore.GetDataEntities("VehicleTypes", string.Empty)));                    
                    lookups.Add(new LookupList("NewOLIDTypes", integrationStore.GetDataEntities("IDTypes", string.Empty)));
                    lookups.Add(new LookupList("NewOLBusinessTypes", integrationStore.GetDataEntities("BusinessTypes", string.Empty)));
                    lookups.Add(new LookupList("NewOLCarryingCapacities", integrationStore.GetDataEntities("CarryingCapacities", string.Empty)));
                }
                finally
                {
                    integrationStore.Close();
                }
            }
            #endregion

            vm.Lookups = lookups;
            vm.Value = value;

            ViewBag.Title = "Licence Extension Workflow Console";

            return vm;
        }
        #endregion

        #region GetViewModel
        [HttpGet]
        public string GetViewModel(long workflowid, long itemid, long? verifiedLicenceID)
        {
            var workflowDatabase = new WorkflowsDatabase();
            if (!workflowDatabase.CheckWorkflowInstanceSecurity(workflowid, itemid, Profile.UserName))
            {
                throw new Exception("Security error trying to access GetViewModel");
            }

            return GetViewModelInternal(workflowid, itemid, verifiedLicenceID, false).ToJson(JsonSerializerOptions.FormatDateTime);
        }
        #endregion

        #region SetWorkflowTemplateDefaults
        static void SetWorkflowTemplateDefaults(Neo.Legitimate.LicenceUpliftmentExtensionRequest.Models.LicenceUpliftmentExtensionRequestDetail value, IEnumerable<WorkflowTemplateDefault> defaults)
        {
        }
        #endregion

        #region JSON endpoints

        #region GetVerifiedOperatingLicence
        [HttpPost]
        public JsonResult GetVerifiedOperatingLicence(long licenceID, string documentNumber, bool isReprint, string reprintReason)
        {
            if (!isReprint)
            {
                if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), Securable.OperatingLicencesModule_LicenceIssueRequest_PrintLicence_Actual) && !SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), Securable.OperatingLicencesModule_LicenceIssueRequest_PrintLicence_Test))
                {
                    throw new Exception("Security error");
                }
            }
            else
            {
                if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), Securable.OperatingLicencesModule_LicenceIssueRequest_RePrintLicence))
                {
                    throw new Exception("Security error");
                }
            }            

            var database = new LegitimateDatabase();
            var errorMessage = "";
            var ol = database.UpdateOperatingLicence(licenceID, documentNumber, isReprint, reprintReason, Profile.UserID, out errorMessage);

            if (isReprint)
            {
                database.WriteAuditEntry((int)Profile.UserID, "Application", "LIR Reprint", reprintReason, false, false, "licence", licenceID);
            }
            else 
            {
                database.WriteAuditEntry((int)Profile.UserID, "Application", "LIR Print", reprintReason, false, false, "licence", licenceID);
            }

            if (errorMessage == "" && !string.IsNullOrEmpty(ol.LicenceExceptions))
            {
                errorMessage = ol.LicenceExceptions;
                ol = null;
            }

            var result = new
            {
                OperatingLicence = ol,
                ServerDate = DateTime.Now.ToString("dd MMM yyyy HH:mm"),
                ErrorMessage = errorMessage
            };

            return Json(result, JsonSerializerOptions.None);
        }
        #endregion

        #region GetOperatingLicenceDetails
        [HttpPost]
        public JsonResult GetOperatingLicenceDetails(long licenceID)
        {
            var database = new LegitimateDatabase();
            var licence = database.GetVerifiedOperatingLicence(licenceID);

            var result = new
            {
                OperatingLicence = (string.IsNullOrEmpty(licence.LicenceExceptions)) ? licence : null,
                ServerDate = DateTime.Now.ToString("dd MMM yyyy HH:mm"),
                ErrorMessage = licence.LicenceExceptions
            };

            return Json(result, JsonSerializerOptions.None);
        }
        #endregion

        #region IssueWithoutPrint
        [HttpPost]
        public JsonResult IssueWithoutPrint(long licenceID, string reason)
        {
            var database = new LegitimateDatabase();
            var errorMessage = "";

            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), Securable.OperatingLicencesModule_LicenceIssueRequest_IssueWithoutPrint))
            {
                throw new Exception("Security error");
            }

            try
            {
                database.IssueLicenceWithoutPrint(licenceID, reason, Profile.UserID);
            }
            catch (Exception ex)
            {
                errorMessage = database.GetInnermostMessage(ex);
            }

            var result = new
            {
                ErrorMessage = errorMessage
            };

            return Json(result, JsonSerializerOptions.None);
        }
        #endregion

        #endregion
    }
}