using Python.Runtime;
using System.Diagnostics;

namespace Detune.PythonBridge
{
    /// <summary>
    /// Manages the Python environment using pythonnet.
    /// </summary>
    public class PythonNetEnv : IDisposable
    {
        /// <summary>
        /// Indicates if the environment is initialized.
        /// </summary>
        public bool IsInitialized { get; private set; }

        private readonly PythonEnv _env;
        private PythonEngine? _engine;
        private string? _originalPath;
        private string? _originalPythonhome;
        private static readonly char[] separator = [' '];
        private int _currentWriter = -1;
        private DateTime lastWriteTime = DateTime.MinValue;
        private CancellationTokenSource _cts = new();

        /// <summary>
        /// Event triggered when a response from Pythonnet is received.
        /// </summary>
        public event EventHandler<ConsoleResponse>? OnPythonnetResponse;

        /// <summary>
        /// Initializes a new instance of the <see cref="PythonNetEnv"/> class.
        /// </summary>
        /// <param name="pythonEnv">The path to the Python environment directory.</param>
        public PythonNetEnv(PythonEnv pythonEnv)
        {
            _env = pythonEnv ?? throw new ArgumentNullException(nameof(pythonEnv));
            Initialize();
        }

        /// <summary>
        /// Initializes the Python environment.
        /// </summary>
        private void Initialize()
        {
            if (IsInitialized) return;

            // Construct the necessary paths
            string scriptsPath = Path.Combine(_env.EnvPath, "Scripts");
            string libraryPath = Path.Combine(_env.EnvPath, "Library");
            string binPath = Path.Combine(_env.EnvPath, "bin");
            string executablePath = Path.Combine(_env.EnvPath, "Library", "bin");
            string mingwBinPath = Path.Combine(_env.EnvPath, "Library", "mingw-w64", "bin");

            // Get the current PATH environment variable
            _originalPath = Environment.GetEnvironmentVariable("PATH");
            _originalPythonhome = Environment.GetEnvironmentVariable("PYTHONHOME");

            // Set the new PATH environment variable
            string newPath = $"{_env.EnvPath};{scriptsPath};{libraryPath};{binPath};{executablePath};{mingwBinPath};{_originalPath}";
            Environment.SetEnvironmentVariable("PATH", newPath, EnvironmentVariableTarget.Process);

            // Set the PYTHONHOME environment variable
            Environment.SetEnvironmentVariable("PYTHONHOME", _env.EnvPath, EnvironmentVariableTarget.Process);

            // Extract the major and minor version numbers from the provided version string
            string[] versionParts = _env.Version.Split('.');
            if (versionParts.Length < 2)
                throw new ArgumentException("Invalid Python version format. Expected format: main.current.path (e.g., 3.8.20)");

            string majorVersion = versionParts[0];
            string minorVersion = versionParts[1];

            // Construct the Python runtime DLL path based on the version
            string pythonDllPath = Path.Combine(_env.EnvPath, $"python{majorVersion}{minorVersion}.dll");

            // Explicitly set the Python runtime DLL path
            Runtime.PythonDLL = pythonDllPath;

            // Set PythonEngine.PythonHome
            PythonEngine.PythonHome = _env.EnvPath;
            if (!PythonEngine.IsInitialized)
            {
                // Initialize the Python engine
                _engine = new PythonEngine();
            }
            else Debug.WriteLine("Exception");
            // Allow Python threads to run independently of the main thread
            PythonEngine.BeginAllowThreads();

            IsInitialized = true;
        }

        /// <summary>
        /// Runs a Python script from a specific path with specified arguments.
        /// </summary>
        /// <param name="scriptPath">The path to the Python script.</param>
        /// <param name="workingDirectory">The working directory for the script.</param>
        /// <param name="arguments">The arguments to pass to the script.</param>
        public async Task RunPythonScript(string scriptPath, string workingDirectory, string arguments)
        {
            if (!IsInitialized) throw new InvalidOperationException("Python environment is not initialized.");
            await Task.Run(() =>
            {
                string currentDictionary = Environment.CurrentDirectory;
                using (Py.GIL())
                {
                    try
                    {
                        Environment.CurrentDirectory = workingDirectory;
                        dynamic sys = Py.Import("sys");
                        dynamic io = Py.Import("io");

                        ValidateScriptPath(scriptPath);
                        ConfigurePythonArguments(sys, scriptPath, arguments);
                        string moduleName = Path.GetFileNameWithoutExtension(scriptPath);
                        Debug.WriteLine($"Importing module: {moduleName}");

                        dynamic stdout_capture = io.StringIO();
                        dynamic stderr_capture = io.StringIO();
                        sys.stdout = stdout_capture;
                        sys.stderr = stderr_capture;
                        _cts = new CancellationTokenSource();
                        _ = Task.Run(() => CaptureOutput(stdout_capture, false, 0, _cts.Token));
                        _ = Task.Run(() => CaptureOutput(stderr_capture, true, 1, _cts.Token));

                        try
                        {
                            ExecutePythonScript(scriptPath);
                        }
                        finally
                        {
                            _cts.Cancel();
                            RestoreStandardOutputs(sys, stdout_capture, stderr_capture);
                        }
                    }
                    catch (PythonException ex)
                    {
                        Console.WriteLine($"Python error: {ex.Message}");
                        Console.WriteLine($"Stack Trace: {ex.StackTrace}");
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"Error: {ex.Message}");
                        Console.WriteLine($"Stack Trace: {ex.StackTrace}");
                    }
                }
                Environment.CurrentDirectory = currentDictionary;
            });
        }

        private static void ValidateScriptPath(string scriptPath)
        {
            if (!File.Exists(scriptPath))
            {
                Console.WriteLine($"Script file not found: {scriptPath}");
                throw new FileNotFoundException($"Script file not found: {scriptPath}");
            }
        }

        private static void ConfigurePythonArguments(dynamic sys, string scriptPath, string arguments)
        {
            string[] argsArray = arguments.Split(separator, StringSplitOptions.RemoveEmptyEntries);
            using var pyList = new PyList([new PyString(scriptPath), .. argsArray.Select(arg => new PyString(arg))]);
            sys.argv = pyList;
            sys.path.append(Environment.CurrentDirectory);
        }

        private async Task CaptureOutput(dynamic captureStream, bool error, int instanceId, CancellationToken token)
        {
            int index = 0;
            string currentOutput = "";
            while (!token.IsCancellationRequested)
            {
                try
                {
                    using (Py.GIL())
                    {
                        var currentOutputValue = captureStream.getvalue();
                        if (currentOutputValue != null)
                            currentOutput = currentOutputValue.ToString(); // It happens sometimes here, while the code is running. Throws an error but the try-catch does not prevent exiting of the program.
                    }
                }
                catch (System.AccessViolationException ex) { Debug.WriteLine(ex); }
                if (index == currentOutput.Length)
                {
                    await Task.Delay(20, token);
                    continue;
                }

                bool shouldWrite = _currentWriter == -1 || _currentWriter == instanceId;
                bool setWrite = false;
                if (!shouldWrite && (DateTime.Now - lastWriteTime).TotalMilliseconds >= 20)
                    setWrite = true;

                if (shouldWrite || setWrite)
                {
                    _currentWriter = instanceId;
                    OnPythonnetResponse?.Invoke(this, new ConsoleResponse(error, (setWrite ? Environment.NewLine : "") + currentOutput[index..]));
                    index = currentOutput.Length;
                    lastWriteTime = DateTime.Now;
                }
            }
        }

        private static void ExecutePythonScript(string scriptPath)
        {
            using (Py.GIL())
            {
                using dynamic scope = Py.CreateScope();
                scope.Set("__name__", "__main__");
                scope.Exec(File.ReadAllText(scriptPath)); // It happens sometimes here, while the code is running. Throws an error but the try-catch does not prevent exiting of the program.
            }
        }

        private static void RestoreStandardOutputs(dynamic sys, dynamic stdout_capture, dynamic stderr_capture)
        {
            using (Py.GIL())
            {
                sys.stdout = sys.__stdout__;
                sys.stderr = sys.__stderr__;

                try
                {
                    _ = stdout_capture.getvalue().ToString();
                    _ = stderr_capture.getvalue().ToString();
                }
                finally
                {
                    // Dispose of the captured streams if they implement IDisposable
                    if (stdout_capture is IDisposable stdoutDisposable)
                    {
                        stdoutDisposable.Dispose();
                    }
                    if (stderr_capture is IDisposable stderrDisposable)
                    {
                        stderrDisposable.Dispose();
                    }
                }
            }
        }

        /// <summary>
        /// Disposes of the Python environment, shutting down the Python engine.
        /// </summary>
        public void Dispose()
        {
            if (!IsInitialized)
                return;

            try
            {
                _cts.Dispose();
            }
            catch (Exception) { }

            try
            {
                Debug.WriteLine("Shutdown");

                PythonEngine.Shutdown(); // Somewhere here does it happen at most. The catch does not work.
                _engine?.Dispose();
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex);
            }
            finally
            {
                Environment.SetEnvironmentVariable("PATH", _originalPath, EnvironmentVariableTarget.Process);
                Environment.SetEnvironmentVariable("PYTHONHOME", _originalPythonhome, EnvironmentVariableTarget.Process);

            }
        }
    }
}