using EnvelopeGenerator.Application.Contracts;
using EnvelopeGenerator.Application.DTOs;
using EnvelopeGenerator.Application.Services;
using EnvelopeGenerator.Common;
using EnvelopeGenerator.Web.Models;
using EnvelopeGenerator.Web.Services;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using System.Diagnostics;

namespace EnvelopeGenerator.Web.Controllers
{
    public class HomeController : BaseController
    {
        private readonly EnvelopeOldService envelopeOldService;
        private readonly IConfiguration _config;
        private readonly IEnvelopeService _envelopeService;

        public HomeController(DatabaseService databaseService, EnvelopeOldService envelopeOldService, ILogger<HomeController> logger, IConfiguration configuration, IEnvelopeService envelopeService) : base(databaseService, logger)
        {
            this.envelopeOldService = envelopeOldService;
            _envelopeService = envelopeService;
            _config = configuration;
        }

        [HttpGet("/")]
        public IActionResult Index()
        {
            return View();
        }

        [HttpPost("/")]
        public IActionResult DebugEnvelopes([FromForm] string password)
        {
            try
            {
                var passwordFromConfig = _config["Config:AdminPassword"] ?? throw new InvalidOperationException("No admin password configured!");

                if (passwordFromConfig == null)
                {
                    ViewData["error"] = "No admin password configured!";
                    return View("Index");
                }

                if (password == null)
                {
                    ViewData["error"] = "No password supplied!";
                    return View("Index");
                }

                if (password != passwordFromConfig)
                {
                    ViewData["error"] = "Wrong Password!";
                    return View("Index");
                }

                List<Envelope> envelopes = envelopeOldService.LoadEnvelopes();

                return View(envelopes);
            } 
            catch (Exception e)
            {
                ViewData["error"] = "Unknown error!";
                return View("Index");
            }         
        }

        [HttpGet("/EnvelopeKey/{envelopeReceiverId}")]
        public IActionResult ShowEnvelope([FromRoute] string envelopeReceiverId) => Redirect($"/EnvelopeKey/{envelopeReceiverId}/Locked");

        [HttpPost("/EnvelopeKey/{envelopeReceiverId}/Locked")]
        public async Task<IActionResult> ShowEnvelopePost([FromRoute] string envelopeReceiverId, [FromForm] string access_code)
        {
            var envlopeServiceResult = await _envelopeService.ReadByUuidAsync(envelopeUuid, withDocuments: true, withReceivers: true, withHistory: true, withDocumentReceiverElement:true);

            EnvelopeResponse response = await envelopeOldService.LoadEnvelope(envelopeReceiverId);
            string accessCode = response.Receiver.AccessCode;

            if (string.IsNullOrEmpty(access_code))
            {
                return Redirect($"/EnvelopeKey/{envelopeReceiverId}/Locked");
            }

            if (accessCode == access_code)
            {
                database.Services.actionService.EnterCorrectAccessCode(response.Envelope, response.Receiver);   //for history
                ViewData["EnvelopeKey"] = envelopeReceiverId;
                return View("ShowEnvelope", envlopeServiceResult);
            } 
            else
            {
                database.Services.actionService.EnterIncorrectAccessCode(response.Envelope, response.Receiver); //for history
                return Unauthorized();

            }
        }

        [HttpGet("/EnvelopeKey/{envelopeReceiverId}/Locked")]
        public async Task<IActionResult> EnvelopeLocked([FromRoute] string envelopeReceiverId)
        {
            ViewData["EnvelopeKey"] = envelopeReceiverId;
            return View();
        }

        [HttpGet("/EnvelopeKey/{EnvelopeReceiverId}/Success")]
        public IActionResult EnvelopeSigned()
        {
            ViewData["EnvelopeKey"] = HttpContext.Request.RouteValues["EnvelopeReceiverId"];

            return View();
        }

        [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
        public IActionResult Error()
        {
            return View(new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });
        }
    }
}