const std = @import("std");
const vm = @import("../root.zig");

pub const Vector2x8 = struct {
    x: vm.f32x8,
    y: vm.f32x8,

    pub const zero = initScalarSingle(0);
    pub const one = initScalarSingle(1);
    pub const unit_x = initSingle(1, 0);
    pub const unit_y = initSingle(0, 1);
    pub const unit_nx = initSingle(-1, 0);
    pub const unit_ny = initSingle(0, -1);

    // --- INIT ----------------------------------------------------------------

    pub inline fn init(x: vm.f32x8, y: vm.f32x8) Vector2x8 {
        return .{ .x = x, .y = y };
    }

    pub inline fn initSingle(x: f32, y: f32) Vector2x8 {
        return .{ .x = vm.ps(x), .y = vm.ps(y) };
    }

    pub inline fn initScalar(scalar: vm.f32x8) Vector2x8 {
        return .{ .x = scalar, .y = scalar };
    }

    pub inline fn initScalarSingle(scalar: f32) Vector2x8 {
        return .{ .x = vm.ps(scalar), .y = vm.ps(scalar) };
    }

    pub inline fn initArrayOfVectors(vectors: [8]vm.Vector2) Vector2x8 {
        const vector: @Vector(16, f32) = @as([16]f32, @bitCast(vectors));
        return .{
            .x = @shuffle(f32, vector, undefined, [_]i32{ 0, 2, 4, 6, 8, 10, 12, 14 }),
            .y = @shuffle(f32, vector, undefined, [_]i32{ 1, 3, 5, 7, 9, 11, 13, 15 }),
        };
    }

    pub inline fn splat(vector: vm.Vector2) Vector2x8 {
        return .{ .x = vm.ps(vector.x), .y = vm.ps(vector.y) };
    }

    // --- CONVERSION ----------------------------------------------------------

    pub inline fn asInt(self: Vector2x8) vm.Vector2Int_x8 {
        return .{ .x = @intFromFloat(self.x), .y = @intFromFloat(self.y) };
    }

    pub inline fn withZ(self: Vector2x8, z: vm.f32x8) vm.Vector3x8 {
        return .{ .x = self.x, .y = self.y, .z = z };
    }

    pub inline fn withZW(self: Vector2x8, z: vm.f32x8, w: vm.f32x8) vm.Vector4x8 {
        return .{ .x = self.x, .y = self.y, .z = z, .w = w };
    }

    pub inline fn asArrayOfVectors(self: Vector2x8) [8]vm.Vector2 {
        const vector: @Vector(16, f32) = self.x ++ self.y;
        return @bitCast(@as([16]f32, @shuffle(f32, vector, undefined, [_]i32{
            0, 8,
            1, 9,
            2, 10,
            3, 11,
            4, 12,
            5, 13,
            6, 14,
            7, 15,
        })));
    }

    pub inline fn unpack(self: Vector2x8) [2]vm.f32x8 {
        return .{ self.x, self.y };
    }

    // --- LOAD AND STORE ------------------------------------------------------

    pub inline fn loadArrayOfVectors(self: *Vector2x8, array: *const [8]vm.Vector2) void {
        const vector: @Vector(16, f32) = @as(*const [16]f32, @ptrCast(array)).*;
        self.x = @shuffle(f32, vector, undefined, [_]i32{ 0, 2, 4, 6, 8, 10, 12, 14 });
        self.y = @shuffle(f32, vector, undefined, [_]i32{ 1, 3, 5, 7, 9, 11, 13, 15 });
    }

    pub inline fn storeArrayOfVectors(self: *const Vector2x8, array: *[8]vm.Vector2) void {
        const vector: @Vector(16, f32) = self.x ++ self.y;
        @as(*[16]f32, @ptrCast(array)).* = @shuffle(f32, vector, undefined, [_]i32{
            0, 8,
            1, 9,
            2, 10,
            3, 11,
            4, 12,
            5, 13,
            6, 14,
            7, 15,
        });
    }

    // --- COMPONENT-WISE ------------------------------------------------------

    pub inline fn add(self: Vector2x8, other: Vector2x8) Vector2x8 {
        return .{ .x = self.x + other.x, .y = self.y + other.y };
    }

    pub inline fn sub(self: Vector2x8, other: Vector2x8) Vector2x8 {
        return .{ .x = self.x - other.x, .y = self.y - other.y };
    }

    pub inline fn mul(self: Vector2x8, other: Vector2x8) Vector2x8 {
        return .{ .x = self.x * other.x, .y = self.y * other.y };
    }

    pub inline fn mulScalar(self: Vector2x8, scalar: vm.f32x8) Vector2x8 {
        return .{ .x = self.x * scalar, .y = self.y * scalar };
    }

    pub inline fn mulScalarSingle(self: Vector2x8, scalar: f32) Vector2x8 {
        return .{ .x = self.x * vm.ps(scalar), .y = self.y * vm.ps(scalar) };
    }

    pub inline fn div(self: Vector2x8, other: Vector2x8) Vector2x8 {
        return .{ .x = self.x / other.x, .y = self.y / other.y };
    }

    pub inline fn divScalar(self: Vector2x8, scalar: vm.f32x8) Vector2x8 {
        return .{ .x = self.x / scalar, .y = self.y / scalar };
    }

    pub inline fn divScalarSingle(self: Vector2x8, scalar: f32) Vector2x8 {
        return .{ .x = self.x / vm.ps(scalar), .y = self.y / vm.ps(scalar) };
    }

    pub inline fn negate(self: Vector2x8) Vector2x8 {
        return .{ .x = -self.x, .y = -self.y };
    }

    pub inline fn abs(self: Vector2x8) Vector2x8 {
        return .{ .x = @abs(self.x), .y = @abs(self.y) };
    }

    pub inline fn floor(self: Vector2x8) Vector2x8 {
        return .{ .x = @floor(self.x), .y = @floor(self.y) };
    }

    pub inline fn ceil(self: Vector2x8) Vector2x8 {
        return .{ .x = @ceil(self.x), .y = @ceil(self.y) };
    }

    pub inline fn round(self: Vector2x8) Vector2x8 {
        return .{ .x = @round(self.x), .y = @round(self.y) };
    }

    pub inline fn min(self: Vector2x8, other: Vector2x8) Vector2x8 {
        return .{ .x = @min(self.x, other.x), .y = @min(self.y, other.y) };
    }

    pub inline fn max(self: Vector2x8, other: Vector2x8) Vector2x8 {
        return .{ .x = @max(self.x, other.x), .y = @max(self.y, other.y) };
    }

    // --- OTHER ---------------------------------------------------------------

    pub inline fn len(self: Vector2x8) vm.f32x8 {
        return @sqrt(self.x * self.x + self.y * self.y);
    }

    pub inline fn lenSquared(self: Vector2x8) vm.f32x8 {
        return self.x * self.x + self.y * self.y;
    }

    pub inline fn dot(self: Vector2x8, other: Vector2x8) vm.f32x8 {
        return self.x * other.x + self.y * other.y;
    }

    pub inline fn cross(self: Vector2x8, other: Vector2x8) vm.f32x8 {
        return self.x * other.y - self.y * other.x;
    }

    pub inline fn lerp(a: Vector2x8, b: Vector2x8, t: vm.f32x8) Vector2x8 {
        return .{
            .x = @mulAdd(vm.f32x8, t, b.x, @mulAdd(vm.f32x8, -t, a.x, a.x)),
            .y = @mulAdd(vm.f32x8, t, b.y, @mulAdd(vm.f32x8, -t, a.y, a.y)),
        };
    }

    pub inline fn lerpSingle(a: Vector2x8, b: Vector2x8, t: f32) Vector2x8 {
        return .{
            .x = @mulAdd(vm.f32x8, vm.ps(t), b.x, @mulAdd(vm.f32x8, -vm.ps(t), a.x, a.x)),
            .y = @mulAdd(vm.f32x8, vm.ps(t), b.y, @mulAdd(vm.f32x8, -vm.ps(t), a.y, a.y)),
        };
    }

    pub inline fn rotate(self: Vector2x8, complex: vm.Complex_x8) Vector2x8 {
        return .{
            .x = self.x * complex.re - self.y * complex.im,
            .y = self.x * complex.im + self.y * complex.re,
        };
    }

    pub inline fn rotateSingle(self: Vector2x8, complex: vm.Complex) Vector2x8 {
        return .{
            .x = self.x * vm.ps(complex.re) - self.y * vm.ps(complex.im),
            .y = self.x * vm.ps(complex.im) + self.y * vm.ps(complex.re),
        };
    }

    pub inline fn transformPoint(self: Vector2x8, m: vm.Matrix3x2x8) Vector2x8 {
        return .{
            .x = self.x * m.ix + self.y * m.jx + m.tx,
            .y = self.x * m.iy + self.y * m.jy + m.ty,
        };
    }

    pub inline fn transformPointSingle(self: Vector2x8, m: vm.Matrix3x2) Vector2x8 {
        return .{
            .x = self.x * vm.ps(m.ix) + self.y * vm.ps(m.jx) + vm.ps(m.tx),
            .y = self.x * vm.ps(m.iy) + self.y * vm.ps(m.jy) + vm.ps(m.ty),
        };
    }

    pub inline fn transformVector(self: Vector2x8, m: vm.Matrix3x2x8) Vector2x8 {
        return .{
            .x = self.x * m.ix + self.y * m.jx,
            .y = self.x * m.iy + self.y * m.jy,
        };
    }

    pub inline fn transformVectorSingle(self: Vector2x8, m: vm.Matrix3x2) Vector2x8 {
        return .{
            .x = self.x * vm.ps(m.ix) + self.y * vm.ps(m.jx),
            .y = self.x * vm.ps(m.iy) + self.y * vm.ps(m.jy),
        };
    }
};