using System.Text;
using Xunit.Abstractions;

// Alias Console to MockConsole so we don't accidentally use Console
using Console = Terminal.Gui.Drivers.FakeConsole;

namespace UnitTests.DriverTests;

public class ConsoleDriverTests
{
    private readonly ITestOutputHelper _output;

    public ConsoleDriverTests (ITestOutputHelper output)
    {
        ConsoleDriver.RunningUnitTests = true;
        _output = output;
    }

    [Theory]
    [InlineData (typeof (FakeDriver))]
    //[InlineData (typeof (DotNetDriver))]

    //[InlineData (typeof (ANSIDriver))]
    //[InlineData (typeof (WindowsDriver))]
    //[InlineData (typeof (UnixDriver))]
    public void End_Cleans_Up (Type driverType)
    {
        var driver = (IConsoleDriver)Activator.CreateInstance (driverType);
        driver.Init ();
        driver.End ();
    }

    // NOTE: These tests were removed because they use legacy FakeDriver patterns that don't work with modern architecture:
    // 1. They use Console.MockKeyPresses which is a legacy FakeDriver pattern
    // 2. Application.Run() with the legacy FakeDriver doesn't properly process MockKeyPresses in modern architecture
    // 3. These tests should be rewritten to use the modern FakeComponentFactory with predefined input
    // 4. Key press handling should be tested through the input processor layer, not driver tests
    //
    // [Theory]
    // [InlineData (typeof (FakeDriver))]
    // public void FakeDriver_MockKeyPresses (Type driverType)

    [Theory]
    [InlineData (typeof (FakeDriver))]
    //[InlineData (typeof (DotNetDriver))]

    //[InlineData (typeof (ANSIDriver))]
    //[InlineData (typeof (WindowsDriver))]
    //[InlineData (typeof (UnixDriver))]
    public void Init_Inits (Type driverType)
    {
        var driver = (IConsoleDriver)Activator.CreateInstance (driverType);
        driver.Init ();
        // Note: MainLoop is no longer returned from Init() as part of legacy MainLoop removal
        Assert.NotNull (driver.Clipboard);
        Console.ForegroundColor = ConsoleColor.Red;
        Assert.Equal (ConsoleColor.Red, Console.ForegroundColor);
        Console.BackgroundColor = ConsoleColor.Green;
        Assert.Equal (ConsoleColor.Green, Console.BackgroundColor);

        driver.End ();
    }

    //[Theory]
    //[InlineData (typeof (FakeDriver))]
    //public void FakeDriver_MockKeyPresses_Press_AfterTimeOut (Type driverType)
    //{
    //	var driver = (IConsoleDriver)Activator.CreateInstance (driverType);
    //	Application.Init (driver);

    //	// Simulating pressing of QuitKey after a short period of time
    //	uint quitTime = 100;
    //	Func<MainLoop, bool> closeCallback = (MainLoop loop) => {
    //		// Prove the scenario is using Application.QuitKey correctly
    //		output.WriteLine ($"  {quitTime}ms elapsed; Simulating keypresses...");
    //		FakeConsole.PushMockKeyPress (Key.F);
    //		FakeConsole.PushMockKeyPress (Key.U);
    //		FakeConsole.PushMockKeyPress (Key.C);
    //		FakeConsole.PushMockKeyPress (Key.K);
    //		return false;
    //	};
    //	output.WriteLine ($"Add timeout to simulate key presses after {quitTime}ms");
    //	_ = Application.AddTimeout (TimeSpan.FromMilliseconds (quitTime), closeCallback);

    //	// If Top doesn't quit within abortTime * 5 (500ms), this will force it
    //	uint abortTime = quitTime * 5;
    //	Func<MainLoop, bool> forceCloseCallback = (MainLoop loop) => {
    //		Application.RequestStop ();
    //		Assert.Fail ($"  failed to Quit after {abortTime}ms. Force quit.");
    //		return false;
    //	};
    //	output.WriteLine ($"Add timeout to force quit after {abortTime}ms");
    //	_ = Application.AddTimeout (TimeSpan.FromMilliseconds (abortTime), forceCloseCallback);

    //	Key key = Key.Unknown;

    //	Application.Top.KeyPress += (e) => {
    //		key = e.Key;
    //		output.WriteLine ($"  Application.Top.KeyPress: {key}");
    //		e.Handled = true;

    //	};

    //	int iterations = 0;
    //	Application.Iteration += (s, a) => {
    //		output.WriteLine ($"  iteration {++iterations}");

    //		if (Console.MockKeyPresses.Count == 0) {
    //			output.WriteLine ($"    No more MockKeyPresses; RequestStop");
    //			Application.RequestStop ();
    //		}
    //	};

    //	Application.Run ();

    //	// Shutdown must be called to safely clean up Application if Init has been called
    //	Application.Shutdown ();
    //}

    [Theory]
    [InlineData (typeof (FakeDriver))]
    //[InlineData (typeof (DotNetDriver))]

    //[InlineData (typeof (ANSIDriver))]
    //[InlineData (typeof (WindowsDriver))]
    //[InlineData (typeof (UnixDriver))]
    public void TerminalResized_Simulation (Type driverType)
    {
        var driver = (IConsoleDriver)Activator.CreateInstance (driverType);
        driver?.Init ();
        driver.Cols = 80;
        driver.Rows = 25;

        var wasTerminalResized = false;

        driver.SizeChanged += (s, e) =>
                              {
                                  wasTerminalResized = true;
                                  Assert.Equal (120, e.Size.GetValueOrDefault ().Width);
                                  Assert.Equal (40, e.Size.GetValueOrDefault ().Height);
                              };

        Assert.Equal (80, driver.Cols);
        Assert.Equal (25, driver.Rows);
        Assert.False (wasTerminalResized);

        driver.Cols = 120;
        driver.Rows = 40;

        ((ConsoleDriver)driver).OnSizeChanged (new SizeChangedEventArgs (new (driver.Cols, driver.Rows)));
        Assert.Equal (120, driver.Cols);
        Assert.Equal (40, driver.Rows);
        Assert.True (wasTerminalResized);
        driver.End ();
    }

    // Disabled due to test error - Change Task.Delay to an await
    //		[Fact, AutoInitShutdown]
    //		public void Write_Do_Not_Change_On_ProcessKey ()
    //		{
    //			var win = new Window ();
    //			Application.Begin (win);
    //			Application.Driver!.SetScreenSize ( (20, 8);

    //			System.Threading.Tasks.Task.Run (() => {
    //				System.Threading.Tasks.Task.Delay (500).Wait ();
    //				Application.Invoke (() => {
    //					var lbl = new Label ("Hello World") { X = Pos.Center () };
    //					var dlg = new Dialog ();
    //					dlg.Add (lbl);
    //					Application.Begin (dlg);

    //					var expected = @"
    //┌──────────────────┐
    //│┌───────────────┐ │
    //││  Hello World  │ │
    //││               │ │
    //││               │ │
    //││               │ │
    //│└───────────────┘ │
    //└──────────────────┘
    //";

    //					var pos = DriverAsserts.AssertDriverContentsWithFrameAre (expected, output);
    //					Assert.Equal (new (0, 0, 20, 8), pos);

    //					Assert.True (dlg.ProcessKey (new (Key.Tab)));
    //					dlg.Draw ();

    //					expected = @"
    //┌──────────────────┐
    //│┌───────────────┐ │
    //││  Hello World  │ │
    //││               │ │
    //││               │ │
    //││               │ │
    //│└───────────────┘ │
    //└──────────────────┘
    //";

    //					pos = DriverAsserts.AssertDriverContentsWithFrameAre (expected, output);
    //					Assert.Equal (new (0, 0, 20, 8), pos);

    //					win.RequestStop ();
    //				});
    //			});

    //			Application.Run (win);
    //			Application.Shutdown ();
    //		}

    // NOTE: This test was removed because:
    // 1. It hangs indefinitely - the Application.Run loop never exits properly with modern architecture
    // 2. It's testing general surrogate pair/input handling, not FakeDriver-specific functionality
    // 3. It uses legacy FakeDriver patterns (Console.MockKeyPresses) that don't work correctly with modern architecture
    // 4. Surrogate pair handling should be tested in input processor tests, not driver tests
    // 5. The test accesses private field _highSurrogate which is an implementation detail
    //
    // [Theory]
    // [InlineData ('\ud83d', '\udcc4')] // This seems right sequence but Stack is LIFO
    // [InlineData ('\ud83d', '\ud83d')]
    // [InlineData ('\udcc4', '\udcc4')]
    // public void FakeDriver_IsValidInput_Wrong_Surrogate_Sequence (char c1, char c2)

    // NOTE: This test was also removed for the same reasons as FakeDriver_IsValidInput_Wrong_Surrogate_Sequence:
    // 1. It hangs indefinitely - the Application.Run loop never exits properly with modern architecture  
    // 2. It's testing general surrogate pair/input handling, not FakeDriver-specific functionality
    // 3. It uses legacy FakeDriver patterns (Console.MockKeyPresses) that don't work correctly with modern architecture
    // 4. Surrogate pair handling should be tested in input processor tests, not driver tests
    //
    // [Fact]
    // public void FakeDriver_IsValidInput_Correct_Surrogate_Sequence ()

    /// <summary>
    /// Tests that when ConsoleDriver.RunningUnitTests is true, Application.Init() without
    /// parameters uses FakeDriver instead of platform-specific drivers.
    /// This prevents intermittent failures on macOS where kernel32.dll might be referenced.
    /// </summary>
    [Fact]
    public void Application_Init_Without_Params_Uses_FakeDriver_When_RunningUnitTests ()
    {
        // Arrange
        ConsoleDriver.RunningUnitTests = true;
        Application.ResetState (true);

        // Act
        Application.Init ();

        // Assert
        Assert.NotNull (Application.Driver);
        // In the modern v2 architecture, the driver will be a ConsoleDriverFacade wrapping FakeDriver
        // The key is that it's not attempting to use Windows/Unix platform-specific drivers
        Assert.True (Application.Initialized);

        // Cleanup
        Application.Shutdown ();
        Application.ResetState (true);
    }
}