using System;
using System.Runtime.InteropServices;
using AOT;

public partial class SystemModule: CallbackHandler<SystemModule>
{
    private void BuildCallbacks()
    {
        var callbacks = new Callbacks
        {
            SysPrint = CreateCallback<SysPrintCallback>(Callback_SysPrint),
            SysError = CreateCallback<SysErrorCallback>(Callback_SysError),
            SysQuit = CreateCallback<SysQuitCallback>(Callback_SysQuit),
            SysDoubleTime = CreateCallback<SysDoubleTimeCallback>(Callback_SysDoubleTime),
            
            SysFileOpenRead = CreateCallback<SysFileOpenReadCallback>(Callback_SysFileOpenRead),
            SysFileOpenWrite = CreateCallback<SysFileOpenWriteCallback>(Callback_SysFileOpenWrite),
            SysFileClose = CreateCallback<SysFileCloseCallback>(Callback_SysFileClose),
            SysFileSeek = CreateCallback<SysFileSeekCallback>(Callback_SysFileSeek),
            SysFileRead = CreateCallback<SysFileReadCallback>(Callback_SysFileRead),
            SysFileWrite = CreateCallback<SysFileWriteCallback>(Callback_SysFileWrite),
            SysFileTime = CreateCallback<SysFileTimeCallback>(Callback_SysFileTime),
            SysMkDir = CreateCallback<SysMkDirCallback>(Callback_SysMkDir),
        };
        
        RegisterCallbacks(callbacks);
    }
    
    /// <summary>
    /// This matches struct unity_syscalls_s from uniquake.h in native code.
    /// </summary>
    [StructLayout(LayoutKind.Sequential, Pack = 0)]
    private class Callbacks
    {
        public IntPtr SysPrint;
        public IntPtr SysError;
        public IntPtr SysQuit;
        public IntPtr SysDoubleTime;

        public IntPtr SysFileOpenRead;
        public IntPtr SysFileOpenWrite;
        public IntPtr SysFileClose;
        public IntPtr SysFileSeek;
        public IntPtr SysFileRead;
        public IntPtr SysFileWrite;
        public IntPtr SysFileTime;
        public IntPtr SysMkDir;
    }

    [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
    private delegate void SysPrintCallback(IntPtr target,
        [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(QuakeTextMarshaler))] string message);
    
    [MonoPInvokeCallback(typeof(SysPrintCallback))]
    private static void Callback_SysPrint(IntPtr target, string message)
    {
        GetSelf(target).Print(message);
    }

    [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
    private delegate void SysErrorCallback(IntPtr target,
        [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(QuakeTextMarshaler))] string message);

    [MonoPInvokeCallback(typeof(SysErrorCallback))]
    private static void Callback_SysError(IntPtr target, string message)
    {
        GetSelf(target).Error(message);
    }
    
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    private delegate void SysQuitCallback(IntPtr target);
    
    [MonoPInvokeCallback(typeof(SysQuitCallback))]
    private static void Callback_SysQuit(IntPtr target)
    {
        GetSelf(target).Quit();
    }
    
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    private delegate double SysDoubleTimeCallback(IntPtr target);

    [MonoPInvokeCallback(typeof(SysDoubleTimeCallback))]
    private static double Callback_SysDoubleTime(IntPtr target)
    {
        return GetSelf(target).DoubleTime();
    }
    
    [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
    private delegate int SysFileOpenReadCallback(IntPtr target, [MarshalAs(UnmanagedType.LPStr)] string path, out int handle);

    [MonoPInvokeCallback(typeof(SysFileOpenReadCallback))]
    private static int Callback_SysFileOpenRead(IntPtr target, string path, out int handle)
    {
        return GetSelf(target).FileOpenRead(path, out handle);
    }
    
    [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
    private delegate int SysFileOpenWriteCallback(IntPtr target, [MarshalAs(UnmanagedType.LPStr)] string path);

    [MonoPInvokeCallback(typeof(SysFileOpenWriteCallback))]
    private static int Callback_SysFileOpenWrite(IntPtr target, string path)
    {
        return GetSelf(target).FileOpenWrite(path);
    }
    
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    private delegate void SysFileCloseCallback(IntPtr target, int handle);

    [MonoPInvokeCallback(typeof(SysFileCloseCallback))]
    private static void Callback_SysFileClose(IntPtr target, int handle)
    {
        GetSelf(target).FileClose(handle);
    }
    
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    private delegate void SysFileSeekCallback(IntPtr target, int handle, int position);

    [MonoPInvokeCallback(typeof(SysFileSeekCallback))]
    private static void Callback_SysFileSeek(IntPtr target, int handle, int position)
    {
        GetSelf(target).FileSeek(handle, position);
    }
    
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    private delegate int SysFileReadCallback(IntPtr target, int handle, IntPtr dest, int count);

    [MonoPInvokeCallback(typeof(SysFileReadCallback))]
    private static int Callback_SysFileRead(IntPtr target, int handle, IntPtr dest, int count)
    {
        return GetSelf(target).FileRead(handle, dest, count);
    }
    
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    private delegate int SysFileWriteCallback(IntPtr target, int handle, IntPtr data, int count);

    [MonoPInvokeCallback(typeof(SysFileWriteCallback))]
    private static int Callback_SysFileWrite(IntPtr target, int handle, IntPtr data, int count)
    {
        return GetSelf(target).FileWrite(handle, data, count);
    }
    
    [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
    private delegate int SysFileTimeCallback(IntPtr target, [MarshalAs(UnmanagedType.LPStr)] string path);

    [MonoPInvokeCallback(typeof(SysFileTimeCallback))]
    private static int Callback_SysFileTime(IntPtr target, string path)
    {
        return GetSelf(target).FileTime(path);
    }
    
    [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
    private delegate bool SysMkDirCallback(IntPtr target, [MarshalAs(UnmanagedType.LPStr)] string path);

    [MonoPInvokeCallback(typeof(SysMkDirCallback))]
    private static bool Callback_SysMkDir(IntPtr target, string path)
    {
        return GetSelf(target).MkDir(path);
    }
}