using Neo.Afx.Services.Workflows;
using Neo.LegitimateLicences.Common;
using Neo.LegitimateLicences.Data.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using Neo.Afx.ViewModels;
using Neo.Afx.Services.Integration;
using Neo.LegitimateLicences.Stationery;
using Neo.LegitimateLicences.Common.Helpers;
using Neo.Afx.Mvc;
using DPUruNet;
using Neo.Afx.Admin.Security;

namespace Neo.LegitimateLicences.Stationery.Controllers
{

    public partial class StationeryController : Neo.LegitimateLicences.Common.ControllerBase
    {
        private const int DPFJ_PROBABILITY_ONE = 0x7fffffff;

        #region Action Results
        #region AvailableStationery
        public ActionResult AvailableStationery()
        {
            var database = new LegitimateDatabase();
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), Common.SecurableEnum.StationeryModule))
            {
                return RedirectToAction("Default", "Applications");
            }

            var model = new AvailableStationeryModel
            {
                StationeryBatches = database.GetStationeryBatches("AvailableStationery", Profile.UserID)
            };

            WebHelper.SetLastPageVisited(HttpContext, "Stationery/AvailableStationery");
            ViewBag.Controller = "AvailableStationery";
            ViewBag.Page = "Stationery";
            return View("AvailableStationery", model);
        }
        #endregion

        #region IssuedStationery
        public ActionResult IssuedStationery()
        {
            var database = new LegitimateDatabase();
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), Common.SecurableEnum.StationeryModule))
            {
                return RedirectToAction("Default", "Applications");
            }

            var model = new IssuedStationeryModel
            {
                IssuedStationery = database.GetIssuedStationery(Profile.UserID)
            };

            WebHelper.SetLastPageVisited(HttpContext, "Stationery/IssuedStationery");
            ViewBag.Controller = "IssuedStationery";
            ViewBag.Page = "Stationery";
            return View("IssuedStationery", model);
        }
        #endregion

        #region UpsertStationeryBatch
        public ActionResult UpsertStationeryBatch()
        {
            var database = new LegitimateDatabase();
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), Common.SecurableEnum.StationeryModule))
            {
                return RedirectToAction("Default", "Applications");
            }

            var model = new UpsertStationeryBatchModel
            {
                StationeryBatch = new StationeryBatch(),
                TransferedInBatches = database.GetStationeryBatches("TransferedInStationery", Profile.UserID),
                Lookups = GetLookups()

            };
            model.StationeryBatch.StationeryBatchTypeID = (short)StationeryBatchTypeEnum.FromGPW;
            WebHelper.SetLastPageVisited(HttpContext, "Stationery/UpsertStationeryBatch");
            ViewBag.Controller = "UpsertStationeryBatch";
            ViewBag.Page = "Stationery";
            return View("UpsertStationeryBatch", model);
        }
        #endregion

        #region TransferStationery
        public ActionResult TransferStationery()
        {
            var database = new LegitimateDatabase();
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), Common.SecurableEnum.StationeryModule))
            {
                return RedirectToAction("Default", "Applications");
            }

            var model = new UpsertStationeryBatchModel
            {
                StationeryBatch = new StationeryBatch(),
                Stationery = database.GetFirstAvailableStationeryNumber(Profile.UserID),
                Lookups = GetLookupsForTransfer()

            };

            WebHelper.SetLastPageVisited(HttpContext, "Stationery/TransferStationery");
            ViewBag.Controller = "TransferStationery";
            ViewBag.Page = "Stationery";
            return View("TransferStationery", model);
        }
        #endregion

        #region AssignStationery
        public ActionResult AssignStationery()
        {
            var database = new LegitimateDatabase();
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), Common.SecurableEnum.StationeryModule))
            {
                return RedirectToAction("Default", "Applications");
            }

            var model = new UpsertStationeryBatchModel
            {
                StationeryBatch = new StationeryBatch(),
                Stationery = database.GetFirstAvailableStationeryNumber(Profile.UserID),
                Lookups = GetLookups()

            };

            WebHelper.SetLastPageVisited(HttpContext, "Stationery/AssignStationery");
            ViewBag.Controller = "AssignStationery";
            ViewBag.Page = "Stationery";
            return View("AssignStationery", model);
        }
        #endregion

        #region RetrieveStationery
        public ActionResult RetrieveStationery(long issuedToID)
        {
            var database = new LegitimateDatabase();
            var securityDatabase = new SecurityDatabase();
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), Common.SecurableEnum.StationeryModule))
            {
                return RedirectToAction("Default", "Applications");
            }

            var model = new RetrieveStationeryModel
            {
                IssuedStationery = database.GetIssuedToStationery(issuedToID, ((short)StationeryStatusEnum.IssuedForUse).ToString() +","+ ((short)StationeryStatusEnum.Defaced).ToString() +","+ ((short)StationeryStatusEnum.Lost).ToString(), Profile.UserID),
                IssuedToUser = securityDatabase.GetUserByID(issuedToID)
            };

            WebHelper.SetLastPageVisited(HttpContext, "Stationery/RetrieveStationery");
            ViewBag.Controller = "RetrieveStationery";
            ViewBag.Page = "Stationery";
            return View("RetrieveStationery", model);
        }
        #endregion
        #endregion

        #region JSON endpoints

        // All JSON endpoints require [HttpPost] to prevent JSON hijacking.
        // With [HttpPost], returning arrays is allowed.  
        // See http://haacked.com/archive/2009/06/25/json-hijacking.aspx

        [HttpPost]
        public JsonResult CreateStationeryBatches(StationeryBatch stationeryBatch, int intFromNumber, int intToNumber, string prefix)
        {
            var database = new LegitimateDatabase();
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), Common.SecurableEnum.StationeryModule))
            {
                throw new  Exception("Invalid User");
            }
            var success = true;
            var errorMessage = "";
            try
            {
                database.CreateStationeryBatch(stationeryBatch.StationeryBatchTypeID, stationeryBatch.FromNumber, stationeryBatch.ToNumber, intFromNumber, intToNumber, prefix, Profile.UserID);
            }
            catch (Exception ex)
            {
                success = false;
                errorMessage = database.GetInnermostMessage(ex);
            }
            return Json(new
            {
                success,
                errorMessage
            },
            JsonSerializerOptions.None);
        }

        [HttpPost]
        public JsonResult MarkStationeryBatchAsReceived(Pr_StationeryBatchesGet_Result stationeryBatch)
        {
            var database = new LegitimateDatabase();
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), Common.SecurableEnum.StationeryModule))
            {
                throw new Exception("Invalid User");
            }
            var success = true;
            var errorMessage = "";
            try
            {
                database.MarkStationeryBatchReceived(stationeryBatch.StationeryBatchID, Profile.UserID);
            }
            catch (Exception ex)
            {
                success = false;
                errorMessage = database.GetInnermostMessage(ex);
            }
            return Json(new
            {
                success,
                errorMessage
            },
            JsonSerializerOptions.None);
        }

        [HttpPost]
        public JsonResult AvailableStationerySearch()
        {
            var database = new LegitimateDatabase();
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), Common.SecurableEnum.StationeryModule))
            {
                throw new Exception("Invalid User");
            }
            var success = true;
            var errorMessage = "";
            List<Pr_StationeryBatchesGet_Result> stationeryBatches = new List<Pr_StationeryBatchesGet_Result>();

            try
            {
                stationeryBatches = database.GetStationeryBatches("AvailableStationery", Profile.UserID);
            }
            catch (Exception ex)
            {
                success = false;
                errorMessage = database.GetInnermostMessage(ex);
            }
            return Json(new
            {
                success,
                stationeryBatches,
                errorMessage
            },
            JsonSerializerOptions.None);
        }

        [HttpPost]
        public JsonResult IssuedStationerySearch()
        {
            var database = new LegitimateDatabase();
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), Common.SecurableEnum.StationeryModule))
            {
                throw new Exception("Invalid User");
            }
            var success = true;
            var errorMessage = "";
            List<Pr_IssuedStationeryGet_Result> issuedStationery = new List<Pr_IssuedStationeryGet_Result>();

            try
            {
                issuedStationery = database.GetIssuedStationery(Profile.UserID);
            }
            catch (Exception ex)
            {
                success = false;
                errorMessage = database.GetInnermostMessage(ex);
            }
            return Json(new
            {
                success,
                issuedStationery,
                errorMessage
            },
            JsonSerializerOptions.None);
        }

        [HttpPost]
        public JsonResult AssignPrecheckStationery(string fromNumber, long numberOfPagesIssued)
        {
            var database = new LegitimateDatabase();
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), Common.SecurableEnum.StationeryModule))
            {
                throw new Exception("Invalid User");
            }
            var success = true;
            var errorMessage = "";
            List<Neo.LegitimateLicences.Data.Models.Stationery> stationery = new List<Neo.LegitimateLicences.Data.Models.Stationery>();

            try
            {
                stationery = database.AssignPrecheckStationery(fromNumber, numberOfPagesIssued, Profile.UserID);
            }
            catch (Exception ex)
            {
                success = false;
                errorMessage = database.GetInnermostMessage(ex);
            }
            return Json(new
            {
                success,
                stationery,
                errorMessage
            },
            JsonSerializerOptions.None);
        }

        [HttpPost]
        public JsonResult IssueStationery(long issueToID, string fromNumber, long numberOfPagesIssued, string fingerprint)
        {
            var database = new LegitimateDatabase();
            var securityDatabase = new SecurityDatabase();
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), Common.SecurableEnum.StationeryModule))
            {
                throw new Exception("Invalid User");
            }

            var success = true;
            var errorMessage = "";
            List<Neo.LegitimateLicences.Data.Models.Stationery> stationery = new List<Neo.LegitimateLicences.Data.Models.Stationery>();

            try
            {
                #region Authenicate Transaction
                int thresholdScore = DPFJ_PROBABILITY_ONE * 1 / 100000;
                var user = securityDatabase.GetUser(issueToID, Profile.UserID);
                var verifiedTemplate = user.FingerprintTemplate;
                var fingerprintBytes = Convert.FromBase64String(fingerprint);
                var scannedFingerConversion = new Fmd(fingerprintBytes, (int)Constants.Formats.Fmd.DP_VERIFICATION, "1.0.0");

                Fmd[] fmds = new Fmd[1];
                fmds[0] = new Fmd(verifiedTemplate, (int)Constants.Formats.Fmd.DP_REGISTRATION, "1.0.0");

                IdentifyResult identifyResult = Comparison.Identify(scannedFingerConversion, 0, fmds, thresholdScore, 2);
                if (identifyResult.ResultCode == Constants.ResultCode.DP_SUCCESS)
                {
                    if (identifyResult.Indexes.Length == 1)
                    {
                        database.IssueStationery(issueToID, fromNumber, numberOfPagesIssued, Profile.UserID);
                    }
                    else
                    {
                        throw new Exception("Invalid user");
                    }
                }
                else
                {
                    throw new Exception("Unkown Error occured");
                }
                #endregion
            }
            catch (Exception ex)
            {
                success = false;
                errorMessage = database.GetInnermostMessage(ex);
            }
            return Json(new
            {
                success,
                stationery,
                errorMessage
            },
            JsonSerializerOptions.None);
        }

        [HttpPost]
        public JsonResult TransferStationery(string fromNumber, long numberOfPagesIssued, short stationeryBatchTypeID, short? officeLocationID, string externalPartyDescription, string externalPartyContactName, string externalPartyContactEmail, string stationeryIDs)
        {
            var database = new LegitimateDatabase();
            var securityDatabase = new SecurityDatabase();
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), Common.SecurableEnum.StationeryModule))
            {
                throw new Exception("Invalid User");
            }
            var success = true;
            var errorMessage = "";
            List<Neo.LegitimateLicences.Data.Models.Stationery> stationery = new List<Neo.LegitimateLicences.Data.Models.Stationery>();


            try
            {
                database.TransferStationery(fromNumber, numberOfPagesIssued, stationeryBatchTypeID, officeLocationID, externalPartyDescription, externalPartyContactName, externalPartyContactEmail, stationeryIDs, Profile.UserID);
            }
            catch (Exception ex)
            {
                success = false;
                errorMessage = database.GetInnermostMessage(ex);
            }
            return Json(new
            {
                success,
                stationery,
                errorMessage
            },
            JsonSerializerOptions.None);
        }

        [HttpPost]
        public JsonResult ReturnStationery(long issueToUserID, List<Pr_IssuedToStationeryGet_Result> stationery)
        {
            var database = new LegitimateDatabase();
            var securityDatabase = new SecurityDatabase();
            if (!SecurityHelper.UserHasAccessToSecurable(Profile.Securables.ToList(), Common.SecurableEnum.StationeryModule))
            {
                throw new Exception("Invalid User");
            }
            var success = true;
            var errorMessage = "";

            try
            {
                foreach(var s in stationery)
                {
                    database.ReturnStationery(issueToUserID, s.StationeryID, s.StationeryStatusID, s.StationeryScanDocID, s.Comments, Profile.UserID);
                }                
            }
            catch (Exception ex)
            {
                success = false;
                errorMessage = database.GetInnermostMessage(ex);
            }
            return Json(new
            {
                success,
                errorMessage
            },
            JsonSerializerOptions.None);
        }
        #endregion

        #region GetLookups
        public List<LookupList> GetLookups()
        {
            var lookups = new List<LookupList>();
            var integrationStore = new SqlIntegrationStore();
            try
            {
                integrationStore.Open();
                var stationeryBatchTypes = integrationStore.GetDataEntities("StationeryBatchTypes", string.Empty);
                stationeryBatchTypes = stationeryBatchTypes.Where(a => a.Key != ((short)StationeryBatchTypeEnum.ExternalTransfer).ToString()).ToList();
                lookups.Add(new LookupList("OfficeLocations", integrationStore.GetDataEntities("OfficeLocations", string.Empty)));
                lookups.Add(new LookupList("StationeryBatchTypes", stationeryBatchTypes));
            }
            finally
            {
                integrationStore.Close();
            }

            return lookups;
        }
        #endregion

        #region GetLookupsForTransfer
        public List<LookupList> GetLookupsForTransfer()
        {
            var lookups = new List<LookupList>();
            var integrationStore = new SqlIntegrationStore();
            try
            {
                integrationStore.Open();
                var stationeryBatchTypes = integrationStore.GetDataEntities("StationeryBatchTypes", string.Empty);
                stationeryBatchTypes = stationeryBatchTypes.Where(a => a.Key != ((short)StationeryBatchTypeEnum.FromGPW).ToString()).ToList();
                lookups.Add(new LookupList("OfficeLocations", integrationStore.GetDataEntities("OfficeLocations", string.Empty)));
                lookups.Add(new LookupList("StationeryBatchTypes", stationeryBatchTypes));
            }
            finally
            {
                integrationStore.Close();
            }

            return lookups;
        }
        #endregion
    }
}