using System;
using System.Text;
using System.Data;
using System.Linq;
using System.Web.Mvc;
using System.Data.Entity.Validation;
using System.Collections.Generic;
using Pilotfish.Afx.Mvc;
using Pilotfish.Afx.ViewModels;
using Pilotfish.Afx.ComponentModel;
using Pilotfish.Afx.Services.Integration;
using Pilotfish.Afx.Services.Workflows;
using Pilotfish.Afx.Services.Workflows.Entities;
using Pilotfish.Afx.Services.Forms.Entities;
using Neo.Legitimate.Common;
using Neo.Legitimate.Data.Models;
using Neo.Legitimate.ApplicationRequest.Models;
using ApplicationDocument = Neo.Legitimate.ApplicationRequest.Models.ApplicationDocument;
using ApplicationRequestDetail = Neo.Legitimate.ApplicationRequest.Models.ApplicationRequestDetail;
using Neo.Legitimate.Data;
using Pilotfish.Afx.Services.Audits;
using Neo.Legitimate.Common.Helpers;

namespace Neo.Legitimate.ApplicationRequest.Controllers
{
    public partial class ApplicationRequestController : Controller<ApplicationDatabase>
    {
        #region Constructor
        public ApplicationRequestController()
            : base(new ApplicationDatabase())
        {
        }
        #endregion

        #region Console
        public ActionResult Console(long workflowid, long itemid, short? applicationrequesttypeid, short? sourceapplicationid, long? precheckdetailid)
        {
            var consoleUrl = "~/ApplicationRequest/Console?workflowid=" + workflowid + "&itemid=" + itemid + "&t=" + DateTime.Now.Ticks;

            if (Request.QueryString["returnurl"] != null)
            {
                consoleUrl += "&returnurl=" + Request.QueryString["returnurl"];
            }

            if (itemid == -1)
            {
                consoleUrl += "&applicationrequesttypeid=" + applicationrequesttypeid + "&sourceapplicationid=" + sourceapplicationid + "&precheckdetailid=" + precheckdetailid;
            }

            //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))
            {
                var returnUrl = Convert.ToBase64String(Encoding.ASCII.GetBytes(consoleUrl));
                return Redirect(Url.Content("~/Error/ShowSecurityError?error=WORKFLOWACCESSSECURITY&workflowid=" + workflowid + "&itemid=" + itemid + "&returnUrl=" + returnUrl));
            }

            return View("Console", GetViewModelInternal(workflowid, itemid, applicationrequesttypeid, sourceapplicationid, precheckdetailid));
        }
        #endregion

        #region Save
        [HttpPost]
        public JsonResult Save(ApplicationRequestDetail value)
        {
            var changes = new List<string>();
            var auditDb = new AuditsDatabase();

            #region validate originating licence number of provided
            if (value.ExistingLicence != null && !string.IsNullOrEmpty(value.ExistingLicence.OperatingLicenceNumber))
            {

                switch (value.SourceApplicationID)
                {
                    case (short)Common.SourceApplication.NTLIS:
                        if (!value.ExistingLicence.OperatingLicenceNumber.ToUpper().StartsWith("LKNKZN"))
                        {
                            return Json(new
                            {
                                Result = "ERROR",
                                Message = "The originating licence number is not valid."
                            });
                        }
                        break;
                    case (short)Common.SourceApplication.Legitimate:
                        if (!value.ExistingLicence.OperatingLicenceNumber.ToUpper().StartsWith("LGKZN") &&
                            !value.ExistingLicence.OperatingLicenceNumber.ToUpper().StartsWith("LGTST"))
                        {
                            return Json(new
                            {
                                Result = "ERROR",
                                Message = "The originating licence number is not valid."
                            });
                        }
                        break;
                    default:
                        break;
                }
            }
            #endregion

            #region validate event start and end date for special licence
            if (value.ApplicationRequestTypeID == (short)Common.ApplicationRequestType.TemporarySpecialLicence)
            {
                //this logic must be updated in the LIR save as well if you adjust it
                if (!value.ExistingLicence.SpecialLicenceDateFrom.HasValue || !value.ExistingLicence.SpecialLicenceDateTo.HasValue)
                {
                    return Json(new
                    {
                        Result = "ERROR",
                        Message = "You have to specify the date from and date to for the special licence."
                    });
                }
                else {
                    if ((value.ExistingLicence.SpecialLicenceDateTo.Value - value.ExistingLicence.SpecialLicenceDateFrom.Value).TotalDays > 14)
                    {
                        return Json(new
                        {
                            Result = "ERROR",
                            Message = "A special licence duration is not allowed to exceed 14 days."
                        });
                    }
                    else if (value.ExistingLicence.SpecialLicenceDateTo.Value < value.ExistingLicence.SpecialLicenceDateFrom.Value)
                    {
                        return Json(new
                        {
                            Result = "ERROR",
                            Message = "The To date must be before or the same as the from date."
                        });
                    }
                }
            }
            
            #endregion

            try
            {
                if (value.ApplicationRequestDetailID == Database.NewID)
                {
                    changes.Add("New application created");

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

                    #region Applicant
                    var projDb = new ApplicationDatabase(); //don't use database context as we need the values refreshed every time
                    var existingModel = projDb.GetApplicationRequest(value.ApplicationRequestDetailID, Profile.UserID);
                    changes.AddRange(auditDb.GetEntityDifferences<ApplicationApplicantDetail>(existingModel.Applicant, value.Applicant, "ApplicationRequestDetailID"));
                    #region value.Documents
                    foreach (var document in value.Documents)
                    {
                        var blankObj = new ApplicationDocument();
                        changes.Add(string.Format("{0}, Added document{1}", "Documents", document.DocumentID));
                        changes.AddRange(auditDb.GetEntityDifferences<ApplicationDocument>(blankObj, document, "ApplicationDocumentID"));
                    }
                    #endregion
                    #endregion
                    #region value.Documents
                    foreach (var document in value.Documents)
                    {
                        var existingDocument = existingModel.Documents.Where(a => a.ApplicationDocumentID == document.ApplicationDocumentID).FirstOrDefault();
                        if (existingDocument != null)
                        {
                            changes.AddRange(auditDb.GetEntityDifferences<ApplicationDocument>(existingDocument, document, "ApplicationDocumentID"));
                        }
                    }
                    #endregion
                    #region value.Services
                    foreach (var service in value.Services)
                    {
                        var blankObj = new ApplicationServiceDetail();

                        changes.Add(string.Format("{0}, Added service type {1}", "ApplicationServiceDetails", service.ServiceTypeID));

                        changes.AddRange(auditDb.GetEntityDifferences<ApplicationServiceDetail>(blankObj, service, "ApplicationServiceDetailID"));
                    }
                    #endregion
                    #region value.Vehicles
                    var vin = (!string.IsNullOrEmpty(value.Vehicle.VIN)) ? value.Vehicle.VIN : "nothing";
                    changes.Add(string.Format("{0}, Added vehicle with VIN {1}", "ApplicationVehicleDetail", vin));
                    #endregion
                    #region value.Routes
                    foreach (var route in value.Routes)
                    {
                        var blankObj = new ApplicationRouteDetail();

                        changes.Add(string.Format("{0}, Added route {1}, {2}, {3}, {4}", "ApplicationRouteDetails", route.RouteOrigin, route.RouteDestination, route.NationalRouteNumber, route.BoardRouteNumber));
                        changes.AddRange(auditDb.GetEntityDifferences<ApplicationRouteDetail>(blankObj, route, "ApplicationRouteDetailID"));
                    }
                    #endregion
                    #region value.ApplicationVehicleDetailsInBulk
                    foreach (var bulkVehicle in value.ApplicationVehicleDetailsInBulk)
                    {
                        var blankObj = new Models.ApplicationVehicleDetailsInBulk();

                        changes.Add(string.Format("{0}, Added vehicle {1}, {2}", "ApplicationVehicleDetailsInBulk", bulkVehicle.VIN, bulkVehicle.VehicleRegistrationNumber));
                        changes.AddRange(auditDb.GetEntityDifferences<Models.ApplicationVehicleDetailsInBulk>(blankObj, bulkVehicle, "ApplicationVehicleDetailsInBulkID"));
                    }
                    #endregion

                    foreach (var document in value.Documents)
                    {
                        document.DocumentType = null;
                    }

                    Database.Insert(value);

                    var precheck = Database.Context.PrecheckDetails.FirstOrDefault(a => a.PrecheckDetailID == value.PrecheckDetailID);
                    if (precheck != null)
                    {
                        if (precheck.IsComplete == true)
                        {
                            throw new Exception("The precheck record has already been used against another application. A second application can not be started.");
                        }
                        else {
                            Database.Context.Entry(precheck).Entity.IsComplete = true;
                            Database.Context.Entry(precheck).State = System.Data.Entity.EntityState.Modified;
                        }                        
                    }
                }
                else
                {
                    var projDb = new ApplicationDatabase(); //don't use database context as we need the values refreshed every time
                    var existingModel = projDb.GetApplicationRequest(value.ApplicationRequestDetailID, 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.ApplicationRequestDetailID, "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;

                    //Do not update value.ApplicationRequestAdjudicationDecisions or value.Objections
                    value.ApplicationRequestAdjudicationDecisions = null;
                    value.Objections = null;

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

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

                    #region value.Services
                    foreach (var service in value.Services)
                    {
                        if (service.ApplicationServiceDetailID > 0)
                        {
                            Database.Update(service);

                            var exstingService = existingModel.Services.Where(a => a.ApplicationServiceDetailID == service.ApplicationServiceDetailID).FirstOrDefault();
                            changes.AddRange(auditDb.GetEntityDifferences<ApplicationServiceDetail>(exstingService, service, "ApplicationServiceDetailID"));

                        }
                        else
                        {
                            Database.Insert(service);
                            var blankObj = new ApplicationServiceDetail();

                            changes.Add(string.Format("{0}, Added service type {1}", "ApplicationServiceDetails", service.ServiceTypeID));

                            changes.AddRange(auditDb.GetEntityDifferences<ApplicationServiceDetail>(blankObj, service, "ApplicationServiceDetailID"));
                        }
                    }

                    if (value.RemovedServices != null)
                    {
                        foreach (var removedService in value.RemovedServices)
                        {
                            changes.Add(string.Format("{0}, Removed service type {1}", "ApplicationServiceDetails", removedService.ServiceTypeID));

                            var exstingService = existingModel.Services.Where(a => a.ApplicationServiceDetailID == removedService.ApplicationServiceDetailID).FirstOrDefault();
                            changes.AddRange(auditDb.GetEntityDifferences<ApplicationServiceDetail>(exstingService, removedService, "ApplicationServiceDetailID"));

                            Database.Context.Entry(removedService).State = System.Data.Entity.EntityState.Deleted;                            
                        }
                    }
                    #endregion

                    #region value.Vehicles

                    if (value.Vehicle.ApplicationRequestDetailID > 0)
                    {
                        Database.Update(value.Vehicle);
                        changes.AddRange(auditDb.GetEntityDifferences<ApplicationVehicleDetail>(existingModel.Vehicle, value.Vehicle, "ApplicationRequestDetailID"));
                    }
                    else
                    {
                        Database.Insert(value.Vehicle);
                        var vin = (!string.IsNullOrEmpty(value.Vehicle.VIN)) ? value.Vehicle.VIN : "nothing";
                        changes.Add(string.Format("{0}, Added vehicle with VIN {1}", "ApplicationVehicleDetail", vin));
                    }                    
                    #endregion

                    #region value.Routes
                    foreach (var route in value.Routes)
                    {
                        if (route.ApplicationRouteDetailID > 0)
                        {
                            Database.Update(route);

                            var exstingRoute = existingModel.Routes.Where(a => a.ApplicationRouteDetailID == route.ApplicationRouteDetailID).FirstOrDefault();
                            changes.AddRange(auditDb.GetEntityDifferences<ApplicationRouteDetail>(exstingRoute, route, "ApplicationRouteDetailID"));

                        }
                        else
                        {
                            Database.Insert(route);
                            var blankObj = new ApplicationRouteDetail();


                            changes.Add(string.Format("{0}, Added route {1}, {2}, {3}, {4}", "ApplicationRouteDetails", route.RouteOrigin, route.RouteDestination, route.NationalRouteNumber, route.BoardRouteNumber));
                            changes.AddRange(auditDb.GetEntityDifferences<ApplicationRouteDetail>(blankObj, route, "ApplicationRouteDetailID"));

                        }
                    }

                    if (value.RemovedRoutes != null)
                    {
                        foreach (var removedRoute in value.RemovedRoutes)
                        {
                            changes.Add(string.Format("{0}, Removed route {1}, {2}, {3}, {4}", "ApplicationRouteDetails", removedRoute.RouteOrigin, removedRoute.RouteDestination, removedRoute.NationalRouteNumber, removedRoute.BoardRouteNumber));

                            var exstingRoute = existingModel.Routes.Where(a => a.ApplicationRouteDetailID == removedRoute.ApplicationRouteDetailID).FirstOrDefault();
                            changes.AddRange(auditDb.GetEntityDifferences<ApplicationRouteDetail>(exstingRoute, removedRoute, "ApplicationRouteDetailID"));

                            Database.Context.Entry(removedRoute).State = System.Data.Entity.EntityState.Deleted;                            
                        }
                    }
                    #endregion

                    #region value.ApplicationVehicleDetailsInBulk
                    foreach (var bulkVehicle in value.ApplicationVehicleDetailsInBulk)
                    {
                        if (bulkVehicle.ApplicationVehicleDetailsInBulkID > 0)
                        {
                            Database.Update(bulkVehicle);

                            var exstingVehicleBulk = existingModel.ApplicationVehicleDetailsInBulk.Where(a => a.ApplicationVehicleDetailsInBulkID == bulkVehicle.ApplicationVehicleDetailsInBulkID).FirstOrDefault();
                            changes.AddRange(auditDb.GetEntityDifferences<Models.ApplicationVehicleDetailsInBulk>(exstingVehicleBulk, bulkVehicle, "ApplicationVehicleDetailsInBulkID"));

                        }
                        else
                        {
                            Database.Insert(bulkVehicle);
                            var blankObj = new Models.ApplicationVehicleDetailsInBulk();


                            changes.Add(string.Format("{0}, Added vehicle {1}, {2}", "ApplicationVehicleDetailsInBulk", bulkVehicle.VIN, bulkVehicle.VehicleRegistrationNumber));
                            changes.AddRange(auditDb.GetEntityDifferences<Models.ApplicationVehicleDetailsInBulk>(blankObj, bulkVehicle, "ApplicationVehicleDetailsInBulkID"));


                        }
                    }

                    if (value.RemovedBulkVehicles != null)
                    {
                        foreach (var bulkVehicle in value.RemovedBulkVehicles)
                        {
                            changes.Add(string.Format("{0}, Removed vehicle {1}, {2}", "ApplicationVehicleDetailsInBulk", bulkVehicle.VIN, bulkVehicle.VehicleRegistrationNumber));

                            var exstingVehicleBulk = existingModel.ApplicationVehicleDetailsInBulk.Where(a => a.ApplicationVehicleDetailsInBulkID == bulkVehicle.ApplicationVehicleDetailsInBulkID).FirstOrDefault();
                            changes.AddRange(auditDb.GetEntityDifferences<Models.ApplicationVehicleDetailsInBulk>(exstingVehicleBulk, bulkVehicle, "ApplicationVehicleDetailsInBulkID"));

                            Database.Context.Entry(bulkVehicle).State = System.Data.Entity.EntityState.Deleted;
                        }
                    }
                    #endregion

                    Database.Update(value);
                    changes.AddRange(auditDb.GetEntityDifferences<ApplicationRequestDetail>(existingModel, value, "ApplicationRequestDetailID"));

                    Database.Update(value.Applicant);
                    changes.AddRange(auditDb.GetEntityDifferences<ApplicationApplicantDetail>(existingModel.Applicant, value.Applicant, "ApplicationRequestDetailID"));

                    Database.Update(value.ExistingLicenceHolder);
                    changes.AddRange(auditDb.GetEntityDifferences<ApplicationExistingLicenceHolder>(existingModel.ExistingLicenceHolder, value.ExistingLicenceHolder, "ApplicationRequestDetailID"));

                    Database.Update(value.Contract);
                    changes.AddRange(auditDb.GetEntityDifferences<ApplicationContractDetail>(existingModel.Contract, value.Contract, "ApplicationRequestDetailID"));

                    Database.Update(value.Mode);
                    changes.AddRange(auditDb.GetEntityDifferences<ApplicationModeDetail>(existingModel.Mode, value.Mode, "ApplicationRequestDetailID"));

                    Database.Update(value.Proxy);
                    changes.AddRange(auditDb.GetEntityDifferences<ApplicationProxyDetail>(existingModel.Proxy, value.Proxy, "ApplicationRequestDetailID"));

                    #region Update existing licence details
                    value.ExistingLicence.OperatingLicenceNumber = existingModel.ExistingLicence.OperatingLicenceNumber;
                    value.ExistingLicence.OperatingLicenceIssuingBoard = existingModel.ExistingLicence.OperatingLicenceIssuingBoard;
                    value.ExistingLicence.OperatingLicenceIssueDate = existingModel.ExistingLicence.OperatingLicenceIssueDate;
                    value.ExistingLicence.OperatingLicenceExpiryDate = existingModel.ExistingLicence.OperatingLicenceExpiryDate;

                    Database.Update(value.ExistingLicence);
                    changes.AddRange(auditDb.GetEntityDifferences<ApplicationExistingLicence>(existingModel.ExistingLicence, value.ExistingLicence, "ApplicationRequestDetailID"));
                    #endregion

                }
            }
            catch (Exception ex)
            {
                return Json(new
                {
                    Result = "ERROR",
                    Message = string.Format("Error: {0}", new LegitimateDatabase().GetInnermostMessage(ex))
                });
            }

            try
            {
                //Ensure that we don't have another application, for tyhe same application type, in progress for the ol
                if (value.ApplicationRequestDetailID == Database.NewID)
                {
                    var checkDb = new ApplicationDatabase();

                    var idNumber = value.Applicant.IDNumberOrBusinessRegistrationNo;
                    var associationID = value.Applicant.VerifiedAssociationID;
                    var registrationNumber = value.Vehicle.VehicleRegistrationNumber;

                    if (ApplicationRequestHelper.IsTransferType(value.ApplicationRequestTypeID))
                    {
                        idNumber = value.ExistingLicenceHolder.IDNumberOrBusinessRegistrationNo;
                    }

                    short? serviceTypeID = null;

                    if (value.Services != null && value.Services.Count() > 0)
                    { 
                        serviceTypeID = value.Services.First().ServiceTypeID;
                    }

                    checkDb.PerformPrecheck(value.PrecheckDetailID.Value, value.ApplicationRequestTypeID, value.SourceApplicationID, value.ExistingLicence.OperatingLicenceNumber, idNumber, associationID, registrationNumber, true, Profile.UserID, value.Mode.ModeID, serviceTypeID, true);

                }

                Database.Save();
                Database.Context.Pr_ApplicationRequestPostSaveProcess(value.ApplicationRequestDetailID, Profile.UserID);

                if (changes.Count > 0)
                {
                    auditDb.WriteEntries(2 /*Application*/, 2 /*Updated*/, changes, 1000 /*ApplicationRequestDetails*/, value.ApplicationRequestDetailID, 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)
            {
                if (ex.InnerException != null)
                {
                    if (ex.InnerException.Message.Contains("IX_PrecheckDetailID"))
                    {
                        return Json(new
                        {
                            Result = "ERROR",
                            Message = "The application has already been saved against this pre-check. Please submit the original application instead."
                        });
                    }
                    else
                    {
                        return Json(new
                        {
                            Result = "ERROR",
                            Message = string.Format("Error: {0}", new LegitimateDatabase().GetInnermostMessage(ex))
                        });
                    }
                }
                else {
                    return Json(new
                    {
                        Result = "ERROR",
                        Message = string.Format("Error: {0}", new LegitimateDatabase().GetInnermostMessage(ex))
                    });
                }                
            }

            return Json(new WorkflowSaveResult
            {
                Id = value.ApplicationRequestDetailID,
                WorkflowInstanceID = (value.WorkflowInstanceID ?? 0)
            });
        }
        #endregion

        #region GetViewModelInternal
        private WorkflowConsoleViewModelBase GetViewModelInternal(long workflowid, long itemid, short? applicationrequesttypeid, short? sourceapplicationid, long? precheckdetailid, bool includeLookups = true)
        {
            var projDb = new ApplicationDatabase(); //don't use database as we need the values refreshed every time

            var value = projDb.GetApplicationRequest(itemid, 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 = new WorkflowsDatabase().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");
            }
            else {
                //remove items not needed on the fron-end
                foreach (var wts in (((WorkflowTemplate)((WorkflowInstance)vm.WorkflowInstance).WorkflowTemplate)).WorkflowTemplateSteps)
                {
                    wts.IsRequiredScript = null;
                }
            }

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

                if (!applicationrequesttypeid.HasValue || applicationrequesttypeid.Value == -1)
                {
                    applicationrequesttypeid = (short)Common.ApplicationRequestType.NewOperatingLicence;
                }

                value.ApplicationRequestTypeID = applicationrequesttypeid.Value;

                if (!sourceapplicationid.HasValue || sourceapplicationid.Value == -1)
                {
                    sourceapplicationid = (short)Common.SourceApplication.Legitimate;
                }

                value.SourceApplicationID = sourceapplicationid.Value;

                value.PrecheckDetailID = precheckdetailid.Value;
                value = projDb.AddPrecheckDetailToApplicationRequestDetail(value, Profile.UserID); //populate the application details based on the source application                
            }

            #region get defaults if new request
            if (itemid < 0)
            {
                
            }
            #endregion

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

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

                    lookups.Add(new LookupList("NewOLIDTypes", integrationStore.GetDataEntities("IDTypes", string.Empty).OrderBy(a => a.Title)));
                    lookups.Add(new LookupList("NewOLIDTypesIndividual", integrationStore.GetDataEntities("IDTypes", "IndvidualTypesOnly=1").OrderBy(a => a.Title)));
                    lookups.Add(new LookupList("NewOLModes", integrationStore.GetDataEntities("Modes", string.Empty).OrderBy(a => a.Title)));
                    lookups.Add(new LookupList("NewOLServiceTypes", integrationStore.GetDataEntities("ServiceTypes", string.Empty)));
                    lookups.Add(new LookupList("NewOLContractTypes", integrationStore.GetDataEntities("ContractTypes", string.Empty).OrderBy(a => a.Title)));
                    lookups.Add(new LookupList("NewOLPaymentTypes", integrationStore.GetDataEntities("PaymentTypes", string.Empty).OrderBy(a => a.Title)));
                    lookups.Add(new LookupList("NewOLVehicleTypes", integrationStore.GetDataEntities("VehicleTypes", string.Empty).OrderBy(a => a.Title)));
                    lookups.Add(new LookupList("NewOLBusinessTypes", integrationStore.GetDataEntities("BusinessTypes", string.Empty).OrderBy(a => a.Title)));
                    lookups.Add(new LookupList("NewOLCarryingCapacities", integrationStore.GetDataEntities("CarryingCapacities", string.Empty)));
                    lookups.Add(new LookupList("AdjudicationDecisions", integrationStore.GetDataEntities("Decisions", string.Empty).OrderBy(a => a.Title)));
                    lookups.Add(new LookupList("LicenceDurations", integrationStore.GetDataEntities("LicenceDurations", string.Empty)));                    
                }
                finally
                {
                    integrationStore.Close();
                }
            }
            #endregion

            value.RemovedRoutes = new List<ApplicationRouteDetail>();
            value.RemovedServices = new List<ApplicationServiceDetail>();
            value.RemovedBulkVehicles = new List<Models.ApplicationVehicleDetailsInBulk>();

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

            if (itemid < 0)
            {
                vm.FormChecklistResults = ChecklistHelpers.CleanChecklistResults((List<ChecklistResult>)vm.FormChecklistResults, value.ApplicationRequestTypeID, (short)projDb.GetPrecheckDetail((long)value.PrecheckDetailID).ModeID, value.IsRenewal, value.IsLtpsConversion.Value, workflowid);
                ViewBag.Title = projDb.GetApplicationRequestType(value.ApplicationRequestTypeID, false).Title + " Request Workflow Console";
            }
            else {
                ViewBag.Title = value.Description;
            }
            
            ViewBag.ApplicationRequestTypeID = value.ApplicationRequestTypeID;
            ViewBag.IsBulkVehicleApplication = value.IsBulkVehicleApplication;
            ViewBag.IsLtpsConversion = value.IsLtpsConversion;
            ViewBag.IsReadOnly = ((WorkflowInstance)vm.WorkflowInstance).WorkflowInstanceStatusID == 2; // <-- WorkflowInstanceStatusID = 2, ApplicationWorkFlow status is completed.

            return vm;
        }
        #endregion

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

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

        #region SetWorkflowTemplateDefaults
        static void SetWorkflowTemplateDefaults(ApplicationRequestDetail value, IEnumerable<WorkflowTemplateDefault> defaults)
        {
        }
        #endregion

        #region JSON endpoints
                    
        #region AddApplicationServiceDetail
        [HttpPost]
        public JsonResult AddApplicationServiceDetail(long itemid, short serviceTypeID)
        {
            return Json(new ApplicationServiceDetail { ApplicationRequestDetailID = itemid, ServiceTypeID = serviceTypeID }, JsonSerializerOptions.FormatDateTime);
        } 
        #endregion

        #region AddApplicationRankDetail
        [HttpPost]
        public JsonResult AddApplicationRankDetail(long itemid)
        {
            return Json(new ApplicationRankDetail { ApplicationRequestDetailID = itemid }, JsonSerializerOptions.FormatDateTime);
        } 
        #endregion

        #region LogPrintReceipt
        [HttpPost]
        public JsonResult LogPrintReceipt(long receiptDetailID)
        {
            var database = new ApplicationDatabase();
            var errorMessage = "";           
            var success = database.LogPrintReceipt(receiptDetailID, Profile.UserID, out errorMessage);

            var results = new
            {
                Successful = success,
                ErrorMessage = errorMessage
            };

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

        #region GetPaymentAdviceNeededData
        [HttpPost]
        public JsonResult GetPaymentAdviceNeededData(long applicationRequestDetailID)
        {
            var database = new ApplicationDatabase();
            var appData = database.GetApplicationRequestDetails(applicationRequestDetailID);
            var results = new
            {
                data = appData
            };
            return Json(results, JsonSerializerOptions.None);
        } 
        #endregion
        
        #region SaveApplicationRequestObjections
        [HttpPost]
        public JsonResult SaveApplicationRequestObjections(ApplicationRequestObjection objection)
        {
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), Securable.ApplicationsModule_ApplicationRequest_Addobjection))
            {
                throw new Exception("Security error");
            }

            return Json(new ApplicationDatabase().SaveApplicationRequestObjection(objection, Profile.UserID), JsonSerializerOptions.FormatDateTime);
        } 
        #endregion

        #region CommitAdjudicationDecision
        [HttpPost]
        public JsonResult CommitAdjudicationDecision(long applicationrequestDetailID, long adjudicationDetailID, short decisionID, int? licenceDurationID, DateTime? licenceExpiryDate, string comment)
        {
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), Securable.ApplicationsModule_ApplicationRequest_Adjudication_CaptureDecision))
            {
                throw new Exception("Security error");
            }

            var database = new LegitimateDatabase();
            var errorMessage = "";

            database.CommitAdjudicationDecision(applicationrequestDetailID, adjudicationDetailID, decisionID, licenceDurationID, licenceExpiryDate, comment, Profile.UserID, out errorMessage);

            if (String.IsNullOrEmpty(errorMessage))
            {
                return Json(new { Success = true, ErrorMessage = "" }, JsonSerializerOptions.None);
            }
            else
            {
                return Json(new { Success = false, ErrorMessage = errorMessage }, JsonSerializerOptions.None);
            }
        } 
        #endregion
        
        #region AddToAdjudication
        [HttpPost]
        public JsonResult AddToAdjudication(long applicationrequestDetailID)
        {
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), Securable.ApplicationsModule_ApplicationRequest_Adjudication_Addtoadjudication))
            {
                throw new Exception("Security error");
            }

            var database = new LegitimateDatabase();
            var errorMessage = "";

            var success = database.AddApplicationsToAdjudication(applicationrequestDetailID.ToString(), (long)Profile.UserID, out errorMessage);

            if (String.IsNullOrEmpty(errorMessage))
            {
                return Json(new { Success = true, ErrorMessage = "" }, JsonSerializerOptions.None);
            }
            else
            {
                return Json(new { Success = false, ErrorMessage = errorMessage }, JsonSerializerOptions.None);
            }
        } 
        #endregion

        #region RestartAdjudicationDecisions
        [HttpPost]
        public JsonResult RestartAdjudicationDecisions(long applicationrequestDetailID, long adjudicationDetailID)
        {
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), Securable.ApplicationsModule_ApplicationRequest_Adjudication_RestartDecisions))
            {
                throw new Exception("Security error");
            }

            var database = new LegitimateDatabase();
            var errorMessage = "";

            var success = database.RestartAdjudicationDecisions(applicationrequestDetailID, adjudicationDetailID, (long)Profile.UserID, out errorMessage);

            if (String.IsNullOrEmpty(errorMessage))
            {
                return Json(new { Success = true, ErrorMessage = "" }, JsonSerializerOptions.None);
            }
            else
            {
                return Json(new { Success = false, ErrorMessage = errorMessage }, JsonSerializerOptions.None);
            }
        }
        #endregion

        #region BypassAdjudication
        [HttpPost]
        public JsonResult BypassAdjudication(long applicationrequestDetailID, short decisionID, int? licenceDurationID, DateTime? licenceExpiryDate, DateTime actualAdjudicationDate, string comment)
        {
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), Securable.ApplicationsModule_ApplicationRequest_Adjudication_BypassAdjudication))
            {
                throw new Exception("Security error");
            }

            var database = new LegitimateDatabase();
            var errorMessage = "";

            database.BypassAdjudication(applicationrequestDetailID, decisionID, licenceDurationID, licenceExpiryDate, actualAdjudicationDate, comment, Profile.UserID, out errorMessage);

            if (String.IsNullOrEmpty(errorMessage))
            {
                return Json(new { Success = true, ErrorMessage = "" }, JsonSerializerOptions.None);
            }
            else
            {
                return Json(new { Success = false, ErrorMessage = errorMessage }, JsonSerializerOptions.None);
            }
        }
        #endregion

        #region CreateReceipt
        [HttpPost]
        public JsonResult CreateReceipt(string receiptType, int receiptNumberOfCopies, long applicationrequestDetailID)
        {
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), Securable.ApplicationsModule_Receipts))
            {
                throw new Exception("Security error");
            }

            var database = new LegitimateDatabase();
            var errorMessage = "";

            //database.CreateReceipt(applicationrequestDetailID, receiptType, receiptNumberOfCopies, Profile.UserID, out errorMessage);

            var receiptDetail = database.AddHocApplicationCreateReceipt(applicationrequestDetailID, receiptType, receiptNumberOfCopies, Profile.UserID, out errorMessage);

            if (String.IsNullOrEmpty(errorMessage))
            {
                return Json(new { Success = true, ErrorMessage = "", ReceiptDetail = receiptDetail }, JsonSerializerOptions.None);
            }
            else
            {
                return Json(new { Success = false, ErrorMessage = errorMessage, ReceiptDetail = receiptDetail }, JsonSerializerOptions.None);
            }
        }
        #endregion

        #endregion
    }
}