import { assertEquals, assertExists } from "@std/assert";
import { getFetchCalls, mockFetch, restoreFetch } from "../helpers/api_mock.ts";
import { createMockDb } from "../helpers/db_mock.ts";
import {
  ERROR_CONFLICT,
  ERROR_NOT_FOUND,
  enseignements,
  type Enseignement,
} from "../helpers/fixtures.ts";

Deno.test("enseignements - POST 201 creates new enseignement", async () => {
  const newEnseignement: Enseignement = {
    idProf: 1,
    idModule: "JIN705C",
    idPromo: "4AFISE25/26",
  };

  mockFetch({
    "/enseignements": {
      method: "POST",
      status: 201,
      body: newEnseignement,
    },
  });

  try {
    const res = await fetch("http://localhost/api/enseignements", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(newEnseignement),
    });
    assertEquals(res.status, 201);
    const data = await res.json();
    assertEquals(data.idProf, 1);
    assertEquals(data.idModule, "JIN705C");
    assertEquals(data.idPromo, "4AFISE25/26");
  } finally {
    restoreFetch();
  }
});

Deno.test("enseignements - POST 409 conflict on duplicate", async () => {
  mockFetch({
    "/enseignements": {
      method: "POST",
      status: 409,
      body: ERROR_CONFLICT,
    },
  });

  try {
    const res = await fetch("http://localhost/api/enseignements", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        idProf: 1,
        idModule: "JIN702C",
        idPromo: "4AFISE25/26",
      }),
    });
    assertEquals(res.status, 409);
    const data = await res.json();
    assertEquals(data.error, "Ressource déjà existante");
  } finally {
    restoreFetch();
  }
});

Deno.test(
  "enseignements - GET 200 returns enseignement by composite key",
  async () => {
    const enseignement = enseignements[0];
    const path = "/enseignements/1/JIN702C/4AFISE25%2F26";

    mockFetch({
      [path]: {
        status: 200,
        body: enseignement,
      },
    });

    try {
      const res = await fetch(
        "http://localhost/api/enseignements/1/JIN702C/4AFISE25%2F26",
      );
      assertEquals(res.status, 200);
      const data = await res.json();
      assertEquals(data.idProf, 1);
      assertEquals(data.idModule, "JIN702C");
      assertEquals(data.idPromo, "4AFISE25/26");
    } finally {
      restoreFetch();
    }
  },
);

Deno.test("enseignements - GET 404 when enseignement not found", async () => {
  mockFetch({
    "/enseignements/999/JIN999/UNKNOWN": {
      status: 404,
      body: ERROR_NOT_FOUND,
    },
  });

  try {
    const res = await fetch(
      "http://localhost/api/enseignements/999/JIN999/UNKNOWN",
    );
    assertEquals(res.status, 404);
    const data = await res.json();
    assertEquals(data.error, "Ressource introuvable");
  } finally {
    restoreFetch();
  }
});

Deno.test("enseignements - DELETE 204 removes enseignement", async () => {
  const path = "/enseignements/1/JIN702C/4AFISE25%2F26";

  mockFetch({
    [path]: {
      method: "DELETE",
      status: 204,
    },
  });

  try {
    const res = await fetch(
      "http://localhost/api/enseignements/1/JIN702C/4AFISE25%2F26",
      {
        method: "DELETE",
      },
    );
    assertEquals(res.status, 204);
    assertEquals(res.body, null);
  } finally {
    restoreFetch();
  }
});

Deno.test(
  "enseignements - DELETE 404 when enseignement not found",
  async () => {
    mockFetch({
      "/enseignements/999/JIN999/UNKNOWN": {
        method: "DELETE",
        status: 404,
        body: ERROR_NOT_FOUND,
      },
    });

    try {
      const res = await fetch(
        "http://localhost/api/enseignements/999/JIN999/UNKNOWN",
        {
          method: "DELETE",
        },
      );
      assertEquals(res.status, 404);
      const data = await res.json();
      assertEquals(data.error, "Ressource introuvable");
    } finally {
      restoreFetch();
    }
  },
);

Deno.test("enseignements - mockDb operations", () => {
  const db = createMockDb({ tables: { enseignements: [...enseignements] } });

  // Test findOne
  const found = db.findOne<Enseignement>(
    "enseignements",
    (r) =>
      r.idProf === 1 && r.idModule === "JIN702C" && r.idPromo === "4AFISE25/26",
  );
  assertExists(found);
  assertEquals(found.idProf, 1);

  // Test insert
  const newEnseignement: Enseignement = {
    idProf: 3,
    idModule: "JIN705C",
    idPromo: "4AFISE25/26",
  };
  db.insert("enseignements", newEnseignement);
  assertEquals(db.getTable("enseignements").length, 4);

  // Test deleteWhere
  const deleted = db.deleteWhere<Enseignement>(
    "enseignements",
    (r) =>
      r.idProf === 1 && r.idModule === "JIN702C" && r.idPromo === "4AFISE25/26",
  );
  assertEquals(deleted, 1);
  assertEquals(db.getTable("enseignements").length, 3);
});