using Api.SeaHavenIndustries.Controllers;
using Data.SeaHavenIndustries;
using FluentAssertions;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Moq;
using SeaHaven.Services.DTOs;
using SeaHaven.Services.Interfaces;
using System.Security.Claims;
using Xunit;

namespace Api.SeaHavenIndustries.Tests;

public class UpliftControllerTests
{
    private static UpliftController NewController(Mock<IUpliftService> service, params string[] roles)
    {
        var controller = new UpliftController(service.Object, Mock.Of<ILogger<UpliftController>>());
        var claims = new List<Claim> { new(ClaimTypes.NameIdentifier, "42") };
        claims.AddRange(roles.Select(r => new Claim(ClaimTypes.Role, r)));
        controller.ControllerContext = new ControllerContext
        {
            HttpContext = new DefaultHttpContext
            {
                User = new ClaimsPrincipal(new ClaimsIdentity(claims, "Test"))
            }
        };
        return controller;
    }

    [Fact]
    public async Task List_ReturnsPagedResult()
    {
        var service = new Mock<IUpliftService>();
        var dto = new UpliftListResultDTO
        {
            Total = 1,
            Page = 1,
            PageSize = 25,
            Items = new[] { new UpliftListItemDTO { Id = 5, Status = "Pending" } }
        };
        service.Setup(x => x.ListAsync(It.IsAny<ClaimsPrincipal>(), "Pending", null, 1, 25, It.IsAny<CancellationToken>()))
            .ReturnsAsync(dto);

        var controller = NewController(service);

        var result = await controller.List();

        var ok = result.Should().BeOfType<OkObjectResult>().Subject;
        var envelope = ok.Value.Should().BeOfType<DataResponse>().Subject;
        envelope.Status.Should().Be("Success");
    }

    [Fact]
    public async Task Approve_NotFound_Returns404()
    {
        var service = new Mock<IUpliftService>();
        service.Setup(x => x.ApproveAsync(It.IsAny<ClaimsPrincipal>(), 99, null, It.IsAny<CancellationToken>()))
            .ThrowsAsync(new KeyNotFoundException("not found"));

        var controller = NewController(service);

        var result = await controller.Approve(99, null);

        var nf = result.Should().BeOfType<NotFoundObjectResult>().Subject;
        nf.Value.Should().BeOfType<Response>();
    }

    [Fact]
    public async Task Approve_Forbidden_ReturnsSanitized403AndLogsInternally()
    {
        var service = new Mock<IUpliftService>();
        service.Setup(x => x.ApproveAsync(It.IsAny<ClaimsPrincipal>(), 5, null, It.IsAny<CancellationToken>()))
               .ThrowsAsync(new UpliftForbiddenException("SECRET-tier-restriction-detail"));

        var logger = new Mock<ILogger<UpliftController>>();
        logger.Setup(x => x.IsEnabled(It.IsAny<LogLevel>())).Returns(true);
        var controller = new UpliftController(service.Object, logger.Object);
        controller.ControllerContext = new ControllerContext
        {
            HttpContext = new DefaultHttpContext
            {
                User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim(ClaimTypes.NameIdentifier, "42") }, "Test"))
            }
        };

        var result = await controller.Approve(5, null);

        var status = result.Should().BeOfType<ObjectResult>().Subject;
        status.StatusCode.Should().Be(403);
        var response = status.Value.Should().BeOfType<Response>().Subject;
        response.Message.Should().NotContain("SECRET");
        response.Message.Should().Contain("reference");
        logger.Verify(
            x => x.Log(
                LogLevel.Error,
                It.IsAny<EventId>(),
                It.IsAny<It.IsAnyType>(),
                It.Is<Exception>(ex => ex.Message.Contains("SECRET")),
                It.IsAny<Func<It.IsAnyType, Exception?, string>>()),
            Times.Once);
    }

    [Fact]
    public async Task Approve_ForbiddenTier_Returns403()
    {
        var service = new Mock<IUpliftService>();
        service.Setup(x => x.ApproveAsync(It.IsAny<ClaimsPrincipal>(), 5, null, It.IsAny<CancellationToken>()))
            .ThrowsAsync(new UpliftForbiddenException("requires Tier 2"));

        var controller = NewController(service);

        var result = await controller.Approve(5, null);

        var status = result.Should().BeOfType<ObjectResult>().Subject;
        status.StatusCode.Should().Be(403);
    }

    [Fact]
    public async Task Approve_AlreadyDecided_Returns400()
    {
        var service = new Mock<IUpliftService>();
        service.Setup(x => x.ApproveAsync(It.IsAny<ClaimsPrincipal>(), 5, null, It.IsAny<CancellationToken>()))
            .ThrowsAsync(new InvalidOperationException("already decided"));

        var controller = NewController(service);

        var result = await controller.Approve(5, null);

        result.Should().BeOfType<BadRequestObjectResult>();
    }

    [Fact]
    public async Task Approve_Success_ReturnsApprovedResult()
    {
        var service = new Mock<IUpliftService>();
        var approved = new UpliftApproveResultDTO { Id = 5, Status = "Approved", NTEAmount = 750m };
        service.Setup(x => x.ApproveAsync(It.IsAny<ClaimsPrincipal>(), 5, "ok", It.IsAny<CancellationToken>()))
            .ReturnsAsync(approved);

        var controller = NewController(service);

        var result = await controller.Approve(5, new UpliftController.DecisionRequest { Note = "ok" });

        var ok = result.Should().BeOfType<OkObjectResult>().Subject;
        var envelope = ok.Value.Should().BeOfType<DataResponse>().Subject;
        var approveData = envelope.Data as UpliftApproveResultDTO;
        approveData.Should().Be(approved);
    }

    [Fact]
    public async Task Deny_WithoutNote_Returns400()
    {
        var service = new Mock<IUpliftService>();
        service.Setup(x => x.DenyAsync(It.IsAny<ClaimsPrincipal>(), 5, null, It.IsAny<CancellationToken>()))
            .ThrowsAsync(new InvalidOperationException("A note is required when denying"));

        var controller = NewController(service);

        var result = await controller.Deny(5, null);

        result.Should().BeOfType<BadRequestObjectResult>();
    }

    [Fact]
    public async Task Deny_Success_ReturnsDeniedResult()
    {
        var service = new Mock<IUpliftService>();
        var denied = new UpliftDenyResultDTO { Id = 5, Status = "Denied" };
        service.Setup(x => x.DenyAsync(It.IsAny<ClaimsPrincipal>(), 5, "too high", It.IsAny<CancellationToken>()))
            .ReturnsAsync(denied);

        var controller = NewController(service);

        var result = await controller.Deny(5, new UpliftController.DecisionRequest { Note = "too high" });

        var ok = result.Should().BeOfType<OkObjectResult>().Subject;
        service.Verify(x => x.DenyAsync(It.IsAny<ClaimsPrincipal>(), 5, "too high", It.IsAny<CancellationToken>()), Times.Once);
    }

    [Fact]
    public void CanApprove_DelegatesToService()
    {
        var service = new Mock<IUpliftService>();
        service.Setup(x => x.CanApprove(It.IsAny<ClaimsPrincipal>(), 2))
            .Returns(true);

        var controller = NewController(service, "Manager");

        var result = controller.CanApprove(2);

        var ok = result.Should().BeOfType<OkObjectResult>().Subject;
        service.Verify(x => x.CanApprove(It.Is<ClaimsPrincipal>(p => p.IsInRole("Manager")), 2), Times.Once);
    }

    [Fact]
    public async Task ListForDispatch_ReturnsItems()
    {
        var service = new Mock<IUpliftService>();
        var items = new[] { new UpliftForDispatchDTO { Id = 1, DispatchId = 10 } };
        service.Setup(x => x.ListForDispatchAsync(It.IsAny<ClaimsPrincipal>(), 10, It.IsAny<CancellationToken>()))
            .ReturnsAsync(items);

        var controller = NewController(service);

        var result = await controller.ListForDispatch(10);

        var ok = result.Should().BeOfType<OkObjectResult>().Subject;
        var envelope = ok.Value.Should().BeOfType<DataResponse>().Subject;
        envelope.Status.Should().Be("Success");
    }
}