using System;
using System.Linq;

namespace WhiteMagic.Hooking;

/// <summary>
/// A single reversible byte patch. Captures the original bytes when applied,
/// restores them when removed, and reports its state by comparing live memory.
/// </summary>
public sealed class Patch : IDisposable
{
    private readonly MemoryBase _memory;

    /// <summary>The unique name of this patch.</summary>
    public string Name { get; }

    /// <summary>The address the patch overwrites.</summary>
    public IntPtr Address { get; }

    /// <summary>The bytes written by the patch.</summary>
    public byte[] PatchBytes { get; }

    /// <summary>The bytes captured before the patch was applied.</summary>
    public byte[]? OriginalBytes { get; private set; }

    /// <summary>
    /// <see langword="true"/> when the live bytes at <see cref="Address"/> match
    /// <see cref="PatchBytes"/>.
    /// </summary>
    public bool IsApplied
    {
        get
        {
            byte[] current = _memory.ReadBytes(Address, PatchBytes.Length);
            return current.SequenceEqual(PatchBytes);
        }
    }

    internal Patch(MemoryBase memory, string name, IntPtr address, byte[] patchBytes)
    {
        ArgumentNullException.ThrowIfNull(patchBytes);

        _memory = memory;
        Name = name;
        Address = address;
        PatchBytes = patchBytes;
    }

    /// <summary>Captures the original bytes and writes the patch bytes.</summary>
    public void Apply()
    {
        if (IsApplied)
            return;

        OriginalBytes = _memory.ReadBytes(Address, PatchBytes.Length);
        _memory.WriteBytes(Address, PatchBytes);
    }

    /// <summary>Restores the original bytes if they were captured.</summary>
    public void Remove()
    {
        if (OriginalBytes is null)
            return;

        _memory.WriteBytes(Address, OriginalBytes);
        OriginalBytes = null;
    }

    /// <inheritdoc />
    public void Dispose()
    {
        Remove();
    }
}