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

namespace ErsatzTV.Tests.Controllers;

[TestFixture]
public class PlaylistControllerTests
{
    [SetUp]
    public void SetUp()
    {
        _mediator = Substitute.For<IMediator>();
        _controller = new PlaylistController(_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() }
        };
    }

    private PlaylistController _controller = null!;
    private IMediator _mediator = null!;

    [Test]
    public void Controller_Should_Expose_Idiomatic_Rest_Routes()
    {
        ShouldHaveActionRoute(nameof(PlaylistController.GetGroups), "GET", "/api/v1/playlists/groups");
        ShouldHaveActionRoute(nameof(PlaylistController.CreateGroup), "POST", "/api/v1/playlists/groups");
        ShouldHaveActionRoute(nameof(PlaylistController.UpdateGroup), "PUT", "/api/v1/playlists/groups/{id:int}");
        ShouldHaveActionRoute(nameof(PlaylistController.DeleteGroup), "DELETE", "/api/v1/playlists/groups/{id:int}");
        ShouldHaveActionRoute(nameof(PlaylistController.GetAll), "GET", "/api/v1/playlists");
        ShouldHaveActionRoute(nameof(PlaylistController.GetById), "GET", "/api/v1/playlists/{id:int}");
        ShouldHaveActionRoute(nameof(PlaylistController.GetItems), "GET", "/api/v1/playlists/{id:int}/items");
        ShouldHaveActionRoute(nameof(PlaylistController.Create), "POST", "/api/v1/playlists");
        ShouldHaveActionRoute(nameof(PlaylistController.Update), "PUT", "/api/v1/playlists/{id:int}");
        ShouldHaveActionRoute(nameof(PlaylistController.Delete), "DELETE", "/api/v1/playlists/{id:int}");
        ShouldHaveActionRoute(nameof(PlaylistController.AddItems), "POST", "/api/v1/playlists/{id:int}/items");
        ShouldHaveActionRoute(nameof(PlaylistController.Preview), "POST", "/api/v1/playlists/preview");
    }

    [Test]
    public async Task GetGroups_Should_Map_Response()
    {
        _mediator.Send(Arg.Any<GetAllPlaylistGroups>(), Arg.Any<CancellationToken>())
            .Returns(new List<PlaylistGroupViewModel> { new(3, "Kids", 2, false) });

        List<PlaylistGroupResponseModel> result = await _controller.GetGroups(CancellationToken.None);

        result.Count.ShouldBe(1);
        result[0].Id.ShouldBe(3);
        result[0].PlaylistCount.ShouldBe(2);
    }

    [Test]
    public async Task CreateGroup_Should_Return_201_And_Map_Request()
    {
        _mediator.Send(Arg.Any<CreatePlaylistGroup>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, PlaylistGroupViewModel>(new PlaylistGroupViewModel(8, "Kids", 0, false)));

        IActionResult result = await _controller.CreateGroup(
            new CreatePlaylistGroupRequest("Kids"),
            CancellationToken.None);

        var created = result.ShouldBeOfType<CreatedResult>();
        created.Location.ShouldBe("/api/v1/playlists/groups/8");
        created.Value.ShouldBeOfType<PlaylistGroupResponseModel>().Name.ShouldBe("Kids");
        await _mediator.Received(1).Send(
            Arg.Is<CreatePlaylistGroup>(c => c.Name == "Kids"),
            Arg.Any<CancellationToken>());
    }

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

        IActionResult result = await _controller.CreateGroup(
            new CreatePlaylistGroupRequest("Kids"),
            CancellationToken.None);

        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
    }

    [Test]
    public async Task UpdateGroup_Should_Return_200_And_Map_Request()
    {
        _mediator.Send(Arg.Any<GetAllPlaylistGroups>(), Arg.Any<CancellationToken>())
            .Returns(new List<PlaylistGroupViewModel> { new(4, "Kids", 1, false) });
        _mediator.Send(Arg.Any<RenamePlaylistGroup>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, PlaylistGroupViewModel>(new PlaylistGroupViewModel(4, "New Name", 1, false)));

        IActionResult result = await _controller.UpdateGroup(
            4,
            new UpdatePlaylistGroupRequest("New Name"),
            CancellationToken.None);

        result.ShouldBeOfType<OkObjectResult>().Value.ShouldBeOfType<PlaylistGroupResponseModel>().Name
            .ShouldBe("New Name");
        await _mediator.Received(1).Send(
            Arg.Is<RenamePlaylistGroup>(c => c.PlaylistGroupId == 4 && c.Name == "New Name"),
            Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task UpdateGroup_Should_Return_404_When_Missing()
    {
        _mediator.Send(Arg.Any<GetAllPlaylistGroups>(), Arg.Any<CancellationToken>())
            .Returns(new List<PlaylistGroupViewModel>());

        IActionResult result = await _controller.UpdateGroup(
            4,
            new UpdatePlaylistGroupRequest("New Name"),
            CancellationToken.None);

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

    [Test]
    public async Task UpdateGroup_Should_Return_422_On_System_Group_And_Not_Rename()
    {
        _mediator.Send(Arg.Any<GetAllPlaylistGroups>(), Arg.Any<CancellationToken>())
            .Returns(new List<PlaylistGroupViewModel> { new(4, "System", 0, true) });

        IActionResult result = await _controller.UpdateGroup(
            4,
            new UpdatePlaylistGroupRequest("New Name"),
            CancellationToken.None);

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

    [Test]
    public async Task UpdateGroup_Should_Return_422_On_Validation_Error()
    {
        _mediator.Send(Arg.Any<GetAllPlaylistGroups>(), Arg.Any<CancellationToken>())
            .Returns(new List<PlaylistGroupViewModel> { new(4, "Kids", 1, false) });
        _mediator.Send(Arg.Any<RenamePlaylistGroup>(), Arg.Any<CancellationToken>())
            .Returns(Left<BaseError, PlaylistGroupViewModel>(BaseError.New("too long")));

        IActionResult result = await _controller.UpdateGroup(
            4,
            new UpdatePlaylistGroupRequest("New Name"),
            CancellationToken.None);

        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
    }

    [Test]
    public async Task DeleteGroup_Should_Return_204_On_Success()
    {
        _mediator.Send(Arg.Any<GetAllPlaylistGroups>(), Arg.Any<CancellationToken>())
            .Returns(new List<PlaylistGroupViewModel> { new(4, "Kids", 0, false) });
        _mediator.Send(Arg.Any<DeletePlaylistGroup>(), Arg.Any<CancellationToken>())
            .Returns(Option<BaseError>.None);

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

        result.ShouldBeOfType<NoContentResult>();
        await _mediator.Received(1).Send(
            Arg.Is<DeletePlaylistGroup>(c => c.PlaylistGroupId == 4),
            Arg.Any<CancellationToken>());
    }

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

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

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

    [Test]
    public async Task DeleteGroup_Should_Return_422_On_System_Group()
    {
        _mediator.Send(Arg.Any<GetAllPlaylistGroups>(), Arg.Any<CancellationToken>())
            .Returns(new List<PlaylistGroupViewModel> { new(4, "System", 0, true) });
        _mediator.Send(Arg.Any<DeletePlaylistGroup>(), Arg.Any<CancellationToken>())
            .Returns(Option<BaseError>.Some(BaseError.New("Cannot delete system playlist group")));

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

        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
    }

    [Test]
    public async Task GetById_Should_Return_200_For_Some()
    {
        _mediator.Send(Arg.Any<GetPlaylistById>(), Arg.Any<CancellationToken>())
            .Returns(Option<PlaylistViewModel>.Some(new PlaylistViewModel(4, 1, "Kids", false, 1)));

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

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

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

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

        result.ShouldBeOfType<NotFoundObjectResult>();
    }

    [Test]
    public async Task GetItems_Should_Return_200_And_Flatten_Names()
    {
        _mediator.Send(Arg.Any<GetPlaylistById>(), Arg.Any<CancellationToken>())
            .Returns(Option<PlaylistViewModel>.Some(new PlaylistViewModel(4, 1, "Kids", false, 1)));
        _mediator.Send(Arg.Any<GetPlaylistItems>(), Arg.Any<CancellationToken>())
            .Returns(new List<PlaylistItemViewModel>
            {
                new(
                    100,
                    0,
                    CollectionType.Collection,
                    new MediaCollectionViewModel(CollectionType.Collection, 10, "Movies", false, MediaItemState.Normal),
                    null,
                    null,
                    null,
                    PlaybackOrder.Chronological,
                    null,
                    true,
                    false),
                new(
                    101,
                    1,
                    CollectionType.Movie,
                    null,
                    null,
                    null,
                    new NamedMediaItemViewModel(55, "The Movie"),
                    PlaybackOrder.Shuffle,
                    3,
                    false,
                    true)
            });

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

        var items = result.ShouldBeOfType<OkObjectResult>().Value.ShouldBeOfType<List<PlaylistItemResponseModel>>();
        items.Count.ShouldBe(2);
        items[0].CollectionId.ShouldBe(10);
        items[0].CollectionName.ShouldBe("Movies");
        items[0].MediaItemId.ShouldBeNull();
        items[1].MediaItemId.ShouldBe(55);
        items[1].MediaItemName.ShouldBe("The Movie");
        items[1].CollectionName.ShouldBeNull();
    }

    [Test]
    public async Task GetItems_Should_Return_404_When_Playlist_Missing()
    {
        _mediator.Send(Arg.Any<GetPlaylistById>(), Arg.Any<CancellationToken>())
            .Returns(Option<PlaylistViewModel>.None);

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

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

    [Test]
    public async Task GetItems_Should_Set_ETag_From_Playlist_Version()
    {
        _mediator.Send(Arg.Any<GetPlaylistById>(), Arg.Any<CancellationToken>())
            .Returns(Option<PlaylistViewModel>.Some(new PlaylistViewModel(4, 1, "Kids", false, 9)));
        _mediator.Send(Arg.Any<GetPlaylistItems>(), Arg.Any<CancellationToken>())
            .Returns(new List<PlaylistItemViewModel>());

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

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

    [Test]
    public async Task Create_Should_Return_201_And_Map_Request()
    {
        _mediator.Send(Arg.Any<CreatePlaylist>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, PlaylistViewModel>(new PlaylistViewModel(9, 1, "Kids", false, 1)));

        IActionResult result = await _controller.Create(
            new CreatePlaylistRequest(1, "Kids"),
            CancellationToken.None);

        var created = result.ShouldBeOfType<CreatedResult>();
        created.Location.ShouldBe("/api/v1/playlists/9");
        await _mediator.Received(1).Send(
            Arg.Is<CreatePlaylist>(c => c.PlaylistGroupId == 1 && c.Name == "Kids"),
            Arg.Any<CancellationToken>());
    }

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

        IActionResult result = await _controller.Create(
            new CreatePlaylistRequest(1, "Kids"),
            CancellationToken.None);

        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
    }

    [Test]
    public async Task Update_Should_Return_200_With_Items_And_Map_Request_By_Array_Order()
    {
        // Existence pre-check reads version 1; the post-save re-query reads the bumped version 2 —
        // the response ETag must carry the refreshed value (issue #253).
        _mediator.Send(Arg.Any<GetPlaylistById>(), Arg.Any<CancellationToken>())
            .Returns(
                Option<PlaylistViewModel>.Some(new PlaylistViewModel(4, 1, "Kids", false, 1)),
                Option<PlaylistViewModel>.Some(new PlaylistViewModel(4, 1, "Kids", false, 2)));
        _mediator.Send(Arg.Any<ReplacePlaylistItems>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, List<PlaylistItemViewModel>>(new List<PlaylistItemViewModel>
            {
                new(
                    100,
                    0,
                    CollectionType.Movie,
                    null,
                    null,
                    null,
                    new NamedMediaItemViewModel(55, "The Movie"),
                    PlaybackOrder.Shuffle,
                    null,
                    false,
                    true)
            }));
        _mediator.Send(Arg.Any<GetPlaylistItems>(), Arg.Any<CancellationToken>())
            .Returns(new List<PlaylistItemViewModel>
            {
                new(
                    100,
                    0,
                    CollectionType.Movie,
                    null,
                    null,
                    null,
                    new NamedMediaItemViewModel(55, "The Movie"),
                    PlaybackOrder.Shuffle,
                    null,
                    false,
                    true)
            });

        IActionResult result = await _controller.Update(
            4,
            new ReplacePlaylistRequest(
                "Kids",
                new List<PlaylistItemRequest>
                {
                    new(99, CollectionType.Movie, null, null, null, 55, PlaybackOrder.Shuffle, null, false, true),
                    new(99, CollectionType.Collection, 10, null, null, null, PlaybackOrder.Chronological, null, true,
                        false)
                }),
            CancellationToken.None);

        result.ShouldBeOfType<OkObjectResult>().Value.ShouldBeOfType<List<PlaylistItemResponseModel>>().Count
            .ShouldBe(1);
        // On success the response carries the refreshed playlist's ETag.
        _controller.Response.Headers.ETag.ToString().ShouldBe("\"2\"");
        await _mediator.Received(1).Send(
            Arg.Is<ReplacePlaylistItems>(c =>
                c.PlaylistId == 4 &&
                c.Name == "Kids" &&
                c.Items.Count == 2 &&
                c.Items[0].Index == 0 &&
                c.Items[0].MediaItemId == 55 &&
                c.Items[1].Index == 1 &&
                c.Items[1].CollectionId == 10),
            Arg.Any<CancellationToken>());
    }

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

        IActionResult result = await _controller.Update(
            4,
            new ReplacePlaylistRequest("Kids", new List<PlaylistItemRequest>()),
            CancellationToken.None);

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

    [Test]
    public async Task Update_Should_Thread_If_Match_Version_Into_Command()
    {
        _controller.Request.Headers.IfMatch = "\"3\"";
        _mediator.Send(Arg.Any<GetPlaylistById>(), Arg.Any<CancellationToken>())
            .Returns(Option<PlaylistViewModel>.Some(new PlaylistViewModel(4, 1, "Kids", false, 3)));
        _mediator.Send(Arg.Any<ReplacePlaylistItems>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, List<PlaylistItemViewModel>>(new List<PlaylistItemViewModel>()));
        _mediator.Send(Arg.Any<GetPlaylistItems>(), Arg.Any<CancellationToken>())
            .Returns(new List<PlaylistItemViewModel>());

        IActionResult result = await _controller.Update(
            4,
            new ReplacePlaylistRequest("Kids", new List<PlaylistItemRequest>()),
            CancellationToken.None);

        result.ShouldBeOfType<OkObjectResult>();
        await _mediator.Received(1).Send(
            Arg.Is<ReplacePlaylistItems>(c => c.ExpectedVersions == Option<Seq<int>>.Some(new[] { 3 }.ToSeq())),
            Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task Update_Without_If_Match_Should_Force_Write()
    {
        _mediator.Send(Arg.Any<GetPlaylistById>(), Arg.Any<CancellationToken>())
            .Returns(Option<PlaylistViewModel>.Some(new PlaylistViewModel(4, 1, "Kids", false, 1)));
        _mediator.Send(Arg.Any<ReplacePlaylistItems>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, List<PlaylistItemViewModel>>(new List<PlaylistItemViewModel>()));
        _mediator.Send(Arg.Any<GetPlaylistItems>(), Arg.Any<CancellationToken>())
            .Returns(new List<PlaylistItemViewModel>());

        await _controller.Update(
            4,
            new ReplacePlaylistRequest("Kids", new List<PlaylistItemRequest>()),
            CancellationToken.None);

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

    [Test]
    public async Task Update_Should_Return_412_On_Precondition_Failed()
    {
        _controller.Request.Headers.IfMatch = "\"2\"";
        _mediator.Send(Arg.Any<GetPlaylistById>(), Arg.Any<CancellationToken>())
            .Returns(Option<PlaylistViewModel>.Some(new PlaylistViewModel(4, 1, "Kids", false, 5)));
        _mediator.Send(Arg.Any<ReplacePlaylistItems>(), Arg.Any<CancellationToken>())
            .Returns(Left<BaseError, List<PlaylistItemViewModel>>(new PreconditionFailedError("stale")));

        IActionResult result = await _controller.Update(
            4,
            new ReplacePlaylistRequest("Kids", new List<PlaylistItemRequest>()),
            CancellationToken.None);

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

    [Test]
    public async Task Update_Should_Return_404_When_Playlist_Missing()
    {
        _mediator.Send(Arg.Any<GetPlaylistById>(), Arg.Any<CancellationToken>())
            .Returns(Option<PlaylistViewModel>.None);

        IActionResult result = await _controller.Update(
            4,
            new ReplacePlaylistRequest("Kids", new List<PlaylistItemRequest>()),
            CancellationToken.None);

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

    [Test]
    public async Task Update_Should_Return_422_On_Validation_Error()
    {
        _mediator.Send(Arg.Any<GetPlaylistById>(), Arg.Any<CancellationToken>())
            .Returns(Option<PlaylistViewModel>.Some(new PlaylistViewModel(4, 1, "Kids", false, 1)));
        _mediator.Send(Arg.Any<ReplacePlaylistItems>(), Arg.Any<CancellationToken>())
            .Returns(Left<BaseError, List<PlaylistItemViewModel>>(BaseError.New("bad item")));

        IActionResult result = await _controller.Update(
            4,
            new ReplacePlaylistRequest("Kids", new List<PlaylistItemRequest>()),
            CancellationToken.None);

        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
    }

    [Test]
    public async Task Update_Should_Return_422_On_System_Playlist_And_Not_Replace_Items()
    {
        _mediator.Send(Arg.Any<GetPlaylistById>(), Arg.Any<CancellationToken>())
            .Returns(Option<PlaylistViewModel>.Some(new PlaylistViewModel(4, 1, "System", true, 1)));

        IActionResult result = await _controller.Update(
            4,
            new ReplacePlaylistRequest(
                "Renamed",
                new List<PlaylistItemRequest>()),
            CancellationToken.None);

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

    [Test]
    public async Task Delete_Should_Return_204_On_Success()
    {
        _mediator.Send(Arg.Any<GetPlaylistById>(), Arg.Any<CancellationToken>())
            .Returns(Option<PlaylistViewModel>.Some(new PlaylistViewModel(4, 1, "Kids", false, 1)));
        _mediator.Send(Arg.Any<DeletePlaylist>(), Arg.Any<CancellationToken>())
            .Returns(Option<BaseError>.None);

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

        result.ShouldBeOfType<NoContentResult>();
        await _mediator.Received(1).Send(
            Arg.Is<DeletePlaylist>(c => c.PlaylistId == 4),
            Arg.Any<CancellationToken>());
    }

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

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

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

    [Test]
    public async Task Delete_Should_Return_422_On_System_Playlist()
    {
        _mediator.Send(Arg.Any<GetPlaylistById>(), Arg.Any<CancellationToken>())
            .Returns(Option<PlaylistViewModel>.Some(new PlaylistViewModel(4, 1, "System", true, 1)));
        _mediator.Send(Arg.Any<DeletePlaylist>(), Arg.Any<CancellationToken>())
            .Returns(Option<BaseError>.Some(BaseError.New("Cannot delete system (generated) playlist")));

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

        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
    }

    [Test]
    public async Task AddItems_Should_Return_204_And_Map_Request()
    {
        _mediator.Send(Arg.Any<GetPlaylistById>(), Arg.Any<CancellationToken>())
            .Returns(Option<PlaylistViewModel>.Some(new PlaylistViewModel(4, 1, "Kids", false, 1)));
        _mediator.Send(Arg.Any<AddItemsToPlaylist>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, Unit>(Unit.Default));

        IActionResult result = await _controller.AddItems(
            4,
            new AddItemsToPlaylistRequest([1, 2], [3], [], [], [], [], [], [], [], []),
            CancellationToken.None);

        result.ShouldBeOfType<NoContentResult>();
        await _mediator.Received(1).Send(
            Arg.Is<AddItemsToPlaylist>(c =>
                c.PlaylistId == 4 &&
                c.MovieIds.SequenceEqual(new List<int> { 1, 2 }) &&
                c.ShowIds.SequenceEqual(new List<int> { 3 })),
            Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task AddItems_Should_Return_404_When_Playlist_Missing()
    {
        _mediator.Send(Arg.Any<GetPlaylistById>(), Arg.Any<CancellationToken>())
            .Returns(Option<PlaylistViewModel>.None);

        IActionResult result = await _controller.AddItems(
            4,
            new AddItemsToPlaylistRequest([1], [], [], [], [], [], [], [], [], []),
            CancellationToken.None);

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

    [Test]
    public async Task AddItems_Should_Return_422_On_System_Playlist()
    {
        _mediator.Send(Arg.Any<GetPlaylistById>(), Arg.Any<CancellationToken>())
            .Returns(Option<PlaylistViewModel>.Some(new PlaylistViewModel(4, 1, "System", true, 1)));
        _mediator.Send(Arg.Any<AddItemsToPlaylist>(), Arg.Any<CancellationToken>())
            .Returns(Left<BaseError, Unit>(BaseError.New("Cannot add items to system (generated) playlist")));

        IActionResult result = await _controller.AddItems(
            4,
            new AddItemsToPlaylistRequest([1], [], [], [], [], [], [], [], [], []),
            CancellationToken.None);

        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
    }

    [Test]
    public async Task AddItems_Should_Return_422_On_Validation_Error()
    {
        _mediator.Send(Arg.Any<GetPlaylistById>(), Arg.Any<CancellationToken>())
            .Returns(Option<PlaylistViewModel>.Some(new PlaylistViewModel(4, 1, "Kids", false, 1)));
        _mediator.Send(Arg.Any<AddItemsToPlaylist>(), Arg.Any<CancellationToken>())
            .Returns(Left<BaseError, Unit>(BaseError.New("Movie does not exist")));

        IActionResult result = await _controller.AddItems(
            4,
            new AddItemsToPlaylistRequest([999], [], [], [], [], [], [], [], [], []),
            CancellationToken.None);

        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
    }

    [Test]
    public async Task Preview_Should_Return_200_And_Format_Times()
    {
        _mediator.Send(Arg.Any<PreviewPlaylistPlayout>(), Arg.Any<CancellationToken>())
            .Returns(Right<BaseError, List<PlayoutItemPreviewViewModel>>(new List<PlayoutItemPreviewViewModel>
            {
                new("The Movie", new TimeSpan(1, 2, 3), new TimeSpan(2, 4, 6), "1:02:03")
            }));

        IActionResult result = await _controller.Preview(
            new ReplacePlaylistRequest(
                "Draft",
                new List<PlaylistItemRequest>
                {
                    new(0, CollectionType.Movie, null, null, null, 55, PlaybackOrder.Shuffle, null, false, true)
                }),
            CancellationToken.None);

        var items = result.ShouldBeOfType<OkObjectResult>().Value
            .ShouldBeOfType<List<PlaylistPreviewItemResponseModel>>();
        items.Count.ShouldBe(1);
        items[0].Title.ShouldBe("The Movie");
        items[0].Start.ShouldBe("01:02:03");
        items[0].Finish.ShouldBe("02:04:06");
        items[0].Duration.ShouldBe("1:02:03");
        await _mediator.Received(1).Send(
            Arg.Is<PreviewPlaylistPlayout>(c => c.Data.PlaylistId == 0 && c.Data.Items.Count == 1),
            Arg.Any<CancellationToken>());
    }

    [Test]
    public async Task Preview_Should_Return_422_On_Error()
    {
        _mediator.Send(Arg.Any<PreviewPlaylistPlayout>(), Arg.Any<CancellationToken>())
            .Returns(Left<BaseError, List<PlayoutItemPreviewViewModel>>(BaseError.New("bad")));

        IActionResult result = await _controller.Preview(
            new ReplacePlaylistRequest("Draft", new List<PlaylistItemRequest>()),
            CancellationToken.None);

        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
    }

    [Test]
    public async Task Preview_Should_Return_422_When_Item_Missing_Required_Id()
    {
        IActionResult result = await _controller.Preview(
            new ReplacePlaylistRequest(
                "Draft",
                new List<PlaylistItemRequest>
                {
                    // Collection-type item with a null collectionId is invalid.
                    new(0, CollectionType.Collection, null, null, null, null, PlaybackOrder.Chronological, null, true,
                        false)
                }),
            CancellationToken.None);

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

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

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