using System;
using System.Runtime.InteropServices;
using System.Threading;

internal static class Nova64Core
{
    private const string LibName = "nova64_core";

    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    public delegate void DisplayFlushDelegate(IntPtr buffer, ushort width, ushort height);

    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    public delegate void AudioOutputDelegate(IntPtr samples, uint count);

    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    public delegate bool SdReadSectorDelegate(uint sectorIdx, IntPtr destinationBuffer, uint sectorCount);

    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    public delegate void CartridgeStatusDelegate(uint slotIdx, bool isInserted);

    [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
    public delegate void LogMessageDelegate([MarshalAs(UnmanagedType.LPStr)] string message);

    [StructLayout(LayoutKind.Sequential)]
    public struct Nova64IoInterface
    {
        public IntPtr display_flush;
        public IntPtr audio_output;
        public IntPtr sd_read_sector;
        public IntPtr cartridge_status;
        public IntPtr log_message;
    }

    [DllImport(LibName, CallingConvention = CallingConvention.Cdecl)]
    public static extern bool nova64_init(IntPtr io_interface);

    [DllImport(LibName, CallingConvention = CallingConvention.Cdecl)]
    public static extern int nova64_main();

    [DllImport(LibName, CallingConvention = CallingConvention.Cdecl)]
    public static extern bool nova64_shutdown();

    [DllImport(LibName, CallingConvention = CallingConvention.Cdecl)]
    public static extern uint nova64_get_version();
}

internal static class Program
{
    private static readonly Nova64Core.DisplayFlushDelegate DisplayFlush = (buffer, width, height) => { };
    private static readonly Nova64Core.AudioOutputDelegate AudioOutput = (samples, count) => { };
    private static readonly Nova64Core.SdReadSectorDelegate SdReadSector = (sectorIdx, destinationBuffer, sectorCount) => false;
    private static readonly Nova64Core.CartridgeStatusDelegate CartridgeStatus = (slotIdx, isInserted) => { };
    private static readonly Nova64Core.LogMessageDelegate LogMessage = (message) =>
    {
        Console.Write($"[Nova64] {message}");
    };

    private static GCHandle? _ioHandle;
    private static Thread? _coreThread;
    private static readonly ManualResetEventSlim _coreStartedEvent = new(false);

    private static void CoreThreadProc()
    {
        if (_ioHandle == null)
        {
            Console.WriteLine("[Nova64] Core thread failed: IO handle missing.");
            return;
        }

        if (!Nova64Core.nova64_init(_ioHandle.Value.AddrOfPinnedObject()))
        {
            Console.WriteLine("[Nova64] nova64_init failed in core thread.");
            _coreStartedEvent.Set();
            return;
        }

        _coreStartedEvent.Set();

        var result = Nova64Core.nova64_main();
        Console.WriteLine($"[Nova64] nova64_main returned: {result}");
    }

    private static void Main()
    {
        Console.WriteLine("Nova64 simulator starting...");

        try
        {
            var version = Nova64Core.nova64_get_version();
            Console.WriteLine($"Loaded nova64_core native library. Version: 0x{version:X}");

            var ioInterface = new Nova64Core.Nova64IoInterface
            {
                display_flush = Marshal.GetFunctionPointerForDelegate(DisplayFlush),
                audio_output = Marshal.GetFunctionPointerForDelegate(AudioOutput),
                sd_read_sector = Marshal.GetFunctionPointerForDelegate(SdReadSector),
                cartridge_status = Marshal.GetFunctionPointerForDelegate(CartridgeStatus),
                log_message = Marshal.GetFunctionPointerForDelegate(LogMessage)
            };

            _ioHandle = GCHandle.Alloc(ioInterface, GCHandleType.Pinned);
            _coreThread = new Thread(CoreThreadProc)
            {
                IsBackground = true,
                Name = "Nova64CoreThread"
            };
            _coreThread.Start();

            if (_coreStartedEvent.Wait(TimeSpan.FromSeconds(5)))
            {
                Console.WriteLine("nova64 core thread started.");
            }
            else
            {
                Console.WriteLine("nova64 core thread did not signal startup in time.");
            }

            Console.WriteLine("Press Enter to stop the simulator.");
            Console.ReadLine();

            if (_coreThread != null && _coreThread.IsAlive)
            {
                Console.WriteLine("[Nova64] Requesting core shutdown...");
                if (Nova64Core.nova64_shutdown())
                {
                    if (!_coreThread.Join(TimeSpan.FromSeconds(5)))
                    {
                        Console.WriteLine("[Nova64] Core thread did not exit in time.");
                    }
                }
                else
                {
                    Console.WriteLine("[Nova64] Core shutdown request failed.");
                }
            }
        }
        catch (DllNotFoundException ex)
        {
            Console.WriteLine($"Native library not found: {ex.Message}");
        }
        catch (EntryPointNotFoundException ex)
        {
            Console.WriteLine($"Native entry point missing: {ex.Message}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Failed to initialize native library: {ex.Message}");
        }
        finally
        {
            if (_coreThread != null && _coreThread.IsAlive)
            {
                Console.WriteLine("[Nova64] Core thread still running; leaving native handle pinned until process exit.");
            }
            else if (_ioHandle.HasValue && _ioHandle.Value.IsAllocated)
            {
                _ioHandle.Value.Free();
            }
        }
    }
}