import { eq } from "drizzle-orm";

import { beforeEach, describe, expect, it } from "bun:test";

import app from "~/index";
import { getTestDb } from "~/libs/test/getTestDb";
import { getTestEnv } from "~/libs/test/getTestEnv";
import { resetTestDb } from "~/libs/test/resetTestDb";
import { server } from "~/mocks";
import { deviceTokensTable, watchStatusTable } from "~/models/schema";

server.listen();

describe("requests the /watch-status route", () => {
  const db = getTestDb();

  beforeEach(async () => {
    await resetTestDb();
  });

  it("saving title, deviceId in db, should succeed", async () => {
    await db
      .insert(deviceTokensTable)
      .values({ deviceId: "123", token: "asd" });

    const res = await app.request(
      "/watch-status",
      {
        method: "POST",
        headers: new Headers({
          "x-anilist-token": "asd",
          "Content-Type": "application/json",
        }),
        body: JSON.stringify({
          deviceId: "123",
          watchStatus: "CURRENT",
          titleId: 10,
        }),
      },
      getTestEnv(),
    );

    expect(res.json()).resolves.toEqual({ success: true });
    expect(res.status).toBe(200);
  });

  it("saving title, deviceId not in db, should fail", async () => {
    const res = await app.request(
      "/watch-status",
      {
        method: "POST",
        headers: new Headers({
          "x-anilist-token": "asd",
          "Content-Type": "application/json",
        }),
        body: JSON.stringify({
          deviceId: "123",
          watchStatus: "CURRENT",
          titleId: 10,
        }),
      },
      getTestEnv(),
    );

    expect(res.json()).resolves.toEqual({ success: false });
    expect(res.status).toBe(500);
  });

  it("saving title, Anilist request fails, should succeed", async () => {
    await db
      .insert(deviceTokensTable)
      .values({ deviceId: "123", token: "asd" });

    const res = await app.request(
      "/watch-status",
      {
        method: "POST",
        headers: new Headers({
          "x-anilist-token": "asd",
          "Content-Type": "application/json",
        }),
        body: JSON.stringify({
          deviceId: "123",
          watchStatus: "CURRENT",
          titleId: -1,
        }),
      },
      getTestEnv(),
    );

    expect(res.json()).resolves.toEqual({ success: true });
    expect(res.status).toBe(200);
  });

  it("watch status is null, should succeed", async () => {
    await db
      .insert(deviceTokensTable)
      .values({ deviceId: "123", token: "asd" });

    const res = await app.request(
      "/watch-status",
      {
        method: "POST",
        headers: new Headers({
          "x-anilist-token": "asd",
          "Content-Type": "application/json",
        }),
        body: JSON.stringify({
          deviceId: "123",
          watchStatus: null,
          titleId: 10,
        }),
      },
      getTestEnv(),
    );

    expect(res.json()).resolves.toEqual({ success: true });
    expect(res.status).toBe(200);
  });

  it("watch status is null, title does not exist, should succeed", async () => {
    await db
      .insert(deviceTokensTable)
      .values({ deviceId: "123", token: "asd" });

    const res = await app.request(
      "/watch-status",
      {
        method: "POST",
        headers: new Headers({
          "x-anilist-token": "asd",
          "Content-Type": "application/json",
        }),
        body: JSON.stringify({
          deviceId: "123",
          watchStatus: null,
          titleId: -1,
        }),
      },
      getTestEnv(),
    );

    expect(res.json()).resolves.toEqual({ success: true });
    expect(res.status).toBe(200);
  });

  it("watch status is null, title exists, fails to delete entry, should succeed", async () => {
    await db
      .insert(deviceTokensTable)
      .values({ deviceId: "123", token: "asd" });

    const res = await app.request(
      "/watch-status",
      {
        method: "POST",
        headers: new Headers({
          "x-anilist-token": "asd",
          "Content-Type": "application/json",
        }),
        body: JSON.stringify({
          deviceId: "123",
          watchStatus: null,
          titleId: 139518,
        }),
      },
      getTestEnv(),
    );

    expect(res.json()).resolves.toEqual({ success: true });
    expect(res.status).toBe(200);
  });

  it("watch status is null, should delete entry", async () => {
    await db
      .insert(deviceTokensTable)
      .values({ deviceId: "123", token: "asd" });
    await db.insert(watchStatusTable).values({ deviceId: "123", titleId: 10 });

    await app.request(
      "/watch-status",
      {
        method: "POST",
        headers: new Headers({
          "x-anilist-token": "asd",
          "Content-Type": "application/json",
        }),
        body: JSON.stringify({
          deviceId: "123",
          watchStatus: null,
          titleId: 10,
        }),
      },
      getTestEnv(),
    );
    const row = await db
      .select()
      .from(watchStatusTable)
      .where(eq(watchStatusTable.titleId, 10))
      .get();

    expect(row).toBeUndefined();
  });
});