using System.Threading.Tasks;
using WhiteMagic.Assembly;
using WhiteMagic.Execution;

namespace WhiteMagic;

/// <summary>
/// An exported function resolved in the target process, obtained via
/// <c>magic["module"]["function"]</c>. Executes through one of the session's execution
/// strategies.
/// </summary>
/// <remarks>
/// The default <see cref="Execute{T}"/> path uses the always-available
/// <see cref="RemoteThreadExecutor"/> (<c>CreateRemoteThread</c>), which is safe for
/// thread-agnostic exports. For a call that touches single-threaded target state, obtain
/// the <see cref="Address"/> and route it through a <see cref="MainThreadPump"/>, or use
/// <see cref="CreateDelegate{TDelegate}"/> when running in-process.
/// </remarks>
public sealed class RemoteFunction
{
    private readonly Magic _magic;

    /// <summary>The export name this function was resolved from.</summary>
    public string Name { get; }

    /// <summary>The absolute address of the function in the target process.</summary>
    public IntPtr Address { get; }

    internal RemoteFunction(Magic magic, string name, IntPtr address)
    {
        _magic = magic;
        Name = name;
        Address = address;
    }

    /// <summary>
    /// Calls the function via a remote thread and returns its result cast to
    /// <typeparamref name="T"/>.
    /// </summary>
    /// <param name="convention">The calling convention (ignored on x64 targets).</param>
    /// <param name="args">Arguments to pass; primitives, pointers, enums, strings and
    /// structs are supported.</param>
    public T Execute<T>(CallConvention convention, params object?[] args)
    {
        return _magic.RemoteThread.Execute<T>(Address, convention, args);
    }

    /// <summary>Asynchronous variant of <see cref="Execute{T}"/>.</summary>
    public Task<T> ExecuteAsync<T>(CallConvention convention, params object?[] args)
    {
        return _magic.RemoteThread.ExecuteAsync<T>(Address, convention, args);
    }

    /// <summary>
    /// Creates a managed delegate bound to this function for the in-process scenario.
    /// Only valid when the session was opened in-process.
    /// </summary>
    public TDelegate CreateDelegate<TDelegate>() where TDelegate : Delegate
    {
        return new InProcessInvoker(_magic.Memory).CreateFunction<TDelegate>(Address);
    }
}