import { it, expect, beforeEach, describe } from "vitest";
import { defineContractSuite } from "@repo/core-testing/contract";
import type { IPagesRepository } from "../application/repositories/pages.repository.interface.js";
import type { Page } from "../entities/models/page.js";

const SEED_DATE = new Date("2026-01-01T00:00:00.000Z");

/**
 * Known fixtures that every implementation's `buildSubject` must pre-seed.
 * Exported so that test files can pass them to `MockPagesRepository` or the
 * Payload stub without duplicating definitions.
 */
export const CONTRACT_PAGES_SEED: Page[] = [
  {
    id: "cp-1",
    title: "About",
    slug: "about",
    hero: { heading: "About us" },
    layout: [],
    status: "published",
    publishedAt: SEED_DATE,
    seo: { title: "About — Site" },
    createdAt: SEED_DATE,
    updatedAt: SEED_DATE,
  },
  {
    id: "cp-2",
    title: "Draft Page",
    slug: "draft-page",
    hero: { heading: "Draft" },
    layout: [],
    status: "draft",
    publishedAt: null,
    seo: { title: "Draft — Site" },
    createdAt: SEED_DATE,
    updatedAt: SEED_DATE,
  },
];

/**
 * Contract for IPagesRepository.
 *
 * IPagesRepository is read-only (no createPage). Each `buildSubject`
 * must return a repo pre-loaded with CONTRACT_PAGES_SEED (two pages:
 * one published with slug "about", one draft with slug "draft-page").
 */
export const pagesRepositoryContract =
  defineContractSuite<IPagesRepository>(
    "IPagesRepository",
    ({ buildSubject, getTracer }) => {
      let repo: IPagesRepository;

      beforeEach(async () => {
        repo = await buildSubject();
      });

      // --- getPageBySlug ---

      it("getPageBySlug returns the published page by slug", async () => {
        const result = await repo.getPageBySlug("about");
        expect(result).toBeDefined();
        expect(result?.slug).toBe("about");
        expect(result?.status).toBe("published");
        expect(result?.id).toBeDefined();
      });

      it("getPageBySlug returns undefined for an unknown slug", async () => {
        expect(await repo.getPageBySlug("no-such-page")).toBeUndefined();
      });

      // --- getPages ---

      it("getPages with no filter returns all seeded pages", async () => {
        const list = await repo.getPages();
        expect(list).toHaveLength(2);
        for (const page of list) {
          expect(page.id).toBeDefined();
          expect(page.slug).toBeDefined();
          expect(["draft", "published"]).toContain(page.status);
        }
      });

      it("getPages({ status: 'published' }) returns only published pages", async () => {
        const published = await repo.getPages({ status: "published" });
        expect(published).toHaveLength(1);
        for (const page of published) {
          expect(page.status).toBe("published");
        }
      });

      it("getPages({ status: 'draft' }) returns only draft pages", async () => {
        const drafts = await repo.getPages({ status: "draft" });
        expect(drafts).toHaveLength(1);
        for (const page of drafts) {
          expect(page.status).toBe("draft");
        }
      });

      describe("span emission (R50)", () => {
        it("getPageBySlug emits pages.getPageBySlug span with slug attribute", async () => {
          if (!getTracer) return;
          const tracer = getTracer();
          tracer.reset();
          await repo.getPageBySlug("about");
          const span = tracer.findSpan("pages.getPageBySlug");
          expect(span).toBeDefined();
          expect(span!.op).toBe("repository");
          expect(span!.attributes.slug).toBe("about");
        });

        it("getPages emits pages.getPages span with op=repository", async () => {
          if (!getTracer) return;
          const tracer = getTracer();
          tracer.reset();
          await repo.getPages({ status: "published" });
          const span = tracer.findSpan("pages.getPages");
          expect(span).toBeDefined();
          expect(span!.op).toBe("repository");
          expect(span!.attributes.status).toBe("published");
        });
      });
    },
  );
