using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using AcDream.App.UI;
using AcDream.App.UI.Layout;
using AcDream.Core.Chat;
using AcDream.UI.Abstractions.Panels.Chat;

namespace AcDream.App.Tests.UI.Layout;

/// <summary>
/// Campaign CT slice A4: a tagged speaker name draws in the element's authored
/// TAG colour while the rest of its line keeps the message colour.
/// </summary>
public sealed class ChatTranscriptRunsTests
{
    private static readonly Vector4 LineColor = new(0.8f, 0.8f, 0.8f, 1f);

    /// <summary>Measured from the installed dats: chat 0x2100006F / 0x10000011.</summary>
    private static readonly Vector4 TagGreen = new(0f, 178f / 255f, 0f, 1f);

    /// <summary>10px per character, so wrap points are predictable.</summary>
    private static float Measure(string text) => text.Length * 10f;

    private static IReadOnlyList<ChatTextSpan> TellSpans(string name, string rest)
        => new[]
        {
            new ChatTextSpan(name, new ChatTextTag("Tell", "IIDString", $"1342177290:{name}")),
            new ChatTextSpan(rest, null),
        };

    [Fact]
    public void TheNameTakesTheTagColourAndTheRestTakesTheLineColour()
    {
        IReadOnlyList<UiText.TextRun>? runs = ChatTranscriptRenderer.RunsForFragment(
            TellSpans("Dww", " tells you"),
            fragmentStart: 0,
            fragmentLength: "Dww tells you".Length,
            LineColor,
            TagGreen);

        Assert.NotNull(runs);
        Assert.Equal(2, runs!.Count);
        Assert.Equal(("Dww", TagGreen), (runs[0].Text, runs[0].Color));
        Assert.Equal((" tells you", LineColor), (runs[1].Text, runs[1].Color));
    }

    [Fact]
    public void AFragmentWithNoTagInItGetsNoRunsAtAll()
    {
        // A single-colour fragment must take the ordinary flat draw path
        // rather than a one-run list that means the same thing.
        IReadOnlyList<ChatTextSpan> spans = TellSpans("Dww", " tells you, hello there");

        Assert.Null(ChatTranscriptRenderer.RunsForFragment(
            spans,
            fragmentStart: 10,          // well past the name
            fragmentLength: 5,
            LineColor,
            TagGreen));
    }

    [Fact]
    public void ATagStraddlingAWrapBreakIsSplitAcrossBothFragments()
    {
        // The name is long enough to be cut in half by the wrap; both halves
        // must still be green, or a name would change colour mid-word.
        IReadOnlyList<ChatTextSpan> spans = TellSpans("Bartholomew", " tells you");

        IReadOnlyList<UiText.TextRun>? first = ChatTranscriptRenderer.RunsForFragment(
            spans, fragmentStart: 0, fragmentLength: 5, LineColor, TagGreen);
        IReadOnlyList<UiText.TextRun>? second = ChatTranscriptRenderer.RunsForFragment(
            spans, fragmentStart: 5, fragmentLength: 6, LineColor, TagGreen);

        Assert.Equal("Barth", Assert.Single(first!).Text);
        Assert.Equal(TagGreen, first![0].Color);
        Assert.Equal("olomew", Assert.Single(second!).Text);
        Assert.Equal(TagGreen, second![0].Color);
    }

    [Fact]
    public void RunsAlwaysReproduceTheFragmentTheyCover()
    {
        // UiText.RunsMatchLine refuses to draw runs that disagree with the
        // line, so a mapping bug here would silently fall back to flat text
        // rather than fail loudly. Assert the contract directly.
        IReadOnlyList<ChatTextSpan> spans = TellSpans("Dww", " tells you, \"hi\"");
        string line = string.Concat(spans.Select(s => s.Text));

        for (int start = 0; start < line.Length; start++)
        {
            for (int len = 1; len <= line.Length - start; len++)
            {
                IReadOnlyList<UiText.TextRun>? runs =
                    ChatTranscriptRenderer.RunsForFragment(
                        spans, start, len, LineColor, TagGreen);
                if (runs is null)
                    continue;

                string fragment = line.Substring(start, len);
                Assert.True(
                    UiText.RunsMatchLine(runs, fragment),
                    $"runs disagree with fragment [{start}..{start + len})");
            }
        }
    }

    [Fact]
    public void BuildLines_EmitsOneRunEntryPerWrappedFragment()
    {
        // The run list is index-aligned with the lines the transcript draws;
        // if the two ever fall out of step, names colour on the wrong rows.
        var detailed = new List<FormattedLine>
        {
            new("Dww tells you, hello there friend", ChatKind.Tell, null, 0x03u,
                TellSpans("Dww", " tells you, hello there friend")),
            new("Welcome.", ChatKind.System, null, 0x05u),
        };
        var runs = new List<IReadOnlyList<UiText.TextRun>?>();

        List<UiText.Line> lines = ChatTranscriptRenderer.BuildLines(
            detailed,
            maxW: 150f,               // forces the first entry to wrap
            Measure,
            accept: null,
            defaultColor: LineColor,
            tagColor: TagGreen,
            runsPerLine: runs);

        Assert.True(lines.Count > 2, "the first line should have wrapped");
        Assert.Equal(lines.Count, runs.Count);

        // The very first fragment holds the name, so it is the one with runs.
        Assert.NotNull(runs[0]);
        Assert.Equal(TagGreen, runs[0]![0].Color);

        // The untagged system line never gets runs.
        Assert.Null(runs[^1]);
    }

    [Fact]
    public void BuildLines_WithoutATagColourFallsBackToTheLineColour()
    {
        // An element that authors no 0x1D must not render the name in a
        // colour nobody chose; it renders like the rest of the line.
        var detailed = new List<FormattedLine>
        {
            new("Dww tells you", ChatKind.Tell, null, 0x03u,
                TellSpans("Dww", " tells you")),
        };
        var runs = new List<IReadOnlyList<UiText.TextRun>?>();

        ChatTranscriptRenderer.BuildLines(
            detailed, maxW: 1000f, Measure, accept: null,
            defaultColor: LineColor, tagColor: null, runsPerLine: runs);

        IReadOnlyList<UiText.TextRun> line = Assert.Single(runs)!;
        Assert.All(line, run => Assert.Equal(line[0].Color, run.Color));
    }
}