using System.Runtime.CompilerServices;

namespace Dalamud.Bindings.ImGui;

public unsafe struct ImVector
{
    public readonly int Size;
    public readonly int Capacity;
    public readonly void* Data;

    public ImVector(int size, int capacity, void* data)
    {
        Size = size;
        Capacity = capacity;
        Data = data;
    }

    public ref T Ref<T>(int index)
    {
        return ref Unsafe.AsRef<T>((byte*)Data + index * Unsafe.SizeOf<T>());
    }

    public IntPtr Address<T>(int index)
    {
        return (IntPtr)((byte*)Data + index * Unsafe.SizeOf<T>());
    }
}

/// <summary>
/// A structure representing a dynamic array for unmanaged types.
/// </summary>
/// <typeparam name="T">The type of elements in the vector, must be unmanaged.</typeparam>
public unsafe struct ImVector<T> where T : unmanaged
{
    /// <summary>
    /// Initializes a new instance of the <see cref="ImVector{T}"/> struct with the specified size, capacity, and data pointer.
    /// </summary>
    /// <param name="size">The initial size of the vector.</param>
    /// <param name="capacity">The initial capacity of the vector.</param>
    /// <param name="data">Pointer to the initial data.</param>
    public ImVector(int size, int capacity, T* data)
    {
        this.size = size;
        this.capacity = capacity;
        this.data = data;
    }

    private int size;
    private int capacity;
    private unsafe T* data;


    /// <summary>
    /// Gets or sets the element at the specified index.
    /// </summary>
    /// <param name="index">The zero-based index of the element to get or set.</param>
    /// <returns>The element at the specified index.</returns>
    /// <exception cref="IndexOutOfRangeException">Thrown when the index is out of range.</exception>
    public T this[int index]
    {
        get
        {
            if (index < 0 || index >= size)
            {
                throw new IndexOutOfRangeException();
            }
            return data[index];
        }
        set
        {
            if (index < 0 || index >= size)
            {
                throw new IndexOutOfRangeException();
            }
            data[index] = value;
        }
    }

    /// <summary>
    /// Gets a pointer to the first element of the vector.
    /// </summary>
    public readonly T* Data => data;

    /// <summary>
    /// Gets a pointer to the first element of the vector.
    /// </summary>
    public readonly T* Front => data;

    /// <summary>
    /// Gets a pointer to the last element of the vector.
    /// </summary>
    public readonly T* Back => size > 0 ? data + size - 1 : null;

    /// <summary>
    /// Gets or sets the capacity of the vector.
    /// </summary>
    public int Capacity
    {
        readonly get => capacity;
        set
        {
            if (capacity == value)
            {
                return;
            }

            if (data == null)
            {
                data = (T*)ImGui.MemAlloc((nuint)(value * sizeof(T)));
            }
            else
            {
                int newSize = Math.Min(size, value);
                T* newData = (T*)ImGui.MemAlloc((nuint)(value * sizeof(T)));
                Buffer.MemoryCopy(data, newData, (nuint)(value * sizeof(T)), (nuint)(newSize * sizeof(T)));
                ImGui.MemFree(data);
                data = newData;
                size = newSize;
            }

            capacity = value;

            // Clear the rest of the data
            for (int i = size; i < capacity; i++)
            {
                data[i] = default;
            }
        }
    }

    /// <summary>
    /// Gets the number of elements in the vector.
    /// </summary>
    public readonly int Size => size;

    /// <summary>
    /// Grows the capacity of the vector to at least the specified value.
    /// </summary>
    /// <param name="newCapacity">The new capacity.</param>
    public void Grow(int newCapacity)
    {
        if (newCapacity > capacity)
        {
            Capacity = newCapacity * 2;
        }
    }

    /// <summary>
    /// Ensures that the vector has at least the specified capacity.
    /// </summary>
    /// <param name="size">The minimum capacity required.</param>
    public void EnsureCapacity(int size)
    {
        if (size > capacity)
        {
            Grow(size);
        }
    }

    /// <summary>
    /// Resizes the vector to the specified size.
    /// </summary>
    /// <param name="newSize">The new size of the vector.</param>
    public void Resize(int newSize)
    {
        EnsureCapacity(newSize);
        size = newSize;
    }

    /// <summary>
    /// Clears all elements from the vector.
    /// </summary>
    public void Clear()
    {
        size = 0;
    }

    /// <summary>
    /// Adds an element to the end of the vector.
    /// </summary>
    /// <param name="value">The value to add.</param>
    public void PushBack(T value)
    {
        EnsureCapacity(size + 1);
        data[size++] = value;
    }

    /// <summary>
    /// Removes the last element from the vector.
    /// </summary>
    public void PopBack()
    {
        if (size > 0)
        {
            size--;
        }
    }

    /// <summary>
    /// Frees the memory allocated for the vector.
    /// </summary>
    public void Free()
    {
        if (data != null)
        {
            ImGui.MemFree(data);
            data = null;
            size = 0;
            capacity = 0;
        }
    }

    public ref T Ref(int index)
    {
        return ref Unsafe.AsRef<T>((byte*)Data + index * Unsafe.SizeOf<T>());
    }

    public ref TCast Ref<TCast>(int index)
    {
        return ref Unsafe.AsRef<TCast>((byte*)Data + index * Unsafe.SizeOf<TCast>());
    }

    public void* Address(int index)
    {
        return (byte*)Data + index * Unsafe.SizeOf<T>();
    }

    public void* Address<TCast>(int index)
    {
        return (byte*)Data + index * Unsafe.SizeOf<TCast>();
    }

    public ImVector* ToUntyped()
    {
        return (ImVector*)Unsafe.AsPointer(ref this);
    }
}