namespace Nodebox.Util.Math;

public sealed class Multiply : BinaryOperator {
    public override Dictionary<(Type, Type), Func<object, object, object>> BaseLookup => new() {
        { (typeof(float), typeof(float)), (a, b) => (float)a * (float)b },
        { (typeof(double), typeof(double)), (a, b) => (double)a * (double)b },

        { (typeof(int), typeof(int)), (a, b) => (int)a * (int)b },
        { (typeof(uint), typeof(uint)), (a, b) => (uint)a * (uint)b },

        { (typeof(long), typeof(long)), (a, b) => (long)a * (long)b },
        { (typeof(ulong), typeof(ulong)), (a, b) => (ulong)a * (ulong)b },

        { (typeof(short), typeof(short)), (a, b) => (short)a * (short)b },
        { (typeof(ushort), typeof(ushort)), (a, b) => (ushort)a * (ushort)b },

        { (typeof(sbyte), typeof(sbyte)), (a, b) => (sbyte)a * (sbyte)b },
        { (typeof(byte), typeof(byte)), (a, b) => (byte)a * (byte)b },

        { (typeof(Vector2), typeof(Vector2)), (a, b) => (Vector2)a * (Vector2)b },
        { (typeof(Vector3), typeof(Vector3)), (a, b) => (Vector3)a * (Vector3)b },
        { (typeof(Vector4), typeof(Vector4)), (a, b) => (Vector4)a * (Vector4)b },
        { (typeof(Vector2Int), typeof(Vector2Int)), (a, b) => (Vector2Int)a * (Vector2Int)b },
        { (typeof(Vector3Int), typeof(Vector3Int)), (a, b) => (Vector3Int)a * (Vector3Int)b },

        { (typeof(Angles), typeof(Angles)), (a, b) => new Angles(
            ((Angles)a).pitch * ((Angles)b).pitch,
            ((Angles)a).yaw * ((Angles)b).yaw,
            ((Angles)a).roll * ((Angles)b).roll
        ) },

        { (typeof(Rotation), typeof(Rotation)), (a, b) => (Rotation)a * (Rotation)b },

        { (typeof(Color), typeof(Color)), (a, b) => (Color)a * (Color)b },

        // { (typeof(Rect), typeof(Rect)), (a, b) => (Rect)a * (Rect)b },
        // { (typeof(RectInt), typeof(RectInt)), (a, b) => (RectInt)a * (RectInt)b },
    };
}