import { expect, test } from "vitest";

import { ErrorConflict } from "$lib/shared/util/error";

import {
  getCategoryNEntries,
  getEntries,
  getEntry,
  getEntryNExecutions,
  getEntryNVersions,
  getEntryVersions,
  getNTodo,
  getPatientNEntries,
  newEntry,
  newEntryExecution,
  newEntryVersion,
} from "$lib/server/query";

const TEST_VERSION = {
  category_id: 1,
  text: "10ml Blut abnehmen",
  date: "2024-01-01",
  priority: false,
};

async function insertTestEntries() {
  // Create some entries
  const eId1 = await newEntry(1, {
    patient_id: 1,
    version: TEST_VERSION,
  });
  const eId2 = await newEntry(1, {
    patient_id: 2,
    version: {
      text: "Carrot cake jelly-o bonbon toffee chocolate.",
      date: "2024-01-05",
      priority: false,
      category_id: null,
    },
  });
  const eId3 = await newEntry(1, {
    patient_id: 1,
    version: {
      text: "Cheesecake danish donut oat cake caramels.",
      date: "2024-01-06",
      priority: false,
      category_id: null,
    },
  });

  // Update an entry
  await newEntryVersion(2, eId1, {
    category_id: 3,
    text: `${TEST_VERSION.text}\n\n> Hello World`,
    date: "2024-01-01",
    priority: true,
  });

  // Execute entries
  await newEntryExecution(1, eId2, { text: "Some execution txt", done: true });
  await newEntryExecution(2, eId3, { text: "More execution txt", done: true });

  return { eId1, eId2, eId3 };
}

test("create entry", async () => {
  const eId = await newEntry(1, {
    patient_id: 1,
    version: TEST_VERSION,
  });
  expect(eId).gt(0);

  const entry = await getEntry(eId);
  expect(entry.patient.id).toBe(1);
  expect(entry.execution).toBeNull();
  expect(entry.current_version.id).gt(0);
  expect(entry.current_version.category?.id).toBe(TEST_VERSION.category_id);
  expect(entry.current_version.category?.name).toBe("Laborabnahme");
  expect(entry.current_version.text).toBe(TEST_VERSION.text);
  expect(entry.current_version.date).toStrictEqual(TEST_VERSION.date);
  expect(entry.current_version.priority).toBe(TEST_VERSION.priority);

  const nVersions = await getEntryNVersions(eId);
  expect(nVersions).toBe(1);
  const nExecutions = await getEntryNExecutions(eId);
  expect(nExecutions).toBe(0);
});

test("create entry version", async () => {
  const eId = await newEntry(1, {
    patient_id: 1,
    version: TEST_VERSION,
  });
  const text = "10ml Blut abnehmen\n\nPS: Nadel nicht vergessen";
  const date = "2024-01-02";

  const nvId = await newEntryVersion(1, eId, {
    date,
    text,
    category_id: 2,
    priority: true,
  });

  const entry = await getEntry(eId);
  const expectedVersion = {
    id: nvId,
    author: { id: 1 },
    date,
    text,
    category: { id: 2 },
    priority: true,
  };
  expect(entry.current_version).toMatchObject(expectedVersion);

  const history = await getEntryVersions(eId);
  expect(history).length(2);
  expect(history[0]).toMatchObject(expectedVersion);
  expect(history[1].text).toBe(TEST_VERSION.text);
  expect(history[0].created_at).greaterThan(history[1].created_at);

  const nVersions = await getEntryNVersions(eId);
  expect(nVersions).toBe(2);
});

test("create entry version (partial)", async () => {
  const eId = await newEntry(1, {
    patient_id: 1,
    version: TEST_VERSION,
  });
  const oldEntry = await getEntry(eId);
  const text = "10ml Blut abnehmen\n\nPS: Nadel nicht vergessen";

  await newEntryVersion(2, eId, { text }, oldEntry.current_version.id);

  const entry = await getEntry(eId);
  expect(entry.current_version).toMatchObject({
    author: { id: 2 },
    date: oldEntry.current_version.date,
    text,
    category: oldEntry.current_version.category,
    priority: oldEntry.current_version.priority,
  });
});

test("create entry version (wrong old vid)", async () => {
  const eId = await newEntry(1, {
    patient_id: 1,
    version: TEST_VERSION,
  });
  const entry = await getEntry(eId);

  await expect(async () => {
    await newEntryVersion(
      1,
      eId,
      { text: "Hello World" },
      entry.current_version.id + 1,
    );
  }).rejects.toThrowError(new ErrorConflict("old version id does not match"));
});

test("create entry execution", async () => {
  const eId = await newEntry(1, {
    patient_id: 1,
    version: TEST_VERSION,
  });
  const text = "Blutabnahme erledigt.";

  const xId = await newEntryExecution(1, eId, { text, done: true }, null);

  const entry = await getEntry(eId);
  expect(entry.execution?.id).toBe(xId);
  expect(entry.execution?.author.id).toBe(1);
  expect(entry.execution?.text).toBe(text);

  const nExecutions = await getEntryNExecutions(eId);
  expect(nExecutions).toBe(1);
});

test("create entry execution (update)", async () => {
  const eId = await newEntry(1, {
    patient_id: 1,
    version: TEST_VERSION,
  });

  const x1 = await newEntryExecution(1, eId, { text: "x1", done: true }, null);
  const x2 = await newEntryExecution(2, eId, { text: "x2", done: true }, x1);

  const entry = await getEntry(eId);
  expect(entry.execution?.id).toBe(x2);
  expect(entry.execution?.text).toBe("x2");
  expect(entry.execution?.author.id).toBe(2);

  const nExecutions = await getEntryNExecutions(eId);
  expect(nExecutions).toBe(2);
});

test("create entry execution (wrong old xid)", async () => {
  const eId = await newEntry(1, {
    patient_id: 1,
    version: TEST_VERSION,
  });
  const x1 = await newEntryExecution(1, eId, { text: "x1", done: true }, null);

  await expect(async () => newEntryExecution(1, eId, { text: "x2", done: true }, x1 + 1)).rejects.toThrowError(new ErrorConflict("old execution id does not match"));
});

test("get entries", async () => {
  const { eId1, eId2, eId3 } = await insertTestEntries();
  const entries = await getEntries({}, {});
  expect(entries.items).length(3);
  expect(entries.total).toBe(3);

  // Pagination

  const entriesLim2 = await getEntries({}, { limit: 2, offset: 0 });
  expect(entriesLim2.items).length(2);
  expect(entriesLim2.total).toBe(3);

  const entriesLim2Offset = await getEntries({}, { limit: 2, offset: 2 });
  expect(entriesLim2Offset.items).length(1);
  expect(entriesLim2Offset.offset).toBe(2);
  expect(entriesLim2Offset.total).toBe(3);

  // Filter by category
  const entriesCategory = await getEntries({ category: 3 }, {});
  const entriesCategory2 = await getEntries({ category: [3] }, {});
  expect(entriesCategory.items).length(1);
  expect(entriesCategory.total).toBe(1);
  expect(entriesCategory.items[0].id).toBe(eId1);
  expect(entriesCategory2).toStrictEqual(entriesCategory);

  // Filter by author
  const entriesAuthor = await getEntries({ author: 2 }, {});
  expect(entriesAuthor.items).length(1);
  expect(entriesAuthor.total).toBe(1);
  expect(entriesAuthor.items[0].id).toBe(eId1);

  // Filter by executor
  const entriesExecutor = await getEntries({ executor: 1 }, {});
  expect(entriesExecutor.items).length(1);
  expect(entriesExecutor.total).toBe(1);
  expect(entriesExecutor.items[0].id).toBe(eId2);

  // Filter by patient
  const entriesPatient = await getEntries({ patient: 1 }, {});
  expect(entriesPatient.items).length(2);
  expect(entriesPatient.total).toBe(2);
  expect(entriesPatient.items[0].id).toBe(eId1);
  expect(entriesPatient.items[1].id).toBe(eId3);

  // Filter by room
  const entriesRoom = await getEntries({ room: 1 }, {});
  expect(entriesRoom).toStrictEqual(entriesPatient);

  // Filter done
  const entriesDone = await getEntries({ done: true }, {});
  expect(entriesDone.items).length(2);
  expect(entriesDone.total).toBe(2);
  expect(entriesDone.items[0].id).toBe(eId2);
  expect(entriesDone.items[1].id).toBe(eId3);

  // Filter not done
  const entriesNotDone = await getEntries({ done: false }, {});
  expect(entriesNotDone.items).length(1);
  expect(entriesNotDone.total).toBe(1);
  expect(entriesNotDone.items[0].id).toBe(eId1);

  // Filter by priority
  const entriesPrio = await getEntries({ priority: true }, {});
  expect(entriesPrio.items).length(1);
  expect(entriesPrio.total).toBe(1);
  expect(entriesPrio.items[0].id).toBe(eId1);

  // Filter by date range
  const entriesDate = await getEntries({ date: "2024-01-05" });
  expect(entriesDate.items).length(1);
  expect(entriesDate.total).toBe(1);
  expect(entriesDate.items[0].id).toBe(eId2);

  const entriesDateRange = await getEntries({ date: "2024-01-05..2024-01-06" });
  expect(entriesDateRange.items).length(2);
  expect(entriesDateRange.total).toBe(2);
  expect(entriesDateRange.items[0].id).toBe(eId2);
  expect(entriesDateRange.items[1].id).toBe(eId3);

  // Search
  const entriesSearch = await getEntries({ search: "Blu" }, {});
  expect(entriesSearch.items).length(1);
  expect(entriesSearch.total).toBe(1);
  expect(entriesSearch.items[0].id).toBe(eId1);

  // NTodo
  const n = await getNTodo(new Date("2024-01-05"));
  expect(n).toBe(1);

  // Sort by ID
  const entriesSortedId = await getEntries({}, {}, ["id"]);
  const entriesSortedIdDsc = await getEntries({}, {}, ["id:dsc"]);
  expect(entriesSortedId.total).toBe(3);
  expect(entriesSortedIdDsc.total).toBe(3);
  for (let i = 0; i < 3; i++) {
    expect(entriesSortedId.items[i]).toStrictEqual(
      entriesSortedIdDsc.items[entriesSortedIdDsc.items.length - i - 1],
    );
  }

  // Sort by patient and ID
  const entriesSortedPatientId = await getEntries({}, {}, ["patient", "id"]);
  expect(entriesSortedPatientId.items.length).toBe(3);
  expect(entriesSortedPatientId.items[0].id).toBe(eId1);
  expect(entriesSortedPatientId.items[1].id).toBe(eId3);
  expect(entriesSortedPatientId.items[2].id).toBe(eId2);

  const entriesSortedPatientIdDsc = await getEntries({}, {}, ["patient:dsc", "id"]);
  expect(entriesSortedPatientIdDsc.items.length).toBe(3);
  expect(entriesSortedPatientIdDsc.items[0].id).toBe(eId2);
  expect(entriesSortedPatientIdDsc.items[1].id).toBe(eId1);
  expect(entriesSortedPatientIdDsc.items[2].id).toBe(eId3);
});

test("get patient n entries", async () => {
  await insertTestEntries();
  expect(await getPatientNEntries(1)).toBe(2);
});

test("get category n entries", async () => {
  await insertTestEntries();
  expect(await getCategoryNEntries(3)).toBe(1);
});

test("todo execution", async () => {
  const eId = await newEntry(1, {
    patient_id: 1,
    version: TEST_VERSION,
  });

  const n1 = await newEntryExecution(1, eId, { text: "note1", done: false }, null);

  const entry = await getEntry(eId);
  expect(entry.execution?.id).toBe(n1);
  expect(entry.execution?.text).toBe("note1");
  expect(entry.execution?.author.id).toBe(1);
  expect(entry.execution?.done).toBe(false);
});