using EnvelopeGenerator.Application.Contracts;
using EnvelopeGenerator.Common;
using EnvelopeGenerator.Web.Services;
using Microsoft.AspNetCore.Mvc;

namespace EnvelopeGenerator.Web.Controllers
{
    public class EnvelopeController : BaseController
    {
        private readonly EnvelopeOldService envelopeService;
        private readonly ActionService? actionService;
        private readonly IEnvelopeService _envelopeService;

        public EnvelopeController(DatabaseService database, EnvelopeOldService envelope, ILogger<EnvelopeController> logger, IEnvelopeService envService) : base(database, logger)
        {
            envelopeService = envelope;
            actionService = database?.Services?.actionService;
            _envelopeService = envService;
        }

        [HttpGet("api/envelope/{envelopeKey}")]
        public async Task<IActionResult> Get(string envelopeKey)
        {
            //_logger.LogInformation($"Loading Envelope by Key [{envelopeKey}]");

            //Tuple<string, string> result = Helpers.DecodeEnvelopeReceiverId(envelopeKey);
            //var envelopeUuid = result.Item1;
            //var receiverSignature = result.Item2;
            ////var receiverId = receiverModel.GetReceiverIdBySignature(receiverSignature);

            ////_logger.LogInformation("Resolved receiver signature to receiverId [{0}]", receiverId);

            //var envlopeServiceResult = await _envelopeService.ReadByUuidAsync(envelopeUuid, withDocuments:true, withReceivers:true, withHistory:true);

            //_logger.LogInformation("Loading envelope..");

            try
            {
                // Validate Envelope Key and load envelope
                envelopeService.EnsureValidEnvelopeKey(envelopeKey);
                EnvelopeResponse response = await envelopeService.LoadEnvelope(envelopeKey);
            
                if (envelopeService.ReceiverAlreadySigned(response.Envelope, response.Receiver.Id) == true)
                {
                    return Problem(statusCode: 403);
                }          

                _logger.LogInformation("Loaded envelope [{0}] for receiver [{1}]", response.Envelope.Id, response.Envelope.Id);
                return Json(response);
            }
            catch (Exception e)
            {
                return ErrorResponse(e);
            }
        }

        [HttpPost("api/envelope/{envelopeKey}")]
        public async Task<IActionResult> Update(string envelopeKey, int index)
        {
            try
            {
                // Validate Envelope Key and load envelope
                envelopeService.EnsureValidEnvelopeKey(envelopeKey);
                EnvelopeResponse response = await envelopeService.LoadEnvelope(envelopeKey);

                // Again check if receiver has already signed
                if (envelopeService.ReceiverAlreadySigned(response.Envelope, response.Receiver.Id) == true)
                {
                    return Problem(statusCode: 403);
                }

                var document = envelopeService.GetDocument(index, envelopeKey);

                string? annotationData = await envelopeService.EnsureValidAnnotationData(Request);

                envelopeService.InsertDocumentStatus(new DocumentStatus()
                {
                    EnvelopeId = response.Envelope.Id,
                    ReceiverId = response.Receiver.Id,
                    Value = annotationData,
                    Status = Common.Constants.DocumentStatus.Signed
                });

                var signResult = actionService?.SignEnvelope(response.Envelope, response.Receiver);

                return Ok();
            }
            catch (Exception e)
            {
                return ErrorResponse(e);
            }
        }
    }
}