import { describe, it, expect, beforeEach } from "vitest";
import { MockDb{Entity}Repository } from "@/repositories/mockdb/{entity-name}.mockdb.repository";
import type { Create{Entity}Type } from "@/schemas/{entity-name}.schema";

const userId = "user-1";
const otherUserId = "user-2";

describe("MockDb{Entity}Repository", () => {
  let repo: MockDb{Entity}Repository;

  beforeEach(() => {
    repo = new MockDb{Entity}Repository();
    repo.clear(); // Clean slate for each test
  });

  // Test cases...
});

describe("create", () => {
  it("creates an entity and returns it", async () => {
    const data: Create{Entity}Type = { content: "Test content" };
    const entity = await repo.create(data, userId);

    expect(entity.id).toBeDefined();
    expect(entity.content).toBe("Test content");
    expect(entity.createdBy).toBe(userId);
    expect(entity.createdAt).toBeInstanceOf(Date);
    expect(entity.updatedAt).toBeInstanceOf(Date);
  });
});

describe("findById", () => {
  it("returns entity by id", async () => {
    const created = await repo.create({ content: "Find me" }, userId);
    const found = await repo.findById(created.id);

    expect(found).not.toBeNull();
    expect(found!.id).toBe(created.id);
  });

  it("returns null if not found", async () => {
    const found = await repo.findById("not-exist");
    expect(found).toBeNull();
  });
});

describe("findAll", () => {
  beforeEach(async () => {
    await repo.create({ content: "A" }, userId);
    await repo.create({ content: "B" }, userId);
    await repo.create({ content: "C" }, otherUserId);
  });

  it("returns all entities", async () => {
    const result = await repo.findAll({});
    expect(result.data.length).toBe(3);
  });

  it("filters by createdBy", async () => {
    const result = await repo.findAll({ createdBy: userId });
    expect(result.data.length).toBe(2);
    expect(result.data.every((e) => e.createdBy === userId)).toBe(true);
  });

  it("searches by content", async () => {
    const result = await repo.findAll({ search: "B" });
    expect(result.data.length).toBe(1);
    expect(result.data[0].content).toBe("B");
  });

  it("paginates results", async () => {
    const result = await repo.findAll({ page: 2, limit: 2 });
    expect(result.data.length).toBe(1);
    expect(result.page).toBe(2);
    expect(result.limit).toBe(2);
  });

  it("sorts results", async () => {
    const result = await repo.findAll({ sortBy: "content", sortOrder: "desc" });
    expect(result.data[0].content >= result.data[1].content).toBe(true);
  });
});

describe("update", () => {
  it("updates entity fields", async () => {
    const entity = await repo.create({ content: "Old" }, userId);
    await new Promise((r) => setTimeout(r, 10)); // Ensure updatedAt changes

    const updated = await repo.update(entity.id, { content: "New" });

    expect(updated).not.toBeNull();
    expect(updated!.content).toBe("New");
    expect(updated!.updatedAt).not.toEqual(entity.updatedAt);
  });

  it("returns null if entity does not exist", async () => {
    const updated = await repo.update("not-exist", { content: "X" });
    expect(updated).toBeNull();
  });
});

describe("remove", () => {
  it("deletes entity and returns true", async () => {
    const entity = await repo.create({ content: "Del" }, userId);
    const result = await repo.remove(entity.id);

    expect(result).toBe(true);
    expect(await repo.findById(entity.id)).toBeNull();
  });

  it("returns false if entity does not exist", async () => {
    const result = await repo.remove("not-exist");
    expect(result).toBe(false);
  });
});