using System.Linq;
using System.Reflection;
using ErsatzTV.Application.ProgramSchedules;
using ErsatzTV.Controllers.Api;
using ErsatzTV.Controllers.Api.Requests;
using ErsatzTV.Core;
using ErsatzTV.Core.Api.Scheduling;
using ErsatzTV.Core.Domain;
using ErsatzTV.Core.Errors;
using ErsatzTV.Core.Scheduling;
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;
using Unit = LanguageExt.Unit;

namespace ErsatzTV.Tests.Controllers;

[TestFixture]
public class ScheduleControllerTests
{
    private ScheduleController _controller = null!;
    private IMediator _mediator = null!;

    [SetUp]
    public void SetUp()
    {
        _mediator = Substitute.For<IMediator>();
        _controller = new ScheduleController(_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(ScheduleController.GetAll), "GET", "/api/v1/schedules");
        ShouldHaveActionRoute(nameof(ScheduleController.GetById), "GET", "/api/v1/schedules/{id:int}");
        ShouldHaveActionRoute(nameof(ScheduleController.Create), "POST", "/api/v1/schedules");
        ShouldHaveActionRoute(nameof(ScheduleController.Update), "PUT", "/api/v1/schedules/{id:int}");
        ShouldHaveActionRoute(nameof(ScheduleController.Delete), "DELETE", "/api/v1/schedules/{id:int}");
        ShouldHaveActionRoute(nameof(ScheduleController.GetItems), "GET", "/api/v1/schedules/{id:int}/items");
        ShouldHaveActionRoute(nameof(ScheduleController.AddItem), "POST", "/api/v1/schedules/{id:int}/items");
        ShouldHaveActionRoute(nameof(ScheduleController.ReplaceItems), "PUT", "/api/v1/schedules/{id:int}/items");
        ShouldHaveActionRoute(
            nameof(ScheduleController.DeleteItem),
            "DELETE",
            "/api/v1/schedules/{id:int}/items/{itemId:int}");
    }

    [Test]
    public void Update_Should_Use_Stable_Update_Request_Dto()
    {
        MethodInfo action = typeof(ScheduleController).GetMethod(nameof(ScheduleController.Update))
            ?? throw new AssertionException($"Missing action {nameof(ScheduleController.Update)}");

        action.GetParameters()[1].ParameterType.ShouldBe(typeof(UpdateScheduleRequest));
    }

    [Test]
    public async Task Create_Should_Return_201_With_Location_And_Body()
    {
        _mediator.Send(Arg.Any<CreateProgramSchedule>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, CreateProgramScheduleResult>(new CreateProgramScheduleResult(5)));
        ProgramScheduleViewModel vm = MakeSchedule(5, "Daily");
        _mediator.Send(Arg.Any<GetProgramScheduleById>(), Arg.Any<CancellationToken>())
            .Returns(Option<ProgramScheduleViewModel>.Some(vm));

        IActionResult result = await _controller.Create(MakeScheduleRequest("Daily"), CancellationToken.None);

        var created = result.ShouldBeOfType<CreatedResult>();
        created.StatusCode.ShouldBe(201);
        created.Location.ShouldBe("/api/v1/schedules/5");
        created.Value.ShouldBe(
            new ProgramScheduleResponseModel(5, "Daily", true, true, false, false, FixedStartTimeBehavior.Flexible, null));
    }

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

        IActionResult result = await _controller.Create(MakeScheduleRequest(string.Empty), CancellationToken.None);

        var unprocessable = result.ShouldBeOfType<UnprocessableEntityObjectResult>();
        var problem = unprocessable.Value.ShouldBeOfType<ProblemDetails>();
        problem.Status.ShouldBe(422);
        problem.Title.ShouldBe("Validation failed");
    }

    [Test]
    public async Task Create_Should_Map_Request_To_Command()
    {
        _mediator.Send(Arg.Any<CreateProgramSchedule>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, CreateProgramScheduleResult>(new CreateProgramScheduleResult(5)));
        _mediator.Send(Arg.Any<GetProgramScheduleById>(), Arg.Any<CancellationToken>())
            .Returns(Option<ProgramScheduleViewModel>.Some(MakeSchedule(5, "Daily")));

        await _controller.Create(MakeScheduleRequest("Daily"), CancellationToken.None);

        await _mediator.Received(1).Send(
            Arg.Is<CreateProgramSchedule>(c =>
                c.Name == "Daily" &&
                c.KeepMultiPartEpisodesTogether &&
                c.TreatCollectionsAsShows &&
                c.ShuffleScheduleItems &&
                c.RandomStartPoint &&
                c.FixedStartTimeBehavior == FixedStartTimeBehavior.Flexible),
            Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task Update_Should_Return_200_And_Map_Route_Id()
    {
        _mediator.Send(Arg.Any<UpdateProgramSchedule>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, UpdateProgramScheduleResult>(new UpdateProgramScheduleResult(7)));
        ProgramScheduleViewModel vm = MakeSchedule(7, "Updated");
        _mediator.Send(Arg.Any<GetProgramScheduleById>(), Arg.Any<CancellationToken>())
            .Returns(Option<ProgramScheduleViewModel>.Some(vm));

        IActionResult result = await _controller.Update(7, MakeUpdateScheduleRequest("Updated"), CancellationToken.None);

        result.ShouldBeOfType<OkObjectResult>().Value.ShouldBe(
            new ProgramScheduleResponseModel(7, "Updated", true, true, false, false, FixedStartTimeBehavior.Flexible, null));
        await _mediator.Received(1).Send(
            Arg.Is<UpdateProgramSchedule>(c => c.ProgramScheduleId == 7 && c.Name == "Updated"),
            Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task Update_Should_Return_404_For_NotFoundError_With_ProblemDetails()
    {
        _mediator.Send(Arg.Any<UpdateProgramSchedule>(), Arg.Any<CancellationToken>())
            .Returns(Left<BaseError, UpdateProgramScheduleResult>(new NotFoundError("missing")));

        IActionResult result = await _controller.Update(99, MakeUpdateScheduleRequest("Missing"), CancellationToken.None);

        var notFound = result.ShouldBeOfType<NotFoundObjectResult>();
        var problem = notFound.Value.ShouldBeOfType<ProblemDetails>();
        problem.Status.ShouldBe(404);
        problem.Title.ShouldBe("Resource not found");
    }

    [Test]
    public async Task Delete_Should_Return_204_On_Success()
    {
        _mediator.Send(Arg.Any<DeleteProgramSchedule>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, Unit>(Unit.Default));

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

        result.ShouldBeOfType<NoContentResult>();
    }

    [Test]
    public async Task Delete_Should_Return_404_For_NotFoundError()
    {
        _mediator.Send(Arg.Any<DeleteProgramSchedule>(), Arg.Any<CancellationToken>())
            .Returns(Left<BaseError, Unit>(new NotFoundError("missing")));

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

        result.ShouldBeOfType<NotFoundObjectResult>();
    }

    [Test]
    public async Task GetById_Should_Return_200_For_Some()
    {
        ProgramScheduleViewModel vm = MakeSchedule(4, "Daily");
        _mediator.Send(Arg.Any<GetProgramScheduleById>(), Arg.Any<CancellationToken>())
            .Returns(Option<ProgramScheduleViewModel>.Some(vm));

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

        result.ShouldBeOfType<OkObjectResult>().Value.ShouldBe(
            new ProgramScheduleResponseModel(4, "Daily", true, true, false, false, FixedStartTimeBehavior.Flexible, null));
    }

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

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

        result.ShouldBeOfType<NotFoundObjectResult>();
    }

    [Test]
    public async Task GetItems_Should_Return_200_With_Items()
    {
        List<ProgramScheduleItemViewModel> items = [MakeOneItem(11)];
        var response = new ProgramScheduleItemsWithDurationViewModel(items, TimeSpan.FromMinutes(25));
        _mediator.Send(Arg.Any<GetProgramScheduleById>(), Arg.Any<CancellationToken>())
            .Returns(Option<ProgramScheduleViewModel>.Some(MakeSchedule(4, "Daily")));
        _mediator.Send(Arg.Any<GetProgramScheduleItemsWithDurations>(), Arg.Any<CancellationToken>())
            .Returns(response);

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

        var envelope = result.ShouldBeOfType<OkObjectResult>().Value.ShouldBeOfType<ScheduleItemsResponseModel>();
        envelope.TotalDurationEstimate.ShouldBe(TimeSpan.FromMinutes(25));
        envelope.Items.Count.ShouldBe(1);
        envelope.Items[0].Id.ShouldBe(11);
        await _mediator.Received(1).Send(
            Arg.Is<GetProgramScheduleItemsWithDurations>(q => q.Id == 4),
            Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task GetItems_Should_Return_404_When_Schedule_Missing()
    {
        _mediator.Send(Arg.Any<GetProgramScheduleById>(), Arg.Any<CancellationToken>())
            .Returns(Option<ProgramScheduleViewModel>.None);

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

        result.ShouldBeOfType<NotFoundObjectResult>();
    }

    [Test]
    public async Task AddItem_Should_Return_201_With_Location_And_Map_Route_Id()
    {
        ProgramScheduleItemViewModel item = MakeOneItem(12);
        _mediator.Send(Arg.Any<AddProgramScheduleItem>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, ProgramScheduleItemViewModel>(item));

        IActionResult result = await _controller.AddItem(4, MakeItemRequest(PlayoutMode.One), CancellationToken.None);

        var created = result.ShouldBeOfType<CreatedResult>();
        created.Location.ShouldBe("/api/v1/schedules/4/items/12");
        created.Value.ShouldBeOfType<ScheduleItemResponseModel>().Id.ShouldBe(12);
        await _mediator.Received(1).Send(
            Arg.Is<AddProgramScheduleItem>(c => c.ProgramScheduleId == 4 && c.PlayoutMode == PlayoutMode.One),
            Arg.Any<CancellationToken>());
    }

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

        IActionResult result = await _controller.AddItem(4, MakeItemRequest(PlayoutMode.Duration), CancellationToken.None);

        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
    }

    [Test]
    public async Task ReplaceItems_Should_Return_200_With_Items_And_Map_Route_Id()
    {
        List<ProgramScheduleItemViewModel> items = [MakeOneItem(21), MakeOneItem(22)];
        _mediator.Send(Arg.Any<ReplaceProgramScheduleItems>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, IEnumerable<ProgramScheduleItemViewModel>>(items));
        _mediator.Send(Arg.Any<GetProgramScheduleById>(), Arg.Any<CancellationToken>())
            .Returns(Option<ProgramScheduleViewModel>.Some(MakeSchedule(4, "Daily")));
        _mediator.Send(Arg.Any<GetProgramScheduleItems>(), Arg.Any<CancellationToken>())
            .Returns(items);

        IActionResult result = await _controller.ReplaceItems(
            4,
            new ReplaceScheduleItemsRequest([MakeItemRequest(PlayoutMode.One), MakeItemRequest(PlayoutMode.Multiple)]),
            CancellationToken.None);

        var replaced = result.ShouldBeOfType<OkObjectResult>().Value
            .ShouldBeOfType<List<ScheduleItemResponseModel>>();
        replaced.Select(i => i.Id).ShouldBe([21, 22]);
        await _mediator.Received(1).Send(
            Arg.Is<ReplaceProgramScheduleItems>(c =>
                c.ProgramScheduleId == 4 &&
                c.Items.Count == 2 &&
                c.Items[0].Index == 0 &&
                c.Items[1].PlayoutMode == PlayoutMode.Multiple),
            Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task GetItems_Should_Set_ETag_From_Schedule_Version()
    {
        var response = new ProgramScheduleItemsWithDurationViewModel([], null);
        _mediator.Send(Arg.Any<GetProgramScheduleById>(), Arg.Any<CancellationToken>())
            .Returns(Option<ProgramScheduleViewModel>.Some(MakeSchedule(4, "Daily", version: 9)));
        _mediator.Send(Arg.Any<GetProgramScheduleItemsWithDurations>(), Arg.Any<CancellationToken>())
            .Returns(response);

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

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

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

        IActionResult result = await _controller.ReplaceItems(
            4,
            new ReplaceScheduleItemsRequest([MakeItemRequest(PlayoutMode.One)]),
            CancellationToken.None);

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

    [Test]
    public async Task ReplaceItems_Should_Thread_If_Match_Version_Into_Command_And_Set_New_ETag()
    {
        _controller.Request.Headers.IfMatch = "\"3\"";
        _mediator.Send(Arg.Any<ReplaceProgramScheduleItems>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, IEnumerable<ProgramScheduleItemViewModel>>([MakeOneItem(21)]));
        _mediator.Send(Arg.Any<GetProgramScheduleById>(), Arg.Any<CancellationToken>())
            .Returns(Option<ProgramScheduleViewModel>.Some(MakeSchedule(4, "Daily", version: 4)));
        _mediator.Send(Arg.Any<GetProgramScheduleItems>(), Arg.Any<CancellationToken>())
            .Returns([MakeOneItem(21)]);

        IActionResult result = await _controller.ReplaceItems(
            4,
            new ReplaceScheduleItemsRequest([MakeItemRequest(PlayoutMode.One)]),
            CancellationToken.None);

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

    [Test]
    public async Task ReplaceItems_Without_If_Match_Should_Force_Write()
    {
        _mediator.Send(Arg.Any<ReplaceProgramScheduleItems>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, IEnumerable<ProgramScheduleItemViewModel>>([MakeOneItem(21)]));
        _mediator.Send(Arg.Any<GetProgramScheduleById>(), Arg.Any<CancellationToken>())
            .Returns(Option<ProgramScheduleViewModel>.Some(MakeSchedule(4, "Daily", version: 1)));
        _mediator.Send(Arg.Any<GetProgramScheduleItems>(), Arg.Any<CancellationToken>())
            .Returns([MakeOneItem(21)]);

        await _controller.ReplaceItems(
            4,
            new ReplaceScheduleItemsRequest([MakeItemRequest(PlayoutMode.One)]),
            CancellationToken.None);

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

    [Test]
    public async Task ReplaceItems_Should_Return_412_On_Precondition_Failed()
    {
        _controller.Request.Headers.IfMatch = "\"2\"";
        _mediator.Send(Arg.Any<ReplaceProgramScheduleItems>(), Arg.Any<CancellationToken>())
            .Returns(Left<BaseError, IEnumerable<ProgramScheduleItemViewModel>>(new PreconditionFailedError("stale")));

        IActionResult result = await _controller.ReplaceItems(
            4,
            new ReplaceScheduleItemsRequest([MakeItemRequest(PlayoutMode.One)]),
            CancellationToken.None);

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

    [Test]
    public async Task DeleteItem_Should_Return_204_And_Map_Route_Ids()
    {
        _mediator.Send(Arg.Any<DeleteProgramScheduleItem>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, Unit>(Unit.Default));

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

        result.ShouldBeOfType<NoContentResult>();
        await _mediator.Received(1).Send(
            Arg.Is<DeleteProgramScheduleItem>(c => c.ProgramScheduleId == 4 && c.ProgramScheduleItemId == 12),
            Arg.Any<CancellationToken>());
    }

    private static CreateScheduleRequest MakeScheduleRequest(string name) =>
        new(
            name,
            KeepMultiPartEpisodesTogether: true,
            TreatCollectionsAsShows: true,
            ShuffleScheduleItems: true,
            RandomStartPoint: true,
            FixedStartTimeBehavior: FixedStartTimeBehavior.Flexible,
            PadToNearestMinute: null);

    private static UpdateScheduleRequest MakeUpdateScheduleRequest(string name) =>
        new(
            name,
            KeepMultiPartEpisodesTogether: true,
            TreatCollectionsAsShows: true,
            ShuffleScheduleItems: true,
            RandomStartPoint: true,
            FixedStartTimeBehavior: FixedStartTimeBehavior.Flexible,
            PadToNearestMinute: null);

    private static ScheduleItemRequest MakeItemRequest(PlayoutMode playoutMode) =>
        new(
            Id: null,
            StartType.Dynamic,
            StartTime: null,
            FixedStartTimeBehavior: null,
            playoutMode,
            CollectionType.SearchQuery,
            CollectionId: null,
            MultiCollectionId: null,
            SmartCollectionId: null,
            RerunCollectionId: null,
            MediaItemId: null,
            PlaylistId: null,
            SearchTitle: "News",
            SearchQuery: "news",
            PlaybackOrder: PlaybackOrder.Shuffle,
            MarathonGroupBy: MarathonGroupBy.None,
            MarathonShuffleGroups: false,
            MarathonShuffleItems: false,
            MarathonBatchSize: null,
            FillWithGroupMode: FillWithGroupMode.None,
            MultipleMode: MultipleMode.Count,
            MultipleCount: "2",
            PlayoutDuration: TimeSpan.FromMinutes(30),
            TailMode: TailMode.None,
            DiscardToFillAttempts: 3,
            CustomTitle: null,
            GuideMode: GuideMode.Normal,
            PreRollFillerId: null,
            MidRollFillerId: null,
            PostRollFillerId: null,
            TailFillerId: null,
            FallbackFillerId: null,
            WatermarkIds: [],
            GraphicsElementIds: [],
            PreferredAudioLanguageCode: null,
            PreferredAudioTitle: null,
            PreferredSubtitleLanguageCode: null,
            SubtitleMode: null);

    private static ProgramScheduleViewModel MakeSchedule(int id, string name, int version = 0) =>
        new(id, name, true, true, false, false, FixedStartTimeBehavior.Flexible, null, version);

    private static ProgramScheduleItemOneViewModel MakeOneItem(int id) =>
        new(
            id,
            0,
            StartType.Dynamic,
            null,
            null,
            CollectionType.SearchQuery,
            null,
            null,
            null,
            null,
            null,
            null,
            "News",
            "news",
            PlaybackOrder.Shuffle,
            MarathonGroupBy.None,
            false,
            false,
            null,
            FillWithGroupMode.None,
            null,
            GuideMode.Normal,
            null,
            null,
            null,
            null,
            null,
            [],
            [],
            null,
            null,
            null,
            null);

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

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