using System.Reflection;
using ErsatzTV.Application.Scheduling;
using ErsatzTV.Controllers.Api;
using ErsatzTV.Controllers.Api.Requests;
using ErsatzTV.Core;
using ErsatzTV.Core.Api.Scheduling;
using ErsatzTV.Core.Errors;
using LanguageExt;
using MediatR;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Routing;
using NSubstitute;
using NUnit.Framework;
using Shouldly;
using static LanguageExt.Prelude;

namespace ErsatzTV.Tests.Controllers;

[TestFixture]
public class TemplateControllerTests
{
    private TemplateController _controller = null!;
    private IMediator _mediator = null!;

    [SetUp]
    public void SetUp()
    {
        _mediator = Substitute.For<IMediator>();
        _controller = new TemplateController(_mediator)
        {
            // Provide a real HttpContext so the ETag/If-Match concurrency headers (#253) can be
            // read from Request and written to Response.
            ControllerContext = new ControllerContext { HttpContext = new DefaultHttpContext() }
        };
    }

    [Test]
    public void Controller_Should_Expose_Idiomatic_Rest_Routes()
    {
        ShouldHaveActionRoute(nameof(TemplateController.GetGroups), "GET", "/api/v1/templates/groups");
        ShouldHaveActionRoute(nameof(TemplateController.CreateGroup), "POST", "/api/v1/templates/groups");
        ShouldHaveActionRoute(nameof(TemplateController.DeleteGroup), "DELETE", "/api/v1/templates/groups/{id:int}");
        ShouldHaveActionRoute(nameof(TemplateController.GetAll), "GET", "/api/v1/templates");
        ShouldHaveActionRoute(nameof(TemplateController.GetById), "GET", "/api/v1/templates/{id:int}");
        ShouldHaveActionRoute(nameof(TemplateController.Create), "POST", "/api/v1/templates");
        ShouldHaveActionRoute(nameof(TemplateController.Delete), "DELETE", "/api/v1/templates/{id:int}");
        ShouldHaveActionRoute(nameof(TemplateController.GetItems), "GET", "/api/v1/templates/{id:int}/items");
        ShouldHaveActionRoute(nameof(TemplateController.Replace), "PUT", "/api/v1/templates/{id:int}");
        ShouldHaveActionRoute(nameof(TemplateController.Copy), "POST", "/api/v1/templates/{id:int}/copy");
    }

    [Test]
    public async Task CreateGroup_Should_Return_201_With_Location_And_Body()
    {
        _mediator.Send(Arg.Any<CreateTemplateGroup>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, TemplateGroupViewModel>(new TemplateGroupViewModel(5, "Prime Time", 0)));

        IActionResult result = await _controller.CreateGroup(
            new CreateTemplateGroupRequest("Prime Time"),
            CancellationToken.None);

        var created = result.ShouldBeOfType<CreatedResult>();
        created.Location.ShouldBe("/api/v1/templates/groups/5");
        created.Value.ShouldBeOfType<TemplateGroupResponseModel>().Name.ShouldBe("Prime Time");
        await _mediator.Received(1).Send(
            Arg.Is<CreateTemplateGroup>(c => c.Name == "Prime Time"),
            Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task CreateGroup_Should_Return_422_On_Validation_Error()
    {
        _mediator.Send(Arg.Any<CreateTemplateGroup>(), Arg.Any<CancellationToken>())
            .Returns(Left<BaseError, TemplateGroupViewModel>(BaseError.New("bad")));

        IActionResult result = await _controller.CreateGroup(
            new CreateTemplateGroupRequest(string.Empty),
            CancellationToken.None);

        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
    }

    [Test]
    public async Task DeleteGroup_Should_Return_204_When_Exists()
    {
        _mediator.Send(Arg.Any<GetAllTemplateGroups>(), Arg.Any<CancellationToken>())
            .Returns(new List<TemplateGroupViewModel> { new(3, "Prime Time", 0) });
        _mediator.Send(Arg.Any<DeleteTemplateGroup>(), Arg.Any<CancellationToken>())
            .Returns(Option<BaseError>.None);

        IActionResult result = await _controller.DeleteGroup(3, CancellationToken.None);

        result.ShouldBeOfType<NoContentResult>();
        await _mediator.Received(1).Send(
            Arg.Is<DeleteTemplateGroup>(c => c.TemplateGroupId == 3),
            Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task DeleteGroup_Should_Return_404_When_Missing()
    {
        _mediator.Send(Arg.Any<GetAllTemplateGroups>(), Arg.Any<CancellationToken>())
            .Returns(new List<TemplateGroupViewModel>());

        IActionResult result = await _controller.DeleteGroup(99, CancellationToken.None);

        result.ShouldBeOfType<NotFoundObjectResult>();
        await _mediator.DidNotReceive().Send(Arg.Any<DeleteTemplateGroup>(), Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task GetAll_Should_Map_ViewModels_To_Response_Models()
    {
        _mediator.Send(Arg.Any<GetAllTemplates>(), Arg.Any<CancellationToken>())
            .Returns(new List<TemplateViewModel> { MakeTemplate(1, 2, "Morning") });

        List<TemplateResponseModel> result = await _controller.GetAll(null, CancellationToken.None);

        result.Count.ShouldBe(1);
        result[0].Id.ShouldBe(1);
        result[0].TemplateGroupId.ShouldBe(2);
        result[0].Name.ShouldBe("Morning");
        await _mediator.DidNotReceive().Send(Arg.Any<GetTemplatesByTemplateGroupId>(), Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task GetAll_Should_Filter_By_TemplateGroupId_When_Provided()
    {
        _mediator.Send(Arg.Any<GetTemplatesByTemplateGroupId>(), Arg.Any<CancellationToken>())
            .Returns(new List<TemplateViewModel> { MakeTemplate(1, 2, "Morning") });

        List<TemplateResponseModel> result = await _controller.GetAll(2, CancellationToken.None);

        result.Count.ShouldBe(1);
        await _mediator.Received(1).Send(
            Arg.Is<GetTemplatesByTemplateGroupId>(c => c.TemplateGroupId == 2),
            Arg.Any<CancellationToken>());
        await _mediator.DidNotReceive().Send(Arg.Any<GetAllTemplates>(), Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task Create_Should_Return_201_And_Map_Request()
    {
        _mediator.Send(Arg.Any<CreateTemplate>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, TemplateViewModel>(MakeTemplate(8, 2, "Morning")));

        IActionResult result = await _controller.Create(
            new CreateTemplateRequest(2, "Morning"),
            CancellationToken.None);

        var created = result.ShouldBeOfType<CreatedResult>();
        created.Location.ShouldBe("/api/v1/templates/8");
        await _mediator.Received(1).Send(
            Arg.Is<CreateTemplate>(c => c.TemplateGroupId == 2 && c.Name == "Morning"),
            Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task Create_Should_Return_422_On_Validation_Error()
    {
        _mediator.Send(Arg.Any<CreateTemplate>(), Arg.Any<CancellationToken>())
            .Returns(Left<BaseError, TemplateViewModel>(BaseError.New("dupe")));

        IActionResult result = await _controller.Create(
            new CreateTemplateRequest(2, "Morning"),
            CancellationToken.None);

        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
    }

    [Test]
    public async Task GetById_Should_Return_200_For_Some()
    {
        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
            .Returns(Option<TemplateViewModel>.Some(MakeTemplate(4, 2, "Morning")));

        IActionResult result = await _controller.GetById(4, CancellationToken.None);

        result.ShouldBeOfType<OkObjectResult>().Value.ShouldBeOfType<TemplateResponseModel>().Id.ShouldBe(4);
    }

    [Test]
    public async Task GetById_Should_Return_404_For_None()
    {
        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
            .Returns(Option<TemplateViewModel>.None);

        IActionResult result = await _controller.GetById(4, CancellationToken.None);

        result.ShouldBeOfType<NotFoundObjectResult>();
    }

    [Test]
    public async Task Delete_Should_Return_204_When_Exists()
    {
        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
            .Returns(Option<TemplateViewModel>.Some(MakeTemplate(4, 2, "Morning")));
        _mediator.Send(Arg.Any<DeleteTemplate>(), Arg.Any<CancellationToken>())
            .Returns(Option<BaseError>.None);

        IActionResult result = await _controller.Delete(4, CancellationToken.None);

        result.ShouldBeOfType<NoContentResult>();
    }

    [Test]
    public async Task Delete_Should_Return_404_When_Missing()
    {
        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
            .Returns(Option<TemplateViewModel>.None);

        IActionResult result = await _controller.Delete(4, CancellationToken.None);

        result.ShouldBeOfType<NotFoundObjectResult>();
        await _mediator.DidNotReceive().Send(Arg.Any<DeleteTemplate>(), Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task GetItems_Should_Return_200_Ordered_By_StartTime()
    {
        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
            .Returns(Option<TemplateViewModel>.Some(MakeTemplate(4, 2, "Morning")));
        _mediator.Send(Arg.Any<GetTemplateItems>(), Arg.Any<CancellationToken>())
            .Returns(new List<TemplateItemViewModel>
            {
                MakeItem(20, "News", TimeSpan.FromHours(12), 30),
                MakeItem(10, "Cartoons", TimeSpan.FromHours(6), 60)
            });

        IActionResult result = await _controller.GetItems(4, CancellationToken.None);

        var items = result.ShouldBeOfType<OkObjectResult>().Value.ShouldBeOfType<List<TemplateItemResponseModel>>();
        items.Count.ShouldBe(2);
        items[0].BlockId.ShouldBe(10);
        items[0].StartTime.ShouldBe(TimeSpan.FromHours(6));
        items[0].BlockMinutes.ShouldBe(60);
        items[1].BlockId.ShouldBe(20);
    }

    [Test]
    public async Task GetItems_Should_Return_404_When_Template_Missing()
    {
        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
            .Returns(Option<TemplateViewModel>.None);

        IActionResult result = await _controller.GetItems(4, CancellationToken.None);

        result.ShouldBeOfType<NotFoundObjectResult>();
    }

    [Test]
    public async Task Replace_Should_Return_200_With_Refreshed_Template_And_Map_Items()
    {
        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
            .Returns(Option<TemplateViewModel>.Some(MakeTemplate(4, 7, "Morning")));
        _mediator.Send(Arg.Any<ReplaceTemplateItems>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, List<TemplateItemViewModel>>(
                [MakeItem(10, "Cartoons", TimeSpan.FromHours(6), 60)]));
        _mediator.Send(Arg.Any<GetTemplateItems>(), Arg.Any<CancellationToken>())
            .Returns([MakeItem(10, "Cartoons", TimeSpan.FromHours(6), 60)]);

        IActionResult result = await _controller.Replace(
            4,
            new ReplaceTemplateRequest(
                "Morning",
                [new TemplateItemRequest(10, TimeSpan.FromHours(6))]),
            CancellationToken.None);

        var body = result.ShouldBeOfType<OkObjectResult>().Value.ShouldBeOfType<TemplateWithItemsResponseModel>();
        body.Id.ShouldBe(4);
        body.Items.Count.ShouldBe(1);
        await _mediator.Received(1).Send(
            Arg.Is<ReplaceTemplateItems>(c =>
                c.TemplateId == 4 &&
                c.TemplateGroupId == 7 &&
                c.Name == "Morning" &&
                c.Items.Count == 1 &&
                c.Items[0].BlockId == 10 &&
                c.Items[0].StartTime == TimeSpan.FromHours(6)),
            Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task Replace_Should_Return_404_When_Template_Missing()
    {
        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
            .Returns(Option<TemplateViewModel>.None);

        IActionResult result = await _controller.Replace(
            4,
            new ReplaceTemplateRequest("Morning", []),
            CancellationToken.None);

        result.ShouldBeOfType<NotFoundObjectResult>();
        await _mediator.DidNotReceive().Send(Arg.Any<ReplaceTemplateItems>(), Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task Replace_Should_Return_422_On_Validation_Error()
    {
        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
            .Returns(Option<TemplateViewModel>.Some(MakeTemplate(4, 7, "Morning")));
        _mediator.Send(Arg.Any<ReplaceTemplateItems>(), Arg.Any<CancellationToken>())
            .Returns(Left<BaseError, List<TemplateItemViewModel>>(BaseError.New("overlap")));

        IActionResult result = await _controller.Replace(
            4,
            new ReplaceTemplateRequest("Morning", []),
            CancellationToken.None);

        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
    }

    [Test]
    public async Task GetItems_Should_Set_ETag_From_Template_Version()
    {
        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
            .Returns(Option<TemplateViewModel>.Some(MakeTemplate(4, 2, "Morning", version: 9)));
        _mediator.Send(Arg.Any<GetTemplateItems>(), Arg.Any<CancellationToken>())
            .Returns(new List<TemplateItemViewModel>());

        await _controller.GetItems(4, CancellationToken.None);

        _controller.Response.Headers.ETag.ToString().ShouldBe("\"9\"");
    }

    [Test]
    public async Task Replace_Should_Return_400_On_Malformed_If_Match()
    {
        _controller.Request.Headers.IfMatch = "not-an-etag";

        IActionResult result = await _controller.Replace(
            4,
            new ReplaceTemplateRequest("Morning", []),
            CancellationToken.None);

        result.ShouldBeOfType<BadRequestObjectResult>();
        await _mediator.DidNotReceive().Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>());
        await _mediator.DidNotReceive().Send(Arg.Any<ReplaceTemplateItems>(), Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task Replace_Should_Thread_If_Match_Version_Into_Command()
    {
        _controller.Request.Headers.IfMatch = "\"3\"";
        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
            .Returns(Option<TemplateViewModel>.Some(MakeTemplate(4, 7, "Morning", version: 4)));
        _mediator.Send(Arg.Any<ReplaceTemplateItems>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, List<TemplateItemViewModel>>([]));
        _mediator.Send(Arg.Any<GetTemplateItems>(), Arg.Any<CancellationToken>())
            .Returns(new List<TemplateItemViewModel>());

        IActionResult result = await _controller.Replace(
            4,
            new ReplaceTemplateRequest("Morning", []),
            CancellationToken.None);

        result.ShouldBeOfType<OkObjectResult>();
        // On success the response carries the refreshed template's ETag.
        _controller.Response.Headers.ETag.ToString().ShouldBe("\"4\"");
        await _mediator.Received(1).Send(
            Arg.Is<ReplaceTemplateItems>(c => c.ExpectedVersions == Option<Seq<int>>.Some(new[] { 3 }.ToSeq())),
            Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task Replace_Without_If_Match_Should_Force_Write()
    {
        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
            .Returns(Option<TemplateViewModel>.Some(MakeTemplate(4, 7, "Morning")));
        _mediator.Send(Arg.Any<ReplaceTemplateItems>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, List<TemplateItemViewModel>>([]));
        _mediator.Send(Arg.Any<GetTemplateItems>(), Arg.Any<CancellationToken>())
            .Returns(new List<TemplateItemViewModel>());

        await _controller.Replace(
            4,
            new ReplaceTemplateRequest("Morning", []),
            CancellationToken.None);

        await _mediator.Received(1).Send(
            Arg.Is<ReplaceTemplateItems>(c => c.ExpectedVersions == Option<Seq<int>>.None),
            Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task Replace_Should_Return_412_On_Precondition_Failed()
    {
        _controller.Request.Headers.IfMatch = "\"2\"";
        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
            .Returns(Option<TemplateViewModel>.Some(MakeTemplate(4, 7, "Morning", version: 5)));
        _mediator.Send(Arg.Any<ReplaceTemplateItems>(), Arg.Any<CancellationToken>())
            .Returns(Left<BaseError, List<TemplateItemViewModel>>(new PreconditionFailedError("stale")));

        IActionResult result = await _controller.Replace(
            4,
            new ReplaceTemplateRequest("Morning", []),
            CancellationToken.None);

        var objectResult = result.ShouldBeOfType<ObjectResult>();
        objectResult.StatusCode.ShouldBe(StatusCodes.Status412PreconditionFailed);
    }

    [Test]
    public async Task Copy_Should_Return_201_And_Map_Request()
    {
        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
            .Returns(Option<TemplateViewModel>.Some(MakeTemplate(4, 2, "Morning")));
        _mediator.Send(Arg.Any<CopyTemplate>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, TemplateViewModel>(MakeTemplate(9, 3, "Morning Copy")));

        IActionResult result = await _controller.Copy(
            4,
            new CopyTemplateRequest(3, "Morning Copy"),
            CancellationToken.None);

        var created = result.ShouldBeOfType<CreatedResult>();
        created.Location.ShouldBe("/api/v1/templates/9");
        await _mediator.Received(1).Send(
            Arg.Is<CopyTemplate>(c => c.TemplateId == 4 && c.NewTemplateGroupId == 3 && c.NewTemplateName == "Morning Copy"),
            Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task Copy_Should_Return_404_When_Source_Missing()
    {
        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
            .Returns(Option<TemplateViewModel>.None);

        IActionResult result = await _controller.Copy(
            4,
            new CopyTemplateRequest(3, "Morning Copy"),
            CancellationToken.None);

        result.ShouldBeOfType<NotFoundObjectResult>();
        await _mediator.DidNotReceive().Send(Arg.Any<CopyTemplate>(), Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task Copy_Should_Return_422_On_Validation_Error()
    {
        _mediator.Send(Arg.Any<GetTemplateById>(), Arg.Any<CancellationToken>())
            .Returns(Option<TemplateViewModel>.Some(MakeTemplate(4, 2, "Morning")));
        _mediator.Send(Arg.Any<CopyTemplate>(), Arg.Any<CancellationToken>())
            .Returns(Left<BaseError, TemplateViewModel>(BaseError.New("dupe")));

        IActionResult result = await _controller.Copy(
            4,
            new CopyTemplateRequest(3, "Morning"),
            CancellationToken.None);

        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
    }

    private static TemplateViewModel MakeTemplate(int id, int groupId, string name, int version = 1) =>
        new(id, groupId, "Group", name, version);

    private static TemplateItemViewModel MakeItem(int blockId, string blockName, TimeSpan startTime, int minutes)
    {
        DateTime start = DateTime.Today.Add(startTime);
        return new TemplateItemViewModel(blockId, blockName, start, start.AddMinutes(minutes));
    }

    private static void ShouldHaveActionRoute(string actionName, string httpMethod, string route)
    {
        MethodInfo action = typeof(TemplateController).GetMethod(actionName)
            ?? throw new AssertionException($"Missing action {actionName}");

        HttpMethodAttribute attribute = action.GetCustomAttributes<HttpMethodAttribute>(inherit: true).Single();
        attribute.HttpMethods.ShouldContain(httpMethod);
        attribute.Template.ShouldBe(route);
    }
}