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

import {
  DenoKVBlobService,
  DenoKVFileService,
  FileMetaData,
  FileService,
} from "../src/fileservice.ts";
import { asyncIterableToArray } from "../src/utils.ts";
import { generateLargeText } from "./utils.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 body = await bs.readAllBlob("0002");
    assertEquals(body, toUint8Array("hello world"));
    assertEquals(await bs.getNumberOfBlobs("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 body = await bs.readAllBlob("0001");
    assertEquals(body, largeText);
    assertEquals(await bs.getNumberOfBlobs("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.getNumberOfBlobs("large-stream"), 1030);
    assertEquals((await Deno.readFile(fileName)).length, size);
    f.close();
  });

  kv.close();
});

Deno.test("DenoKVFileService happy path", 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.createFromFullBody(fileName1, "bob le chef");
    file2 = await fs.createFromFullBody(fileName2, "le geant vert ☀️");

    assertEquals(file1.path, fileName1);
    assertEquals(file2.bodySize, 20);
  });

  await t.step("Get file metadata", async () => {
    const ret = await fs.getMetaDataByID(file1?.id ?? "404");
    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 () => {
    assertEquals(await fs.getFullBodyByPath(fileName1), "bob le chef");
  });

  await t.step("Get File by Id", async () => {
    assertEquals(await fs.getFullBodyByPath(fileName1), "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 file = await Deno.open('tests/examples/teapot.obj');

    const ret = await fs.createFromReader(newPath, file);
    assertEquals(ret.bodySize, 51493);
    file.close();
  });

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

    assertEquals(
      await fs.getFullBodyByPath(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 inputBody = new Uint8Array([240]);
    const file = await fs.createFromFullBody("hello", inputBody);

    assertEquals(file.path, "hello");
    assertEquals(file.bodySize, inputBody.length);

    const bodyString = await fs.getFullBodyByPath("hello");
    assertEquals(bodyString, new TextDecoder().decode(inputBody));
  });

  kv.close();
});