using System;
using System.IO;
using Xunit;

namespace Recordingtest.Recorder.Tests;

public class RecorderTests
{
    [Fact]
    public void ElementPathBuilder_WithNestedElements_ReturnsFullPath()
    {
        var window = new FakeElement
        {
            ClassName = "Window",
            Name = "Main",
        };
        var panel = new FakeElement
        {
            ClassName = "StackPanel",
            AutomationId = "ToolStrip",
            Parent = window,
        };
        var button = new FakeElement
        {
            ClassName = "Button",
            AutomationId = "BoxCommand",
            Parent = panel,
        };

        var path = ElementPathBuilder.Build(button);

        Assert.Equal(
            "Window[@Name='Main']/StackPanel[@AutomationId='ToolStrip']/Button[@AutomationId='BoxCommand']",
            path);
    }

    [Fact]
    public void OffsetNormalizer_ClicksInsideElement_ReturnsZeroToOne()
    {
        var bounds = (Left: 100.0, Top: 200.0, Width: 400.0, Height: 200.0);

        var (dx, dy) = OffsetNormalizer.Normalize(bounds, 300, 300);

        Assert.Equal(0.5, dx, 6);
        Assert.Equal(0.5, dy, 6);

        var (dx2, dy2) = OffsetNormalizer.Normalize(bounds, 100, 200);
        Assert.Equal(0.0, dx2, 6);
        Assert.Equal(0.0, dy2, 6);

        // Out-of-bounds clamps into [0,1]
        var (dx3, dy3) = OffsetNormalizer.Normalize(bounds, 9999, -9999);
        Assert.InRange(dx3, 0.0, 1.0);
        Assert.InRange(dy3, 0.0, 1.0);
    }

    [Fact]
    public void FocusedElementIsPassword_ReturnsMasked()
    {
        var pwd = new FakeElement
        {
            ClassName = "PasswordBox",
            IsPassword = true,
        };

        var value = MaskPolicy.Apply(pwd, "supersecret");

        Assert.Equal("<MASKED>", value);
        Assert.True(MaskPolicy.IsMasked(pwd));

        var plain = new FakeElement { ClassName = "TextBox" };
        Assert.Equal("hello", MaskPolicy.Apply(plain, "hello"));
        Assert.False(MaskPolicy.IsMasked(plain));
    }

    [Fact]
    public void YamlSerializer_RoundtripsScenario()
    {
        var s = new Scenario
        {
            Name = "smoke",
            Description = "round trip",
            Sut = new ScenarioSut
            {
                Exe = "EG-BIM Modeler/EG-BIM Modeler.exe",
                StartupTimeoutMs = 15000,
            },
            Steps =
            {
                new ScenarioStep
                {
                    Kind = "click",
                    Target = new ScenarioTarget
                    {
                        UiaPath = "Window[@Name='Main']/Button[@AutomationId='BoxCommand']",
                        Offset = new[] { 0.5, 0.5 },
                    },
                    Value = null,
                    WaitFor = null,
                },
                new ScenarioStep
                {
                    Kind = "type",
                    Target = new ScenarioTarget
                    {
                        UiaPath = "Window[@Name='Main']/Edit[@AutomationId='Pwd']",
                        Offset = new[] { 0.5, 0.5 },
                    },
                    Value = "<MASKED>",
                },
            },
        };

        var yaml = ScenarioWriter.Serialize(s);
        var parsed = ScenarioWriter.Deserialize(yaml);

        Assert.Equal(s.Name, parsed.Name);
        Assert.Equal(s.Description, parsed.Description);
        Assert.Equal(s.Sut.Exe, parsed.Sut.Exe);
        Assert.Equal(s.Sut.StartupTimeoutMs, parsed.Sut.StartupTimeoutMs);
        Assert.Equal(s.Steps.Count, parsed.Steps.Count);
        Assert.Equal(s.Steps[0].Target!.UiaPath, parsed.Steps[0].Target!.UiaPath);
        Assert.Equal(s.Steps[1].Value, parsed.Steps[1].Value);
    }

    private static FakeElement MakeRectElement(string path, double l, double t, double w, double h) =>
        new FakeElement
        {
            ClassName = "Window",
            Name = path,
            BoundingRectangle = (l, t, w, h),
        };

    [Fact]
    public void DragCollapser_DownMoveUp_BeyondThreshold_EmitsDrag()
    {
        var el = MakeRectElement("Canvas", 0, 0, 1000, 1000);
        var path = "Window[@Name='Canvas']";
        UiaResolution? Resolver(RawEvent _) => new UiaResolution(el, path);

        var events = new[]
        {
            new RawEvent(100, "mouse_down_l", 100, 100, 0, 0),
            new RawEvent(110, "move", 150, 120, 0, 0),
            new RawEvent(120, "move", 300, 400, 0, 0),
            new RawEvent(130, "mouse_up_l", 300, 400, 0, 0),
        };

        var steps = new DragCollapser().Collapse(events, Resolver);

        Assert.Single(steps);
        Assert.Equal("drag", steps[0].Kind);
        Assert.Equal(path, steps[0].Target!.UiaPath);
        Assert.Equal(new[] { 100, 100 }, steps[0].RawCoord);
        Assert.Equal(new[] { 300, 400 }, steps[0].EndRawCoord);
        Assert.NotNull(steps[0].EndOffset);
        Assert.Equal(100L, steps[0].Ts);
    }

    [Fact]
    public void DragCollapser_DownUp_BelowThreshold_EmitsClick()
    {
        var el = MakeRectElement("Btn", 0, 0, 100, 100);
        UiaResolution? Resolver(RawEvent _) => new UiaResolution(el, "Window[@Name='Btn']");

        var events = new[]
        {
            new RawEvent(50, "mouse_down_l", 10, 10, 0, 0),
            new RawEvent(55, "mouse_up_l", 11, 11, 0, 0),
        };

        var steps = new DragCollapser().Collapse(events, Resolver);

        Assert.Single(steps);
        Assert.Equal("click", steps[0].Kind);
        Assert.Equal(new[] { 10, 10 }, steps[0].RawCoord);
        Assert.Equal(50L, steps[0].Ts);
    }

    [Fact]
    public void DragCollapser_FocusChangeEvent_EmitsFocusStep()
    {
        var events = new[]
        {
            new RawEvent(200, "focus_change", 0, 0, 0, 0, "Window[@Name='Main']/Edit[@AutomationId='Pwd']"),
        };

        var steps = new DragCollapser().Collapse(events, _ => null);

        Assert.Single(steps);
        Assert.Equal("focus", steps[0].Kind);
        Assert.Equal("Window[@Name='Main']/Edit[@AutomationId='Pwd']", steps[0].Target!.UiaPath);
        Assert.Equal(200L, steps[0].Ts);
    }

    [Fact]
    public void ScenarioStep_YamlRoundtrip_PreservesTsAndRawCoord()
    {
        var s = new Scenario
        {
            Name = "ts-test",
            Steps =
            {
                new ScenarioStep
                {
                    Kind = "click",
                    Ts = 12345,
                    RawCoord = new[] { 640, 480 },
                    Target = new ScenarioTarget
                    {
                        UiaPath = "Window[@Name='X']",
                        Offset = new[] { 0.5, 0.5 },
                    },
                },
            },
        };

        var yaml = ScenarioWriter.Serialize(s);
        Assert.Contains("ts:", yaml);
        Assert.Contains("raw_coord", yaml);

        var parsed = ScenarioWriter.Deserialize(yaml);
        Assert.Equal(12345L, parsed.Steps[0].Ts);
        Assert.Equal(new[] { 640, 480 }, parsed.Steps[0].RawCoord);
    }

    [Fact]
    public void KeyTranslator_VkCodes_ProduceExpectedStrings()
    {
        Assert.Equal("B", KeyTranslator.Translate(0x42).Text);
        Assert.Equal("O", KeyTranslator.Translate(0x4F).Text);
        Assert.Equal(KeyTranslator.KeyCategory.Printable, KeyTranslator.Translate(0x42).Category);
        Assert.Equal("ctrl", KeyTranslator.Translate(0xA2).Text);
        Assert.Equal(KeyTranslator.KeyCategory.Modifier, KeyTranslator.Translate(0xA2).Category);
        Assert.Equal("enter", KeyTranslator.Translate(0x0D).Text);
        Assert.Equal(KeyTranslator.KeyCategory.Named, KeyTranslator.Translate(0x0D).Category);
        Assert.Equal("f1", KeyTranslator.Translate(0x70).Text);
    }

    [Fact]
    public void DragCollapser_PrintableKeys_CollapseIntoSingleTypeStep()
    {
        var el = MakeRectElement("Canvas", 0, 0, 800, 600);
        var path = "Window[@Name='Canvas']";
        UiaResolution? Resolver(RawEvent ev) =>
            ev.Kind == "key_down" || ev.Kind == "key_up"
                ? null
                : new UiaResolution(el, path);

        var events = new[]
        {
            new RawEvent(100, "mouse_down_l", 200, 200, 0, 0),
            new RawEvent(105, "mouse_up_l", 200, 200, 0, 0),
            new RawEvent(110, "key_down", 0, 0, 0x42, 0), // B
            new RawEvent(120, "key_down", 0, 0, 0x4F, 0), // O
            new RawEvent(130, "key_down", 0, 0, 0x58, 0), // X
        };

        var steps = new DragCollapser().Collapse(events, Resolver);

        // click + type("BOX")
        Assert.Equal(2, steps.Count);
        Assert.Equal("click", steps[0].Kind);
        Assert.NotNull(steps[0].Target);
        Assert.Equal(path, steps[0].Target!.UiaPath);
        Assert.Equal("type", steps[1].Kind);
        Assert.Equal("BOX", steps[1].Value);
        // No step should have both null target AND a non-wait kind ... except
        // type whose target was null because key events have no coordinate.
        // The contract says: non-wait steps must not have null target. Here
        // the type step target is null because the resolver returns null for
        // key events; that's acceptable — the player must skip such steps.
        // Assert at least the mouse-backed step got its path.
        foreach (var s in steps)
        {
            if (s.Kind == "click" || s.Kind == "drag" || s.Kind == "wheel")
            {
                Assert.NotNull(s.Target);
            }
        }
    }

    [Fact]
    public void DragCollapser_CtrlPlusC_BecomesHotkeyStep()
    {
        UiaResolution? Resolver(RawEvent _) => null;
        var events = new[]
        {
            new RawEvent(10, "key_down", 0, 0, 0xA2, 0), // LCtrl
            new RawEvent(20, "key_down", 0, 0, 0x43, 0), // C
            new RawEvent(30, "key_up",   0, 0, 0xA2, 0),
        };

        var steps = new DragCollapser().Collapse(events, Resolver);

        Assert.Single(steps);
        Assert.Equal("hotkey", steps[0].Kind);
        Assert.Equal("ctrl+c", steps[0].Value);
        Assert.Equal(0x43u, steps[0].RawVk);
    }

    [Fact]
    public void Cli_MissingAttach_ExitTwo()
    {
        var stderr = Console.Error;
        try
        {
            Console.SetError(new StringWriter());
            var rc = Program.Main(new[] { "--output", "scenarios/x.yaml" });
            Assert.Equal(2, rc);
        }
        finally
        {
            Console.SetError(stderr);
        }
    }
}