import { expect } from 'vitest';
import { Vector4 } from '../lib/classes/Vector4';
import { Quaternion } from '../lib/classes/Quaternion';
import { LLSDReal } from '../lib/classes/llsd/LLSDReal';
import { LLSDURI } from '../lib/classes/llsd/LLSDURI';
import { Vector3 } from '../lib/classes/Vector3';
import { Vector2 } from '../lib/classes/Vector2';
import { UUID } from '../lib';
import { LLSDInteger } from '../lib/classes/llsd/LLSDInteger';
import { isInt } from 'validator';

function compareObject(path: string, one: unknown, two: unknown, visited = new Set<unknown>())
{
    if (one === null)
    {
        expect(one, path + ' (null)').toBe(two);
        if (two !== null)
        {
            console.error(path + ': Mismatch - One is NULL, two is ' + typeof two);
            return;
        }
        return;
    }
    else if (typeof one === 'string')
    {
        expect(one, path + ' (string)').toBe(two);
        return;
    }
    else if (typeof one === 'number')
    {
        if (isInt(String(one)) && isInt(String(two)))
        {
            expect(one, path + ' (number)').toBe(two);
        }
        else if (isNaN(one))
        {
            expect(isNaN(Number(two)), path + ' (number)').toBeTruthy;
        }
        else
        {
            expect(one, path + ' (number)').toBeCloseTo(Number(two), 6);
        }
    }
    else if (typeof one === 'boolean')
    {
        expect(typeof two, path + ' (Boolean)').toBe('boolean');
        expect(one, path + ' (Boolean)').toBe(two);
    }
    else if (one instanceof Buffer)
    {
        expect(two, path).toBeInstanceOf(Buffer);
        if (two instanceof Buffer)
        {
            expect(one.length, path + ' (Buffer)').toBe(two.length);
            expect(one.toString('base64'), path + ' (Buffer)').toBe(two.toString('base64'));
        }
    }
    else if (one instanceof Date)
    {
        expect(two, path + ' (Date)').toBeInstanceOf(Date);
        if (two instanceof Date)
        {
            if (isNaN(one.getTime()))
            {
                expect(one.getTime(), path + ' (Date)').toBe(two.getTime());
            }
            else
            {
                expect(one.getTime(), path + ' (Date)').toBeGreaterThanOrEqual(two.getTime() - 1);
                expect(one.getTime(), path + ' (Date)').toBeLessThanOrEqual(two.getTime() + 1);
            }
        }
    }
    else if (Array.isArray(one))
    {
        expect(Array.isArray(two), path).toBeTruthy();
        if (Array.isArray(two))
        {
            expect(one.length, path).toBe(two.length);
            for (let x = 0; x < one.length; x++)
            {
                compareObject(path + '[' + String(x) + ']', one[x], two[x], visited);
            }
        }
    }
    else if (one instanceof Map)
    {
        expect(two).toBeInstanceOf(Map);
        if (two instanceof Map)
        {
            for (const k of one.keys())
            {
                const v = one.get(k);
                const v2 = two.get(k);
                compareObject(path + '<' + String(v) + '>', v, v2, visited);
            }
            for (const k of two.keys())
            {
                expect(one.has(k)).toBeTruthy();
            }
        }
    }
    else if (one instanceof LLSDInteger)
    {
        expect(two, path).toBeInstanceOf(LLSDInteger);
        if (two instanceof LLSDInteger)
        {
            expect(one.valueOf(), path + ' (LLSDInteger)').toBe(two.valueOf());
        }
    }
    else if (one instanceof LLSDReal)
    {
        expect(two, path).toBeInstanceOf(LLSDReal);
        if (two instanceof LLSDReal)
        {
            const oneVal = one.valueOf();
            const twoVal = two.valueOf();
            if (isNaN(oneVal))
            {
                expect(isNaN(twoVal), path + ' (LLSDReal)').toBeTruthy();
            }
            else
            {
                expect(oneVal, path + ' (LLSDReal)').toBeCloseTo(twoVal);
            }
        }
    }
    else if (one instanceof LLSDURI)
    {
        expect(two, path).toBeInstanceOf(LLSDURI);
        if (two instanceof LLSDURI)
        {
            expect(one.valueOf(), path + ' (LLSDURI)').toBe(two.valueOf());
        }
    }
    /*else if (one instanceof Matrix4)
    {
        expect(two).toBeInstanceOf(Matrix4);
        if (two instanceof Matrix4)
        {
            const arr1 = one.all();
            const arr2 = two.all();
            expect(arr1.length, path + ' (Matrix4)').toBe(arr2.length);
            for(let x = 0; x < arr1.length; x++)
            {
                if (isNaN(arr1[x]))
                {
                    expect(isNaN(arr2[x]), path + ' (Matrix4)').toBeTruthy();
                }
                else
                {
                    expect(arr1[x], path + ' (Matrix4)').toBeCloseTo(arr2[x], 6);
                }
            }
        }
    }*/
    else if (one instanceof Quaternion)
    {
        expect(two).toBeInstanceOf(Quaternion);
        if (two instanceof Quaternion)
        {
            if (isNaN(one.x))
            {
                expect(isNaN(two.x), path + ' (Quaternion)').toBeTruthy();
            }
            else
            {
                expect(one.x, path + ' (Quaternion)').toBeCloseTo(two.x, 6);
            }
            if (isNaN(one.y))
            {
                expect(isNaN(two.y), path + ' (Quaternion)').toBeTruthy();
            }
            else
            {
                expect(one.y, path + ' (Quaternion)').toBeCloseTo(two.y, 6);
            }
            if (isNaN(one.z))
            {
                expect(isNaN(two.z), path + ' (Quaternion)').toBeTruthy();
            }
            else
            {
                expect(one.z, path + ' (Quaternion)').toBeCloseTo(two.z, 6);
            }
            if (isNaN(one.w))
            {
                expect(isNaN(two.w), path + ' (Quaternion)').toBeTruthy();
            }
            else
            {
                expect(one.w, path + ' (Quaternion)').toBeCloseTo(two.w, 6);
            }
        }
    }
    else if (one instanceof Vector4)
    {
        expect(two).toBeInstanceOf(Vector4);
        if (two instanceof Vector4)
        {
            if (isNaN(one.x))
            {
                expect(isNaN(two.x), path + ' (Vector4)').toBeTruthy();
            }
            else
            {
                expect(one.x, path + ' (Vector4)').toBeCloseTo(two.x, 6);
            }
            if (isNaN(one.y))
            {
                expect(isNaN(two.y), path + ' (Vector4)').toBeTruthy();
            }
            else
            {
                expect(one.y, path + ' (Vector4)').toBeCloseTo(two.y, 6);
            }
            if (isNaN(one.z))
            {
                expect(isNaN(two.z), path + ' (Vector4)').toBeTruthy();
            }
            else
            {
                expect(one.z, path + ' (Vector4)').toBeCloseTo(two.z, 6);
            }
            if (isNaN(one.w))
            {
                expect(isNaN(two.w), path + ' (Vector4)').toBeTruthy();
            }
            else
            {
                expect(one.w, path + ' (Vector4)').toBeCloseTo(two.w, 6);
            }
        }
    }
    else if (one instanceof Vector3)
    {
        expect(two).toBeInstanceOf(Vector3);
        if (two instanceof Vector3)
        {
            if (isNaN(one.x))
            {
                expect(isNaN(two.x), path + ' (Vector3)').toBeTruthy();
            }
            else
            {
                expect(one.x, path + ' (Vector3)').toBeCloseTo(two.x, 6);
            }
            if (isNaN(one.y))
            {
                expect(isNaN(two.y), path + ' (Vector3)').toBeTruthy();
            }
            else
            {
                expect(one.y, path + ' (Vector3)').toBeCloseTo(two.y, 6);
            }
            if (isNaN(one.z))
            {
                expect(isNaN(two.z), path + ' (Vector3)').toBeTruthy();
            }
            else
            {
                expect(one.z, path + ' (Vector3)').toBeCloseTo(two.z, 6);
            }
        }
    }
    else if (one instanceof Vector2)
    {
        expect(two).toBeInstanceOf(Vector2);
        if (two instanceof Vector2)
        {
            if (isNaN(one.x))
            {
                expect(isNaN(two.x), path + ' (Vector2)').toBeTruthy();
            }
            else
            {
                expect(one.x, path + ' (Vector2)').toBeCloseTo(two.x, 6);
            }
            if (isNaN(one.y))
            {
                expect(isNaN(two.y), path + ' (Vector2)').toBeTruthy();
            }
            else
            {
                expect(one.y, path + ' (Vector2)').toBeCloseTo(two.y, 6);
            }
        }
    }
    else if (one instanceof UUID)
    {
        expect(two).toBeInstanceOf(UUID);
        if (two instanceof UUID)
        {
            expect(one.toString(), path + ' (UUID)').toBe(two.toString());
        }
    }
    else if (typeof one === 'object')
    {
        if (visited.has(one))
        {
            return;
        }
        visited.add(one);

        expect(typeof two, path + ' (object)').toBe('object');
        expect(two, path + ' (object)').not.toBeNull();
        if (one.constructor.name !== 'Object' && one.constructor.name !== 'LLMesh' && one.constructor.name !== 'LLSettings')
        {
            throw new Error('Unhandled object ' + one.constructor.name);
        }
        if (typeof two === 'object' && two !== null)
        {
            expect(one.constructor.name, path + ' (object)').toBe(two.constructor.name);

            const keys = Object.keys(one);
            for (const k of keys)
            {
                const subPath = path + '[\'' + k + '\']';
                if ((one as any)[k] !== undefined)
                {
                    expect((two as any)[k], subPath + ' (object)').toBeDefined();
                    compareObject(subPath, (one as any)[k], (two as any)[k], visited);
                }
            }
        }
    }
    else
    {
        throw new Error('Unknown object type: ' + one);
    }
}

export function toDeeplyMatch(received: unknown, expected: unknown)
{
    const visited = new Set<unknown>();

    try
    {
        compareObject('', received, expected, visited);
        return {
            pass: true,
            message: () => `Expected objects to not deeply match, but they did.`,
        };
    }
    catch (error: any)
    {
        return {
            pass: false,
            message: () => error.message || `Objects do not deeply match.`,
        };
    }
}