import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';

import { DenoKVBlobService, DenoKVFileService, FileMetaData, FileService } from '../src/services/mod.ts';
import { asyncIterableToArray } from '../src/utils.ts';
import { generateLargeText } from './utils.ts';
import { StringReader } from 'https://deno.land/std@0.191.0/io/mod.ts';

Deno.test('DenoKVBlobService happy path', async (t) => {
    localStorage.clear();
    const kv = await Deno.openKv(':memory:');

    const bs = new DenoKVBlobService(kv, 50);

    function toUint8Array(s: string): Uint8Array {
        return new TextEncoder().encode(s);
    }

    await t.step('read write small text', async () => {
        const size = await bs.persistBlob('0002', toUint8Array('hello world'));
        const content = await bs.readAllBlob('0002');
        assertEquals(content, toUint8Array('hello world'));
        assertEquals(await bs.getNumberOfChunks('0002'), 1);
        assertEquals(size, 'hello world'.length);
    });

    await t.step('read write large text', async () => {
        const largeText = toUint8Array(generateLargeText(33, 100));
        const size = await bs.persistBlob('0001', largeText);
        const content = await bs.readAllBlob('0001');
        assertEquals(content, largeText);
        assertEquals(await bs.getNumberOfChunks('0001'), 21);
        assertEquals(size, largeText.length);
    });

    await t.step('read write large file', async () => {
        const fileName = 'tests/examples/teapot.obj';
        const f = await Deno.open(fileName);
        const size = await bs.persistReader('large-stream', f);

        assertEquals(await bs.getNumberOfChunks('large-stream'), 1030);
        assertEquals((await Deno.readFile(fileName)).length, size);
        f.close();
    });

    kv.close();
});

Deno.test('DenoKVFileService happy path xxx ', async (t) => {
    const kv = await Deno.openKv(':memory:');
    const fs: FileService = new DenoKVFileService(kv);
    const fileName1 = 'didier/file1.txt';
    const fileName2 = 'didier/file2.txt';
    let file1: FileMetaData | undefined;
    let file2: FileMetaData | undefined;

    await t.step('Create 2 files xyzabc', async () => {
        file1 = await fs.createFromFullContent(fileName1, 'bob le chef');
        file2 = await fs.createFromFullContent(fileName2, 'le geant vert ☀️');

        assertEquals(file1.path, fileName1);
        assertEquals(file2.contentSize, 47);
    });

    await t.step('Get file metadata', async () => {
        const ret = await fs.getMetaDataByID(file1!.id);
        assertEquals(ret, file1);
    });

    await t.step('List files', async () => {
        const expected = [file1, file2];
        const ret = await fs.list();
        assertEquals(await asyncIterableToArray(ret), expected);
    });

    await t.step('Get File by path', async () => {
        const ret = await fs.getRawContentByPath(fileName1);
        assertEquals(new TextDecoder().decode(ret!), 'bob le chef');
    });

    await t.step('Get File by Id', async () => {
        const ret = await fs.getRawContentByPath(fileName1);
        assertEquals(new TextDecoder().decode(ret!), 'bob le chef');
    });

    await t.step('Delete File', async () => {
        await fs.deleteByPath(fileName1);
        await fs.deleteByPath('404 not found');
    });

    await t.step('List after delete', async () => {
        const expected = [file2];
        const ret = await fs.list();
        assertEquals(await asyncIterableToArray(ret), expected);
    });

    await t.step('Create File from reader', async () => {
        const newPath = 'boris/streamed-file.txt';

        const ret = await fs.createFromReader(newPath, new StringReader('hello world 18'));
        assertEquals(ret.contentSize, 40);

        const s = await fs.getRawContentByPath(newPath);
        assertEquals(new TextDecoder().decode(s!), 'hello world 18');
    });

    await t.step('Rename file', async () => {
        const newPath = 'boris/file2.txt';
        const ret = await fs.renameById(file2!.id, newPath);
        assertEquals(ret?.path, newPath);

        assertEquals(
            new TextDecoder().decode((await fs.getRawContentByPath(newPath))!),
            'le geant vert ☀️',
        );
    });

    kv.close();
});

Deno.test('DenoKVFileService happy path with byte array', async (t) => {
    const kv = await Deno.openKv(':memory:');
    const fs: FileService = new DenoKVFileService(kv);
    await t.step('Create and read 1 binary file', async () => {
        const inputContent = new Uint8Array([240]);
        const file = await fs.createFromFullContent('hello', inputContent);

        assertEquals(file.path, 'hello');
        assertEquals(file.contentSize, 27);

        const persistedContent = await fs.getRawContentByPath('hello');
        assertEquals(persistedContent, inputContent);
    });

    kv.close();
});