using System;
using System.Threading.Tasks;
using FrameworkBLL.GOP;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.DTO.Framework.ResponseStandard;
using GB5Shared.DTO.GOP;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using static GB5Shared.GB5Constant.Constant;

namespace FrameworkSL.Controllers.GOP
{
    /// <summary>
    /// GOP Queue &amp; Execution Controller
    ///
    /// POST SubmitExecution  — resolve binding → enqueue → fire worker (returns immediately)
    /// GET  GetExecutionStatus    — header + state-log for a given executionId
    /// GET  GetExecutionNodeLogs  — per-node attempt detail
    /// GET  GetQueueDashboard     — status counts across all queues
    /// GET  GetDeadLetters        — unresolved DLQ entries
    /// POST ResolveDeadLetter     — mark a DLQ entry resolved
    /// POST OpenRemediation       — open a manual remediation case
    /// POST ResolveRemediation    — close a remediation case
    /// GET  GetOpenRemediations   — all Open/InProgress cases
    /// </summary>
    [ApiController]
    [Route("[controller]")]
    public class GopQueueService : ControllerBase
    {
        private readonly IGopQueueBLL _IGopQueueBLL;

        public GopQueueService(IGopQueueBLL IGopQueueBLL)
        {
            _IGopQueueBLL = IGopQueueBLL;
        }

        // ── Submit ────────────────────────────────────────────────

        /// <summary>
        /// Resolves the source binding, enqueues the execution, and fires the worker.
        /// Returns QueueId + ExecutionId immediately (202 Accepted pattern).
        /// </summary>
        [HttpPost("SubmitExecution")]
        public async Task<ResponseStandardDTO<object>> SubmitExecution(
            [FromBody]   GopSubmitRequestDTO Request,
            [FromHeader(Name = "Login")] string LoginDTOJson)
        {
            var LoginDTO = JsonConvert.DeserializeObject<LoginDTO>(LoginDTOJson);
            try
            {
                var result = await _IGopQueueBLL.SubmitExecution(Request, LoginDTO!);
                return await GB5Shared.ResponseStandard.Response.CreateSuccessResponse(
                    result, CacheKeyLevel.NOT_REQUIRED, LoginDTO!);
            }
            catch (Exception ex)
            {
                return await GB5Shared.ResponseStandard.Response.CreateExceptionError<string>(
                    ex, CacheKeyLevel.NOT_REQUIRED, LoginDTO!, ex.Message, 500);
            }
        }

        // ── Query ─────────────────────────────────────────────────

        /// <summary>Returns execution header + state-log for a given ExecutionId.</summary>
        [HttpGet("GetExecutionStatus")]
        public async Task<ResponseStandardDTO<object>> GetExecutionStatus(
            int ExecutionId,
            [FromHeader(Name = "Login")] string LoginDTOJson)
        {
            var LoginDTO = JsonConvert.DeserializeObject<LoginDTO>(LoginDTOJson);
            try
            {
                var result = await _IGopQueueBLL.GetExecutionStatus(ExecutionId, LoginDTO!);
                return await GB5Shared.ResponseStandard.Response.CreateSuccessResponse(
                    result, CacheKeyLevel.NOT_REQUIRED, LoginDTO!);
            }
            catch (Exception ex)
            {
                return await GB5Shared.ResponseStandard.Response.CreateExceptionError<string>(
                    ex, CacheKeyLevel.NOT_REQUIRED, LoginDTO!, ex.Message, 500);
            }
        }

        /// <summary>Returns all node-log attempts for a given ExecutionId.</summary>
        [HttpGet("GetExecutionNodeLogs")]
        public async Task<ResponseStandardDTO<object>> GetExecutionNodeLogs(
            int ExecutionId,
            [FromHeader(Name = "Login")] string LoginDTOJson)
        {
            var LoginDTO = JsonConvert.DeserializeObject<LoginDTO>(LoginDTOJson);
            try
            {
                var result = await _IGopQueueBLL.GetExecutionNodeLogs(ExecutionId, LoginDTO!);
                return await GB5Shared.ResponseStandard.Response.CreateSuccessResponse(
                    result, CacheKeyLevel.NOT_REQUIRED, LoginDTO!);
            }
            catch (Exception ex)
            {
                return await GB5Shared.ResponseStandard.Response.CreateExceptionError<string>(
                    ex, CacheKeyLevel.NOT_REQUIRED, LoginDTO!, ex.Message, 500);
            }
        }

        /// <summary>Returns queue status counts (dashboard summary).</summary>
        [HttpGet("GetQueueDashboard")]
        public async Task<ResponseStandardDTO<object>> GetQueueDashboard(
            [FromHeader(Name = "Login")] string LoginDTOJson)
        {
            var LoginDTO = JsonConvert.DeserializeObject<LoginDTO>(LoginDTOJson);
            try
            {
                var result = await _IGopQueueBLL.GetQueueDashboard(LoginDTO!);
                return await GB5Shared.ResponseStandard.Response.CreateSuccessResponse(
                    result, CacheKeyLevel.NOT_REQUIRED, LoginDTO!);
            }
            catch (Exception ex)
            {
                return await GB5Shared.ResponseStandard.Response.CreateExceptionError<string>(
                    ex, CacheKeyLevel.NOT_REQUIRED, LoginDTO!, ex.Message, 500);
            }
        }

        // ── Dead Letter ───────────────────────────────────────────

        /// <summary>Returns all unresolved dead-letter entries for the client.</summary>
        [HttpGet("GetDeadLetters")]
        public async Task<ResponseStandardDTO<object>> GetDeadLetters(
            [FromHeader(Name = "Login")] string LoginDTOJson)
        {
            var LoginDTO = JsonConvert.DeserializeObject<LoginDTO>(LoginDTOJson);
            try
            {
                var result = await _IGopQueueBLL.GetDeadLetters(LoginDTO!);
                return await GB5Shared.ResponseStandard.Response.CreateSuccessResponse(
                    result, CacheKeyLevel.NOT_REQUIRED, LoginDTO!);
            }
            catch (Exception ex)
            {
                return await GB5Shared.ResponseStandard.Response.CreateExceptionError<string>(
                    ex, CacheKeyLevel.NOT_REQUIRED, LoginDTO!, ex.Message, 500);
            }
        }

        /// <summary>Marks a dead-letter entry as resolved.</summary>
        [HttpPost("ResolveDeadLetter")]
        public async Task<ResponseStandardDTO<object>> ResolveDeadLetter(
            int    DlqId,
            string ResolvedBy,
            [FromHeader(Name = "Login")] string LoginDTOJson)
        {
            var LoginDTO = JsonConvert.DeserializeObject<LoginDTO>(LoginDTOJson);
            try
            {
                await _IGopQueueBLL.ResolveDeadLetter(DlqId, ResolvedBy, LoginDTO!);
                return await GB5Shared.ResponseStandard.Response.CreateSuccessResponse(
                    $"DLQ entry {DlqId} resolved.", CacheKeyLevel.NOT_REQUIRED, LoginDTO!);
            }
            catch (Exception ex)
            {
                return await GB5Shared.ResponseStandard.Response.CreateExceptionError<string>(
                    ex, CacheKeyLevel.NOT_REQUIRED, LoginDTO!, ex.Message, 500);
            }
        }

        // ── Remediation ───────────────────────────────────────────

        /// <summary>Opens a manual remediation case for a failed execution node.</summary>
        [HttpPost("OpenRemediation")]
        public async Task<ResponseStandardDTO<object>> OpenRemediation(
            [FromBody]   GopOpenRemediationRequestDTO Request,
            [FromHeader(Name = "Login")] string LoginDTOJson)
        {
            var LoginDTO = JsonConvert.DeserializeObject<LoginDTO>(LoginDTOJson);
            try
            {
                int remId = await _IGopQueueBLL.OpenRemediation(Request, LoginDTO!);
                return await GB5Shared.ResponseStandard.Response.CreateSuccessResponse(
                    new { RemediationId = remId, Message = "Remediation case opened." },
                    CacheKeyLevel.NOT_REQUIRED, LoginDTO!);
            }
            catch (Exception ex)
            {
                return await GB5Shared.ResponseStandard.Response.CreateExceptionError<string>(
                    ex, CacheKeyLevel.NOT_REQUIRED, LoginDTO!, ex.Message, 500);
            }
        }

        /// <summary>Resolves (closes) an open remediation case.</summary>
        [HttpPost("ResolveRemediation")]
        public async Task<ResponseStandardDTO<object>> ResolveRemediation(
            [FromBody]   GopResolveRemediationRequestDTO Request,
            [FromHeader(Name = "Login")] string LoginDTOJson)
        {
            var LoginDTO = JsonConvert.DeserializeObject<LoginDTO>(LoginDTOJson);
            try
            {
                await _IGopQueueBLL.ResolveRemediation(Request, LoginDTO!);
                return await GB5Shared.ResponseStandard.Response.CreateSuccessResponse(
                    $"Remediation {Request.RemediationId} resolved.",
                    CacheKeyLevel.NOT_REQUIRED, LoginDTO!);
            }
            catch (Exception ex)
            {
                return await GB5Shared.ResponseStandard.Response.CreateExceptionError<string>(
                    ex, CacheKeyLevel.NOT_REQUIRED, LoginDTO!, ex.Message, 500);
            }
        }

        /// <summary>Returns all Open/InProgress remediation cases for the client.</summary>
        [HttpGet("GetOpenRemediations")]
        public async Task<ResponseStandardDTO<object>> GetOpenRemediations(
            [FromHeader(Name = "Login")] string LoginDTOJson)
        {
            var LoginDTO = JsonConvert.DeserializeObject<LoginDTO>(LoginDTOJson);
            try
            {
                var result = await _IGopQueueBLL.GetOpenRemediations(LoginDTO!);
                return await GB5Shared.ResponseStandard.Response.CreateSuccessResponse(
                    result, CacheKeyLevel.NOT_REQUIRED, LoginDTO!);
            }
            catch (Exception ex)
            {
                return await GB5Shared.ResponseStandard.Response.CreateExceptionError<string>(
                    ex, CacheKeyLevel.NOT_REQUIRED, LoginDTO!, ex.Message, 500);
            }
        }
    }
}