import { decompress } from '@cloudpss/zstd';
import { encode, encodeDev } from '../../dist/gql/encode.js';
import { randomFillSync, randomBytes } from 'node:crypto';
import { decode } from '@cloudpss/ubjson';

describe('encode', () => {
    it('encode small', async () => {
        const ret = await encode({ a: 1 });
        expect(ret.contentType).toEqual('application/ubjson+zstd');
        expect(ret.data).toBeInstanceOf(Blob);
        expect(decode(await decompress(ret.data as Blob))).toEqual({ a: 1 });
        expect(ret.rawSize).toBeGreaterThan(0);
        expect(ret.compressedSize).toBe((ret.data as Blob).size);
    });

    it('encode large zstd', async () => {
        const ret = await encode({ a: new Uint8Array(1024) });
        expect(ret.contentType).toEqual('application/ubjson+zstd');
        expect(ret.data).toBeInstanceOf(Blob);
        expect(ret.rawSize).toBeGreaterThan(ret.compressedSize);
        expect(ret.compressedSize).toBe((ret.data as Blob).size);
    });

    it('encode large ubjson', async () => {
        const ret = await encode({ a: randomBytes(1024) });
        expect(ret.contentType).toEqual('application/ubjson+zstd');
        expect(ret.data).toBeInstanceOf(Blob);
        expect(ret.compressedSize).toBeGreaterThan(ret.rawSize);
        expect(ret.compressedSize).toBe((ret.data as Blob).size);
    });

    it('encode huge', async () => {
        const ret = await encode({
            a: Array.from({ length: 128 }, () => randomBytes(1024 * 1024)),
            b: Array.from({ length: 128 }, () => new Uint8Array(1024 * 1024)),
        });
        expect(ret.contentType).toEqual('application/ubjson+zstd');
        expect(ret.data).toBeInstanceOf(Blob);
        expect(ret.rawSize).toBeGreaterThan(ret.compressedSize);
        expect(ret.compressedSize).toBe((ret.data as Blob).size);
    });

    it('encode dev', async () => {
        const ret = await encodeDev({ a: 1 });
        expect(ret.contentType).toEqual('application/json;charset=utf-8');
        expect(ret.data).toBe(JSON.stringify({ a: 1 }));
        expect(ret.rawSize).toBeGreaterThan(0);
        expect(ret.compressedSize).toBeGreaterThan(0);
    });

    it('encode dev force ubjson', async () => {
        const data = new Uint8Array(1024 * 1024 * 5);
        randomFillSync(data);
        const ret = await encodeDev({ a: data });
        expect(ret.contentType).toEqual('application/ubjson+zstd');
        expect(ret.data).toBeInstanceOf(Blob);
        expect(ret.rawSize).toBeGreaterThan(0);
        expect(ret.compressedSize).toBeGreaterThan(ret.rawSize);
    });

    it('encode dev force zstd', async () => {
        const ret = await encodeDev({ a: new Uint8Array(1024 * 1024 * 5) });
        expect(ret.contentType).toEqual('application/ubjson+zstd');
        expect(ret.data).toBeInstanceOf(Blob);
        expect(ret.rawSize).toBeGreaterThan(ret.compressedSize);
        expect(ret.compressedSize).toBeGreaterThan(0);
    });
});