using Neo.Afx.Mvc;
using Neo.Afx.Services.Correspondence;
using Neo.Afx.Services.Integration;
using Neo.Afx.Services.Reports;
using Neo.Afx.Services.Workflows;
using Neo.Afx.ViewModels;
using Neo.LegitimateLicences.ApplicationRequest;
using Neo.LegitimateLicences.ApplicationRequest.Models.Database;
using Neo.LegitimateLicences.Common;
using Neo.LegitimateLicences.Data.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Mvc;
using AdjudicationDetail = Neo.LegitimateLicences.Data.Models.AdjudicationDetail;
using Neo.Afx.Common;
using Neo.LegitimateLicences.Logic.Helpers;

namespace Neo.LegitimateLicences.AdjudicationConsole
{
    public partial class AdjudicationConsoleController : Neo.LegitimateLicences.Common.ControllerBase
    {
        private const long ADJUDICATION_ENTITY_ID = 1007;
        private const long DOCUMENT_STORE_LOCATION_ID = 3;

        #region Console
        /// <summary>
        /// Load the main Adjudication Console
        /// </summary>
        /// <param name="adjudicationDetailID"></param>
        /// <param name="adjudicationTypeID"></param>
        /// <returns></returns>
        public ActionResult Console(long adjudicationDetailID, short? adjudicationTypeID)
        {
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), SecurableEnum.ApplicationsModule_Adjudication))
            {
                return RedirectToAction("ShowError", "Error", new { msg = "Security error" });                
            }
            
            var adjudicationType = (short)((adjudicationTypeID.HasValue) ? adjudicationTypeID.Value : 0);

            var database = new LegitimateDatabase();
            var model = new ConsoleModel()
            { 
                AdjudicationDetailID = adjudicationDetailID,
                AdjudicationDetail = database.GetAdjudicationDetail(adjudicationDetailID, adjudicationType, Profile.OfficeLocationID.Value, Profile.UserID)
            };

            ViewBag.Controller = "Adjudication Details";
            ViewBag.Page = "Adjudication Details";
            return View("Console", model);
        }
        #endregion

        #region Default
        /// <summary>
        /// Load the main Adjudication details view
        /// </summary>
        /// <param name="adjudicationDetailID"></param>
        /// <param name="adjudicationTypeID"></param>
        /// <returns></returns>
        public ActionResult Default(long adjudicationDetailID, short? adjudicationTypeID)
        {
            #region Securable Check
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), SecurableEnum.ApplicationsModule_Adjudication))
            {
                return RedirectToAction("ShowError", "Error", new { msg = "Security error" });
            }
            #endregion

            var database = new LegitimateDatabase();
            var adjudicationType = (short)((adjudicationTypeID.HasValue) ? adjudicationTypeID.Value : 0);

            var model = new DefaultModel
            {
                AdjudicationDetail = database.GetAdjudicationDetail(adjudicationDetailID, adjudicationType, Profile.OfficeLocationID.Value, Profile.UserID),
                OfficeLocations = database.GetOfficeLocations(Profile.UserID),
                AdjudicationTypes = database.GetAdjudicationTypes()
            };

            model.IsAdjudicationDetailsLinkVisible = true;
            model.IsPanelLinkVisible = model.AdjudicationDetail.AdjudicationDetailID > 0 && model.AdjudicationDetail.AdjudicationDetailStatusID != 1;
            model.IsApplicationsLinkVisible = model.AdjudicationDetail.AdjudicationDetailID > 0;

            ViewBag.Controller = "Adjudication Details";
            ViewBag.Page = "Adjudication Details";
            return View("Default", model);
        }
        #endregion

        #region Notifications
        /// <summary>
        /// Load the Adjudication Notifications view
        /// </summary>
        /// <param name="adjudicationDetailID"></param>
        /// <param name="adjudicationTypeID"></param>
        /// <returns></returns>
        public ActionResult Notifications(long adjudicationDetailID, short? adjudicationTypeID)
        {
            #region Securable Check
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), SecurableEnum.ApplicationsModule_Adjudication))
            {
                return RedirectToAction("ShowError", "Error", new { msg = "Security error" });
            }
            #endregion

            var database = new LegitimateDatabase();
            var adjudicationType = (short)((adjudicationTypeID.HasValue) ? adjudicationTypeID.Value : 0);

            var model = new DefaultModel
            {
                AdjudicationDetail = database.GetAdjudicationDetail(adjudicationDetailID, adjudicationType, Profile.OfficeLocationID.Value, Profile.UserID),
                OfficeLocationDocumentTemplates = database.GetOfficeLocationSetupDocumentTemplate(Profile.OfficeLocationID.Value)
            };

            ViewBag.Controller = "Adjudication Notifications";
            ViewBag.Page = "Adjudication Notifications";
            return View("Notifications", model);
        }
        #endregion               

        #region AdjudicationDecisionCapture
        /// <summary>
        /// Capture an adjudication decision
        /// </summary>
        /// <param name="applicationAdjudicationID"></param>
        /// <param name="adjudicationDecisionID"></param>
        /// <returns></returns>
        public ActionResult AdjudicationDecisionCapture(long applicationAdjudicationID, short adjudicationDecisionID)
        {
            var database = new LegitimateDatabase();
            var appDb = new ApplicationDatabase();

            var applicationAdjudication = database.GetApplicationAdjudication(applicationAdjudicationID, Profile.UserID);
            var application = appDb.GetApplicationView(applicationAdjudication.ApplicationDetailID, Profile.UserID);
            bool IsAuthorityRequest = false;

            var model = new AdjudicationDecisionCaptureModel
            {
                AdjudicationDetail = database.GetAdjudicationDetail(applicationAdjudication.AdjudicationDetailID, -1, Profile.OfficeLocationID.Value, Profile.UserID),
                AdjudicationDecisionID = adjudicationDecisionID,
                ApplicationDetail = application,
                ApplicationAdjudicationID = applicationAdjudicationID,
                LicenceDurations = database.GetLicenceDurations(Profile.UserID),
                entityID = ADJUDICATION_ENTITY_ID,
                itemID = applicationAdjudication.AdjudicationDetailID,
                DocumentStoreLocationID = DOCUMENT_STORE_LOCATION_ID,
                IsAuthorityRequest = IsAuthorityRequest
            };
            
            ViewBag.Controller = "AdjudicationDecisionCapture";
            ViewBag.Page = "AdjudicationDecisionCapture";
            return View("AdjudicationDecisionCapture", model);
        }
        #endregion
        
        #region Save
        /// <summary>
        /// Save Adjudication Details
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        [HttpPost]
        public JsonNetResult Save(AdjudicationDetail value)
        {
            try
            {
                var database = new LegitimateDatabase();
                var errorMessage = "";
                var currentAdjudication = database.SaveAdjudicationDetail(value, Profile.UserID, out errorMessage);

                var results = new
                {
                    AdjudicationDetail = currentAdjudication,
                    ErrorMessage = errorMessage
                };

                return new JsonNetResult()
                {
                    Data = new JsonBaseResult()
                    {
                        Success = true,
                        Error = "",
                        ErrorCode = "",
                        Result = new
                        {
                            AdjudicationDetail = currentAdjudication,
                            ErrorMessage = errorMessage
                        }
                    }
                };
            }
            catch (Exception ex)
            {
                #region Error Handling
                #region Error Additional Data
                Dictionary<string, object> additionalData = new Dictionary<string, object>();
                additionalData.Add("value", value);
                #endregion

                var errorMessage = ErrorHelper.ProcessError(ex, "AdjudicationConsole", "Save", additionalData);
                #endregion

                return new JsonNetResult()
                {
                    Data = new JsonBaseResult()
                    {
                        Success = false,
                        ErrorCode = "ERROR",
                        Error = errorMessage
                    }
                };
            }            
        } 
        #endregion

        #region FinaliseAndEmailAgenda
        /// <summary>
        /// Finalise adjudication and email agenda
        /// </summary>
        /// <param name="adjudicationDetailID"></param>
        /// <param name="comments"></param>
        /// <param name="adjudicationTypeID"></param>
        /// <returns></returns>
        [HttpPost]
        public JsonResult FinaliseAndEmailAgenda(long adjudicationDetailID, string comments, short adjudicationTypeID)
        {
            var database = new LegitimateDatabase();
            var reportDatabase = new ReportDatabase();
            var correspondenceDatabase = new CorrespondenceDatabase();
            var errorMessage = "";
            var success = database.AdjudicationStatusUpdate(adjudicationDetailID, (short)Common.AdjudicationDetailStatusEnum.AwaitingPanelMembers, Profile.UserID, comments, out errorMessage);
            var receiversData = database.GetAdjudicationAgendaEmails();
            var receiversEmails = "";
            var adjudicationDetail = database.GetAdjudicationDetail(adjudicationDetailID, adjudicationTypeID, Profile.OfficeLocationID.Value, Profile.UserID);

            string error;
            var reportDefinitionID = (short)ReportDefinitionEnum.AdjudicationAgenda;
            var reportDefinition = reportDatabase.GetReportDefinitionWithServer(reportDefinitionID);
            var reportFormat = "PDF";
            var reportParameters = new List<KeyValuePair<string, string>>();
            reportParameters.Add(new KeyValuePair<string, string>("UserID", Profile.UserID.ToString()));
            reportParameters.Add(new KeyValuePair<string, string>("AdjudicationDetailID", adjudicationDetailID.ToString()));
            var content = ReportGenerator.Render(reportDefinition, reportFormat, reportParameters, out error);

            if (success == true)
            {
                foreach (var i in receiversData)
                {
                    receiversEmails = i.ToString();
                }

                List<string> receiversEmailsList = receiversEmails.Split(',').ToList();
                foreach (var a in receiversEmailsList)
                {
                    var messageid = correspondenceDatabase.Create(9, 0, 1, a, null, null, "Adjudication Agenda for adjudication to be held on " + adjudicationDetail.MeetingDate.Day + "/" + adjudicationDetail.MeetingDate.Month + "/" + adjudicationDetail.MeetingDate.Year + " at " + adjudicationDetail.MeetingTime, "Please Find attached the adjudication agenda", false);
                    correspondenceDatabase.CreateAttachment(messageid.Key, 1/*System*/, content, "application/pdf", 10, "AdjudicationAgenda.pdf", "AdjudicationAgenda");
                }
            }

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

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

        #region GetPanelMembers
        /// <summary>
        /// Get Panel Members for the adjudication
        /// </summary>
        /// <param name="adjudicationDetailID"></param>
        /// <returns></returns>
        [HttpPost]
        public JsonResult GetPanelMembers(long adjudicationDetailID)
        {
            var database = new LegitimateDatabase();
            return Json(database.GetAdjudicationPanelMembers(adjudicationDetailID), JsonSerializerOptions.EscapeBackSlash | JsonSerializerOptions.FormatDateTime);
        }

        #endregion

        #region CommitAdjudicationDecision
        /// <summary>
        /// Commit a single Adjudication Decision per member
        /// </summary>
        /// <param name="applicationAdjudicationID"></param>
        /// <param name="decisionID"></param>
        /// <param name="licenceDurationID"></param>
        /// <param name="licenceExpiryDate"></param>
        /// <param name="comment"></param>
        /// <returns></returns>
        [HttpPost]
        public JsonResult CommitAdjudicationDecision(long applicationAdjudicationID, short decisionID, int? licenceDurationID, DateTime? licenceExpiryDate, string comment)
        {
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), SecurableEnum.ApplicationsModule_ApplicationRequest_Adjudication_CaptureDecision))
            {
                throw new Exception("Security error");
            }

            var database = new LegitimateDatabase();
            // Provider registrations: require certificate duration when approving
            try
            {
                var applicationAdjudication = database.GetApplicationAdjudication(applicationAdjudicationID, Profile.UserID);
                if (applicationAdjudication != null)
                {
                    var appDb = new ApplicationDatabase();
                    var application = appDb.GetApplicationView(applicationAdjudication.ApplicationDetailID, Profile.UserID);
                    if (application != null)
                    {
                        var art = application.ApplicationRequestTypeID;
                        if ((art == 60 || art == 61 || art == 62) && decisionID == 1 && !licenceDurationID.HasValue)
                        {
                            return Json(new { Success = false, ErrorMessage = "#EXPOSE_ERROR#Certificate duration is required for provider registrations." }, JsonSerializerOptions.None);
                        }
                    }
                }
            }
            catch { /* rely on SP validation if lookup fails */ }

            var errorMessage = "";

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

            if (String.IsNullOrEmpty(errorMessage))
            {
                // Send decision notifications (best effort) for NPTR provider registration apps
                // Notifications intentionally skipped here to avoid EntityFramework dependency in this project.

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

        #region AddToAdjudication
        /// <summary>
        /// Restart Adjudication Decisions
        /// </summary>
        /// <param name="applicationAdjudicationID"></param>
        /// <returns></returns>
        [HttpPost]
        public JsonResult AddToAdjudication(long applicationDetailID)
        {
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), SecurableEnum.ApplicationsModule_ApplicationRequest_Adjudication_Addtoadjudication))
            {
                throw new Exception("Security error");
            }

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

            var success = database.AddApplicationsToAdjudication(applicationDetailID.ToString(), Profile.OfficeLocationID.Value, (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
        /// <summary>
        /// Restart Adjudication Decisions
        /// </summary>
        /// <param name="applicationAdjudicationID"></param>
        /// <returns></returns>
        [HttpPost]
        public JsonResult RestartAdjudicationDecisions(long applicationAdjudicationID)
        {
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), SecurableEnum.ApplicationsModule_ApplicationRequest_Adjudication_RestartDecisions))
            {
                throw new Exception("Security error");
            }

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

            var success = database.RestartAdjudicationDecisions(applicationAdjudicationID, (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
        /// <summary>
        /// Bypass Adjudication
        /// </summary>
        /// <param name="applicationAdjudicationID"></param>
        /// <param name="decisionID"></param>
        /// <param name="licenceDurationID"></param>
        /// <param name="licenceExpiryDate"></param>
        /// <param name="actualAdjudicationDate"></param>
        /// <param name="comment"></param>
        /// <returns></returns>
        [HttpPost]
        public JsonResult BypassAdjudication(long applicationAdjudicationID, short decisionID, int? licenceDurationID, DateTime? licenceExpiryDate, DateTime actualAdjudicationDate, string comment)
        {
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), SecurableEnum.ApplicationsModule_ApplicationRequest_Adjudication_BypassAdjudication))
            {
                throw new Exception("Security error");
            }

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

            database.BypassAdjudication(applicationAdjudicationID, 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 GetLookups
        public List<LookupList> GetLookupsForFormGetLookupsFormView()
        {
            var lookups = new List<LookupList>();

            var integrationStore = new SqlIntegrationStore();

            try
            {
                UserProfileHelper userProfileHelper = new UserProfileHelper(Profile.UserID, Profile.OfficeLocationID);
                var officeLocation = userProfileHelper.OfficeLocation;

                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("ServiceTypesDivision", string.Concat("DivisionTypeID=", officeLocation.DivisionTypeID)).OrderBy(a => a.Title)));
                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)));
                try
                {
                    lookups.Add(new LookupList("VehicleModels", integrationStore.GetDataEntities("VehicleModels", string.Empty).OrderBy(a => a.Title)));
                }
                catch
                {
                    lookups.Add(new LookupList("VehicleModels", new List<Neo.Afx.Services.Integration.DataEntity>()));
                }
                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();
            }

            return lookups;
        }

        public List<LookupList> GetLookupsForReferral()
        {
            var lookups = new List<LookupList>();

            var integrationStore = new SqlIntegrationStore();

            try
            {
                integrationStore.Open();
                lookups.Add(new LookupList("ReferralTypes", integrationStore.GetDataEntities("ReferralTypes", string.Empty).OrderBy(a => a.Title)));
            }
            finally
            {
                integrationStore.Close();
            }

            return lookups;
        }
        #endregion

        #region Panel Members Methods
        #region Panel
        /// <summary>
        /// Return Adjudication Panel members view
        /// </summary>
        /// <param name="adjudicationDetailID"></param>
        /// <returns></returns>
        public ActionResult Panel(long adjudicationDetailID)
        {
            #region Securable Check
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), SecurableEnum.ApplicationsModule_Adjudication))
            {
                return RedirectToAction("ShowError", "Error", new { msg = "Security error" });
            }
            #endregion

            var database = new LegitimateDatabase();
            var model = new PanelModel
            {
                AdjudicationDetail = database.GetAdjudicationDetail(adjudicationDetailID, -1, Profile.OfficeLocationID.Value, Profile.UserID),
            };

            if
            (
                model.AdjudicationDetail.AdjudicationDetailStatusID == (short)Neo.LegitimateLicences.Common.AdjudicationDetailStatusEnum.AwaitingPanelMembers
                ||
                model.AdjudicationDetail.AdjudicationDetailStatusID == (short)Neo.LegitimateLicences.Common.AdjudicationDetailStatusEnum.AwaitingAdjudicationHearingDecisions
                &&
                (
                SecurityHelper.UserHasRole(Profile.Roles, Neo.LegitimateLicences.Common.RoleEnum.ChairmanOfTheAdjudicationPanel) ||
                SecurityHelper.UserHasRole(Profile.Roles, Neo.LegitimateLicences.Common.RoleEnum.AdjudicationPanelmember)
                )
            )
            {
                var error = "";
                database.UpdateAttendance(model.AdjudicationDetail.AdjudicationDetailID, Profile.UserID, out error);
            }

            var panelMember = database.GetAdjudicationPanelMembers(adjudicationDetailID);

            model.PanelMembers = panelMember.Where(a => !a.AddedAfterStart);
            model.PanelMembersAddedAfterStart = panelMember.Where(a => a.AddedAfterStart);

            ViewBag.Controller = "Panel";
            ViewBag.Page = "Panel";
            return View("Panel", model);
        }
        #endregion

        #region RemovePanelMember
        /// <summary>
        /// Remove Panel Member from Adjudication
        /// </summary>
        /// <param name="adjudicationDetailID"></param>
        /// <param name="adjudicationPanelID"></param>
        /// <returns></returns>
        [HttpPost]
        public JsonNetResult RemovePanelMember(long adjudicationDetailID, long adjudicationPanelID)
        {            
            try
            {
                var database = new LegitimateDatabase();
                var errorMessage = "";
                var success = database.RemoveAdjudicationPanelMember(adjudicationDetailID, adjudicationPanelID, Profile.UserID, out errorMessage);
                
                if(!String.IsNullOrEmpty(errorMessage))
                {
                    throw new Exception(errorMessage);
                }
                
                return new JsonNetResult()
                {
                    Data = new JsonBaseResult()
                    {
                        Success = true,
                        Error = "",
                        ErrorCode = ""
                    }
                };
            }
            catch (Exception ex)
            {
                #region Error Handling
                #region Error Additional Data
                Dictionary<string, object> additionalData = new Dictionary<string, object>();
                additionalData.Add("adjudicationDetailID", adjudicationDetailID);
                additionalData.Add("adjudicationPanelID", adjudicationPanelID);
                #endregion

                var errorMessage = ErrorHelper.ProcessError(ex, "AdjudicationConsole", "RemovePanelMember", additionalData);
                #endregion

                return new JsonNetResult()
                {
                    Data = new JsonBaseResult()
                    {
                        Success = false,
                        ErrorCode = "ERROR",
                        Error = errorMessage
                    }
                };
            }
        }
        #endregion

        #region ReplaceAdjudicationPanelMember
        /// <summary>
        /// Replace a panel member on a Adjudication request
        /// </summary>
        /// <param name="AdjudicationDetailID"></param>
        /// <param name="FromAdjudicationPanelID"></param>
        /// <param name="ToAdjudicationPanelID"></param>
        /// <returns></returns>
        [HttpPost]
        public JsonNetResult ReplaceAdjudicationPanelMember(long AdjudicationDetailID, long FromAdjudicationPanelID, long ToAdjudicationPanelID)
        {            
            try
            {
                var database = new LegitimateDatabase();
                var errorMessage = "";
                var success = database.ReplaceAdjudicationPanelMember(AdjudicationDetailID, FromAdjudicationPanelID, ToAdjudicationPanelID, Profile.UserID, out errorMessage);

                if (!String.IsNullOrEmpty(errorMessage))
                {
                    throw new Exception(errorMessage);
                }

                return new JsonNetResult()
                {
                    Data = new JsonBaseResult()
                    {
                        Success = true,
                        Error = "",
                        ErrorCode = ""
                    }
                };
            }
            catch (Exception ex)
            {
                #region Error Handling
                #region Error Additional Data
                Dictionary<string, object> additionalData = new Dictionary<string, object>();
                additionalData.Add("AdjudicationDetailID", AdjudicationDetailID);
                additionalData.Add("FromAdjudicationPanelID", FromAdjudicationPanelID);
                additionalData.Add("ToAdjudicationPanelID", ToAdjudicationPanelID);
                #endregion

                var errorMessage = ErrorHelper.ProcessError(ex, "AdjudicationConsole", "ReplaceAdjudicationPanelMember", additionalData);
                #endregion

                return new JsonNetResult()
                {
                    Data = new JsonBaseResult()
                    {
                        Success = false,
                        ErrorCode = "ERROR",
                        Error = errorMessage
                    }
                };
            }
        }
        #endregion

        #region StartAdjudication
        /// <summary>
        /// Start Adjudication
        /// </summary>
        /// <param name="AdjudicationDetailID"></param>
        /// <param name="ChairmanID"></param>
        /// <returns></returns>
        [HttpPost]
        public JsonNetResult StartAdjudication(long AdjudicationDetailID, long ChairmanID)
        {
            try
            {
                var database = new LegitimateDatabase();
                var errorMessage = "";
                var success = database.StartAdjudication(AdjudicationDetailID, ChairmanID, Profile.UserID, out errorMessage);

                if (!String.IsNullOrEmpty(errorMessage))
                {
                    throw new Exception(errorMessage);
                }

                return new JsonNetResult()
                {
                    Data = new JsonBaseResult()
                    {
                        Success = true,
                        Error = "",
                        ErrorCode = ""
                    }
                };
            }
            catch (Exception ex)
            {
                #region Error Handling
                #region Error Additional Data
                Dictionary<string, object> additionalData = new Dictionary<string, object>();
                additionalData.Add("AdjudicationDetailID", AdjudicationDetailID);
                additionalData.Add("ChairmanID", ChairmanID);
                #endregion

                var errorMessage = ErrorHelper.ProcessError(ex, "AdjudicationConsole", "StartAdjudication", additionalData);
                #endregion

                return new JsonNetResult()
                {
                    Data = new JsonBaseResult()
                    {
                        Success = false,
                        ErrorCode = "ERROR",
                        Error = errorMessage
                    }
                };
            }          
        }
        #endregion

        #region PostponeAdjudication
        /// <summary>
        /// Flag Adjudication as postponed
        /// </summary>
        /// <param name="AdjudicationDetailID"></param>
        /// <param name="Reason"></param>
        /// <returns></returns>
        [HttpPost]
        public JsonNetResult PostponeAdjudication(long AdjudicationDetailID, string Reason)
        {            
            try
            {
                var database = new LegitimateDatabase();
                var errorMessage = "";
                var success = database.PostponeAdjudication(AdjudicationDetailID, Reason, Profile.UserID, out errorMessage);

                if (!String.IsNullOrEmpty(errorMessage))
                {
                    throw new Exception(errorMessage);
                }

                return new JsonNetResult()
                {
                    Data = new JsonBaseResult()
                    {
                        Success = true,
                        Error = "",
                        ErrorCode = ""
                    }
                };
            }
            catch (Exception ex)
            {
                #region Error Handling
                #region Error Additional Data
                Dictionary<string, object> additionalData = new Dictionary<string, object>();
                additionalData.Add("AdjudicationDetailID", AdjudicationDetailID);
                additionalData.Add("Reason", Reason);
                #endregion

                var errorMessage = ErrorHelper.ProcessError(ex, "AdjudicationConsole", "PostponeAdjudication", additionalData);
                #endregion

                return new JsonNetResult()
                {
                    Data = new JsonBaseResult()
                    {
                        Success = false,
                        ErrorCode = "ERROR",
                        Error = errorMessage
                    }
                };
            }
        }
        #endregion
        #endregion

        #region Applications
        #region Applications
        /// <summary>
        /// Return a list of applications linked to a adjudication
        /// </summary>
        /// <param name="adjudicationDetailID"></param>
        /// <returns></returns>
        public ActionResult Applications(long adjudicationDetailID)
        {
            var database = new LegitimateDatabase();
            var model = new ApplicationsModel
            {
                AdjudicationDetail = database.GetAdjudicationDetail(adjudicationDetailID, -1, Profile.OfficeLocationID.Value, Profile.UserID),
                Applications = database.GetApplicationsLinkedToAdjudication(adjudicationDetailID, Profile.UserID),
                OfficeLocationSetupDocumentTemplate = database.GetOfficeLocationSetupDocumentTemplate(Profile.OfficeLocationID.Value)
            };

            ViewBag.Controller = "Applications";
            ViewBag.Page = "Applications";
            return View("Applications", model);
        }
        #endregion

        #region ApplicationDetails
        /// <summary>
        /// Returns a view with all of an applicants details, view functions on a single licence level
        /// </summary>
        /// <param name="applicationAdjudicationID"></param>
        /// <returns></returns>
        public ActionResult ApplicationDetails(long applicationAdjudicationID, long applicationLicenceID)
        {
            var database = new LegitimateDatabase();
            var appDb = new ApplicationDatabase();
            string parentApplicationNumber = "";
            var applicationAdjudication = database.GetApplicationAdjudication(applicationAdjudicationID, Profile.UserID);
            var application = appDb.GetAdjudicationApplicationLicences(applicationAdjudication.ApplicationDetailID, applicationLicenceID, Profile.UserID);

            #region Get Gazette Details
            List<Pr_ApplicationGazetteGet_Result> gazetteDetails = appDb.GazetteApplicationsGet(application.ApplicationDetailID, Profile.UserID);
            #endregion

            #region Get parent application detail if split from a main application
            if (application.CopiedFromApplicationDetailID != null)
            {
                application.Receipts = appDb.GetPaymentDetails(application.CopiedFromApplicationDetailID.Value, Profile.UserID);
                if (application.Receipts == null)
                {
                    application.Receipts = new List<Neo.LegitimateLicences.ApplicationRequest.Models.Database.ReceiptDetail>();
                }
                parentApplicationNumber = appDb.GetApplicationView(application.CopiedFromApplicationDetailID.Value, Profile.UserID).ApplicationNumber;
            }
            #endregion

            #region limit to current licence
            //todo optomize!
            var licencesToRemove = new List<ApplicationLicence>();
            foreach (var licence in application.Licences)
            {
                if (licence.ApplicationLicenceID != applicationAdjudication.ApplicationLicenceID)
                {
                    licencesToRemove.Add(licence);
                }
            }

            foreach (var licence in licencesToRemove)
            {
                application.Licences.Remove(licence);
            }

            foreach (var licence in application.Licences)
            {
                foreach (var route in licence.Routes)
                {
                    route.RouteDescription = route.RouteDescription.Replace(Environment.NewLine, "").Replace("\r\n", "").Replace("\n\n", "").Replace("\n", "").Replace("\r", "").Replace("\"", "'").Replace("\t", "");
                }
            }
            #endregion

            var workflowDatabase = new WorkflowsDatabase();
            var applicationDatabase = new ApplicationDatabase();

            var db = new LegitimateDatabase();
            var office = db.GetOfficeLocation(Profile.OfficeLocationID.Value);
            bool isTAT = false;
            if (office.DivisionTypeID == (short)DivisionTypeEnum.TAT)
            {
                isTAT = true;
            }
            string LicenceReferenceNumber = "";

            if(application.Licences.Count() > 0)
            {
                LicenceReferenceNumber = application.Licences.FirstOrDefault().ApplicationLicenceReferenceNumber;
            }

            var model = new ApplicationDetailsModel
            {
                AdjudicationDetail = database.GetAdjudicationDetail(applicationAdjudication.AdjudicationDetailID, -1, Profile.OfficeLocationID.Value, Profile.UserID),
                ApplicationView = database.GetApplicationDetail_ViewOnly(applicationAdjudication.ApplicationDetailID),
                GazetteDetails = gazetteDetails,
                Application = application,
                ApplicationAdjudicationID = applicationAdjudicationID,
                entityID = ADJUDICATION_ENTITY_ID,
                itemID = applicationAdjudication.AdjudicationDetailID,
                DocumentStoreLocationID = DOCUMENT_STORE_LOCATION_ID,
                CanCaptureDecision = applicationAdjudication.IsReadyForAdjudication,
                LicenceReferenceNumber = LicenceReferenceNumber,
                Lookups = GetLookupsForFormGetLookupsFormView(),
                Documents = workflowDatabase.GetWorkflowInstanceDocuments(application.WorkflowInstanceID.Value, Profile.UserID),
                ParentApplicationNumber = parentApplicationNumber,
                IsTAT = isTAT,
                FinalDecisionID = applicationAdjudication.FinalAdjudicationDecisionID
            };

            if (application.CopiedFromApplicationDetailID != null)
            {
                model.IsChildApplication = true;
            }

            #region Check for related TAT Request
            if (application.RelatedTATApplicationRequestID != null)
            {
                model.RelatedTATApplicationDetails = applicationDatabase.GetApplicationTATDetails(application.RelatedTATApplicationRequestID.Value, Profile.UserID);
            }
            else
            {
                model.RelatedTATApplicationDetails = new ApplicationDetail();
            }
            #endregion

            #region Get form state
            var ApplicationRequestBaseModel = new ApplicationRequestFormModel
            {
                ApplicationView = applicationDatabase.GetApplicationView(applicationAdjudication.ApplicationDetailID, Profile.UserID),
                WorkflowInstance = WorkflowHelper.GetWorkflowInstanceView((short)EntityEnum.ApplicationRequestDetails, applicationAdjudication.ApplicationDetailID, Profile.UserID)
            };
            ApplicationRequestBaseModel.SetFormEditState(null);

            if(applicationAdjudication.ApplicationRequestTypeID == (short)ApplicationRequestTypeEnum.ApplicationForAccreditation || applicationAdjudication.ApplicationRequestTypeID == (short)ApplicationRequestTypeEnum.ApplicationForAccreditationWithoutOperatingLicence)
            {
                ApplicationRequestBaseModel.CanViewLicenceDetails = false;
            }

            model.ApplicationRequestBaseModel = ApplicationRequestBaseModel;
            #endregion

            #region Get Previous Adjudication
            if(applicationAdjudication.ApplicationRequestTypeID == (short)ApplicationRequestTypeEnum.ApplicationForAccreditation || applicationAdjudication.ApplicationRequestTypeID == (short)ApplicationRequestTypeEnum.ApplicationForAccreditationWithoutOperatingLicence)
            {
                List<ApplicationAdjudication> applicationAdjudications = applicationDatabase.GetApplicationLicenceAdjudicationDetails(applicationAdjudication.ApplicationDetailID, Profile.UserID);
                model.ApplicationAdjudications = applicationAdjudications;
            }
            else
            {
                // Provider applications (no licence): fall back to application-only overload
                if (!applicationAdjudication.ApplicationLicenceID.HasValue 
                    || applicationAdjudication.ApplicationRequestTypeID == (short)ApplicationRequestTypeEnum.NPTR_EhailingProviderRegistration
                    || applicationAdjudication.ApplicationRequestTypeID == (short)ApplicationRequestTypeEnum.NPTR_EhailingProviderRegistrationRenewal
                    || applicationAdjudication.ApplicationRequestTypeID == (short)ApplicationRequestTypeEnum.NPTR_EhailingProviderRegistrationAmendConditions)
                {
                    List<ApplicationAdjudication> applicationAdjudications = applicationDatabase.GetApplicationLicenceAdjudicationDetails(applicationAdjudication.ApplicationDetailID, Profile.UserID);
                    model.ApplicationAdjudications = applicationAdjudications;
                }
                else
                {
                    List<ApplicationAdjudication> applicationAdjudications = applicationDatabase.GetApplicationLicenceAdjudicationDetails(applicationAdjudication.ApplicationDetailID, applicationAdjudication.ApplicationLicenceID.Value, Profile.UserID);
                    model.ApplicationAdjudications = applicationAdjudications;
                }
            }            
            #endregion

            ViewBag.Controller = "ApplicationDetails";
            ViewBag.Page = "ApplicationDetails";
            return View("ApplicationDetails", model);
        }
        #endregion

        #region AddApplicationToAdjudication
        /// <summary>
        /// Add an application from the manual Adjudication queue
        /// </summary>
        /// <param name="adjudicationDetailID"></param>
        /// <param name="referenceNumber"></param>
        /// <returns></returns>
        [HttpPost]
        public JsonNetResult AddApplicationToAdjudication(long adjudicationDetailID, string referenceNumber)
        {
            try
            {
                if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), SecurableEnum.ApplicationsModule_Adjudication_Console_AddApplication))
                {
                    throw new Exception("#EXPOSE_ERROR#Security error");
                }
                var database = new LegitimateDatabase();
                var errorMessage = "";
                var appDetail = database.GetApplicationDetail_ViewOnly(referenceNumber);
                if (appDetail != null)
                {

                    if ((appDetail.ApplicationCannoutBeAutoAssignedForAdjudication != true) && (appDetail.ApplicationSubStatusID == (short)ApplicationSubStatusEnum.AwaitingNextAvailableAdjudication_Automated))
                    {
                        throw new Exception("#EXPOSE_ERROR#Application is in the automated queue, cannot be manually added");
                    }

                    if (appDetail.AdjudicationOfficeLocationID != Profile.OfficeLocationID)
                    {
                        throw new Exception("#EXPOSE_ERROR#Application is not linked to adjudication location");
                    }
                    database.AddApplicationToAdjudication(appDetail.ApplicationDetailID, adjudicationDetailID, Profile.UserID);
                }
                else
                {
                    errorMessage = "#EXPOSE_ERROR#No record found for reference " + referenceNumber;
                }

                if(!String.IsNullOrEmpty(errorMessage))
                {
                    throw new Exception(errorMessage);
                }

                return new JsonNetResult()
                {
                    Data = new JsonBaseResult()
                    {
                        Success = true,
                        Error = "",
                        ErrorCode = ""
                    }
                };
            }
            catch (Exception ex)
            {
                #region Error Handling
                #region Error Additional Data
                Dictionary<string, object> additionalData = new Dictionary<string, object>();
                additionalData.Add("adjudicationDetailID", adjudicationDetailID);
                additionalData.Add("referenceNumber", referenceNumber);
                #endregion

                var errorMessage = ErrorHelper.ProcessError(ex, "AdjudicationConsole", "AddApplicationToAdjudication", additionalData);
                #endregion

                return new JsonNetResult()
                {
                    Data = new JsonBaseResult()
                    {
                        Success = false,
                        ErrorCode = "ERROR",
                        Error = errorMessage
                    }
                };
            }
        }
        #endregion

        #region RemoveApplicationFromAdjudication
        /// <summary>
        /// Remove application from adjudication
        /// </summary>
        /// <param name="AdjudicationDetailID"></param>
        /// <param name="ApplicationDetailID"></param>
        /// <param name="comments"></param>
        /// <returns></returns>
        [HttpPost]
        public JsonNetResult RemoveApplicationFromAdjudication(long AdjudicationDetailID, long ApplicationDetailID, string comments)
        {
            try
            {
                if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), SecurableEnum.ApplicationsModule_Adjudication_Console_RemoveApplication))
                {
                    throw new Exception("Security error");
                }

                var database = new LegitimateDatabase();
                database.RemoveApplicationFromAdjudication(ApplicationDetailID, AdjudicationDetailID, comments, Profile.UserID);

                return new JsonNetResult()
                {
                    Data = new JsonBaseResult()
                    {
                        Success = true,
                        Error = "",
                        ErrorCode = ""
                    }
                };
            }
            catch (Exception ex)
            {
                #region Error Handling
                #region Error Additional Data
                Dictionary<string, object> additionalData = new Dictionary<string, object>();
                additionalData.Add("AdjudicationDetailID", AdjudicationDetailID);
                additionalData.Add("ApplicationDetailID", ApplicationDetailID);
                additionalData.Add("comments", comments);
                #endregion

                var errorMessage = ErrorHelper.ProcessError(ex, "AdjudicationConsole", "AddApplicationToAdjudication", additionalData);
                #endregion

                return new JsonNetResult()
                {
                    Data = new JsonBaseResult()
                    {
                        Success = false,
                        ErrorCode = "ERROR",
                        Error = errorMessage
                    }
                };
            }           
        }
        #endregion        

        #region ReverseAdjudicationDecision
        /// <summary>
        /// Reverse the decision linked to an application
        /// </summary>
        /// <param name="applicationAdjudicationID"></param>
        /// <param name="comments"></param>
        /// <returns></returns>
        [HttpPost]
        public JsonResult ReverseAdjudicationDecision(long applicationAdjudicationID, string comments)
        {

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

                var database = new LegitimateDatabase();
                database.ReverseAdjudicationDecision(applicationAdjudicationID, Profile.UserID, comments);

                return new JsonNetResult()
                {
                    Data = new JsonBaseResult()
                    {
                        Success = true,
                        Error = "",
                        ErrorCode = ""
                    }
                };
            }
            catch (Exception ex)
            {
                #region Error Handling
                #region Error Additional Data
                Dictionary<string, object> additionalData = new Dictionary<string, object>();
                additionalData.Add("applicationAdjudicationID", applicationAdjudicationID);
                additionalData.Add("comments", comments);
                #endregion

                var errorMessage = ErrorHelper.ProcessError(ex, "AdjudicationConsole", "ReverseAdjudicationDecision", additionalData);
                #endregion

                return new JsonNetResult()
                {
                    Data = new JsonBaseResult()
                    {
                        Success = false,
                        ErrorCode = "ERROR",
                        Error = errorMessage
                    }
                };
            }          
        }
        #endregion

        #region RemoveLicenceRoute
        [HttpPost]
        public JsonResult RemoveLicenceRoute(long applicationLicenceID, long applicationLicenceRouteDetailID)
        {
            var appController = new ApplicationRequestController();

            #region Check if can save
            //var model = appController.GetModel();

            //if (!model.CanEditRouteDetails)
            //{
            //    throw new Exception("Security error");
            //}
            #endregion

            var db = new ApplicationDatabase();
            var deleteAction = db.RemoveLicenceRoute(applicationLicenceID, applicationLicenceRouteDetailID, Profile.UserID);

            return new JsonNetResult()
            {
                Data = new JsonBaseResult()
                {
                    Result = deleteAction,
                    Success = true
                }
            };
        }
        #endregion

        #endregion
    }
}