import { assertEquals, assertExists } from "@std/assert";
import { del, find, insert, update } from "utils/db.ts";

const TEST_DB_PATH = "data/test_postdown.db";

function cleanup() {
  try {
    Deno.removeSync(TEST_DB_PATH);
  } catch {
    // File may not exist
  }
}

Deno.test("db - insert and find a User", () => {
  cleanup();
  try {
    const result = insert("User", {
      name: "testuser",
      email: "test@example.com",
      password: "hashedpassword",
    }, TEST_DB_PATH);
    assertEquals(result.length, 1);
    assertExists(result[0]["id"]);

    const found = find(
      "User",
      { email: "test@example.com" },
      ["name", "email"],
      undefined,
      TEST_DB_PATH,
    );
    assertEquals(found.length, 1);
    assertEquals(found[0]["name"], "testuser");
    assertEquals(found[0]["email"], "test@example.com");
  } finally {
    cleanup();
  }
});

Deno.test("db - find with no results returns empty array", () => {
  cleanup();
  try {
    const found = find(
      "User",
      { email: "nonexistent@example.com" },
      ["id"],
      undefined,
      TEST_DB_PATH,
    );
    assertEquals(found.length, 0);
  } finally {
    cleanup();
  }
});

Deno.test("db - find with targetKeys returns only specified columns", () => {
  cleanup();
  try {
    insert("User", {
      name: "testuser",
      email: "test@example.com",
      password: "hashedpassword",
    }, TEST_DB_PATH);

    const found = find(
      "User",
      { email: "test@example.com" },
      ["name"],
      undefined,
      TEST_DB_PATH,
    );
    assertEquals(found.length, 1);
    assertEquals(Object.keys(found[0]).length, 1);
    assertEquals(found[0]["name"], "testuser");
  } finally {
    cleanup();
  }
});

Deno.test("db - find with limit", () => {
  cleanup();
  try {
    insert("User", {
      name: "user1",
      email: "user1@example.com",
      password: "pass1",
    }, TEST_DB_PATH);
    insert("User", {
      name: "user2",
      email: "user2@example.com",
      password: "pass2",
    }, TEST_DB_PATH);

    const found = find("User", { name: "user1" }, ["id"], 1, TEST_DB_PATH);
    assertEquals(found.length, 1);
  } finally {
    cleanup();
  }
});

Deno.test("db - update a User record", () => {
  cleanup();
  try {
    const inserted = insert("User", {
      name: "oldname",
      email: "test@example.com",
      password: "hashedpassword",
    }, TEST_DB_PATH);
    const userId = inserted[0]["id"] as string | number;

    const result = update("User", userId, { name: "newname" }, TEST_DB_PATH);
    assertEquals(result.length, 1);

    const found = find(
      "User",
      { id: userId },
      ["name"],
      undefined,
      TEST_DB_PATH,
    );
    assertEquals(found[0]["name"], "newname");
  } finally {
    cleanup();
  }
});

Deno.test("db - delete a User record", () => {
  cleanup();
  try {
    const inserted = insert("User", {
      name: "deleteme",
      email: "delete@example.com",
      password: "hashedpassword",
    }, TEST_DB_PATH);
    const userId = inserted[0]["id"] as string | number;

    const result = del("User", { id: userId }, TEST_DB_PATH);
    assertEquals(result, true);

    const found = find("User", { id: userId }, ["id"], undefined, TEST_DB_PATH);
    assertEquals(found.length, 0);
  } finally {
    cleanup();
  }
});

Deno.test("db - insert and find a Post", () => {
  cleanup();
  try {
    const result = insert("Post", {
      id: "abc123",
      title: "Test Post",
      content: "# Hello World",
      user_id: 1,
      shared: 0,
    }, TEST_DB_PATH);
    assertEquals(result.length, 1);
    assertEquals(result[0]["id"], "abc123");

    const found = find(
      "Post",
      { id: "abc123" },
      ["title", "content"],
      undefined,
      TEST_DB_PATH,
    );
    assertEquals(found.length, 1);
    assertEquals(found[0]["title"], "Test Post");
    assertEquals(found[0]["content"], "# Hello World");
  } finally {
    cleanup();
  }
});

Deno.test("db - insert and find a Token", () => {
  cleanup();
  try {
    const result = insert("Token", {
      token: "test-token-123",
      user_id: 1,
    }, TEST_DB_PATH);
    assertEquals(result.length, 1);

    const found = find(
      "Token",
      { token: "test-token-123" },
      ["user_id"],
      undefined,
      TEST_DB_PATH,
    );
    assertEquals(found.length, 1);
    assertEquals(found[0]["user_id"], 1);
  } finally {
    cleanup();
  }
});

Deno.test("db - update Post shared status", () => {
  cleanup();
  try {
    insert("Post", {
      id: "share-test",
      title: "Share Test",
      content: "content",
      user_id: 1,
      shared: 0,
    }, TEST_DB_PATH);

    update("Post", "share-test", { shared: 1 }, TEST_DB_PATH);

    const found = find(
      "Post",
      { id: "share-test" },
      ["shared"],
      undefined,
      TEST_DB_PATH,
    );
    assertEquals(found[0]["shared"], 1);
  } finally {
    cleanup();
  }
});

Deno.test("db - del returns true on non-existent record", () => {
  cleanup();
  try {
    const result = del("User", { id: 99999 }, TEST_DB_PATH);
    assertEquals(result, true);
  } finally {
    cleanup();
  }
});

Deno.test("db - insert duplicate name returns empty array", () => {
  cleanup();
  try {
    insert("User", {
      name: "dupuser",
      email: "first@example.com",
      password: "pass1",
    }, TEST_DB_PATH);

    const result = insert("User", {
      name: "dupuser",
      email: "second@example.com",
      password: "pass2",
    }, TEST_DB_PATH);
    assertEquals(result.length, 0);
  } finally {
    cleanup();
  }
});