/**
 * End-to-end test: @storyblok/schema define functions → MAPI round-trip
 *
 * Validates that:
 *  1. Every major MAPI define function produces a valid creation payload.
 *  2. The MAPI accepts those payloads and creates real resources.
 *  3. The types returned by the schema-aware mapi-client match the actual
 *     runtime data returned by the API (no type lies).
 *  4. Zod schemas generated from the OpenAPI spec accept real API responses.
 *
 * Run manually (never in CI):
 *   pnpm --filter @storyblok/mapi-integration-tests test:e2e
 *
 * Requires .env.qa-engineer-manual at the repo root with:
 *   STORYBLOK_TOKEN=<personal-access-token>
 *   STORYBLOK_SPACE_ID=<numeric-space-id>
 */

import { afterAll, beforeAll, describe, expect, it } from "vitest";
import { createManagementApiClient } from "@storyblok/management-api-client";
import type { StoryCreate, StoryUpdate } from "@storyblok/management-api-client";
import { defineBlock, defineField } from "@storyblok/schema";

const token = process.env.STORYBLOK_TOKEN!;
const spaceId = Number(process.env.STORYBLOK_SPACE_ID!);

const PREFIX = "e2e_schema_";
const STORY_SLUG_PREFIX = "e2e-schema-";

const DATASOURCE_SLUG = "e2e-schema-categories";
const DATASOURCE_NAME = `${PREFIX}categories`;
const STORY_NAME = "E2E Schema Test Page";
const STORY_SLUG = `${STORY_SLUG_PREFIX}test-page`;

const teaserComponent = defineBlock({
  name: `${PREFIX}teaser`,
  fields: [
    defineField("title", { type: "text", required: true }),
    defineField("image", { type: "asset" }),
  ],
});
// Level-2 container: holds teasers in its `items` bloks field (level 3)
const sectionComponent = defineBlock({
  name: `${PREFIX}section`,
  fields: [
    defineField("title", { type: "text" }),
    defineField("items", { type: "bloks", allow: [teaserComponent.name], required: true }),
  ],
});
const pageComponent = defineBlock({
  name: `${PREFIX}page`,
  is_root: true,
  fields: [
    defineField("headline", { type: "text", required: true }),
    defineField("rating", { type: "number" }),
    defineField("is_featured", { type: "boolean" }),
    defineField("description", { type: "richtext" }),
    defineField("body", {
      type: "bloks",
      allow: [teaserComponent.name, sectionComponent.name],
      required: true,
    }),
    defineField("category", { type: "option", source: "internal", datasource: DATASOURCE_SLUG }),
    defineField("any_blocks", { type: "bloks", required: true }),
  ],
});

interface StoryblokTypes {
  components: typeof pageComponent | typeof teaserComponent | typeof sectionComponent;
}

type Blocks = StoryblokTypes["components"];

const client = createManagementApiClient({
  personalAccessToken: token,
  spaceId,
  throwOnError: true,
}).withTypes<StoryblokTypes>();

async function cleanup() {
  // Stories
  const storiesRes = await client.stories.list({ query: { per_page: 100 } });
  for (const story of storiesRes.data?.stories ?? []) {
    if (story.slug?.startsWith(STORY_SLUG_PREFIX) && story.id) {
      await client.stories.delete(story.id);
    }
  }

  // Presets
  const presetsRes = await client.presets.list();
  for (const preset of presetsRes.data?.presets ?? []) {
    if (preset.name?.startsWith(PREFIX) && preset.id) {
      await client.presets.delete(preset.id);
    }
  }

  // Internal tags
  const tagsRes = await client.internalTags.list();
  for (const tag of tagsRes.data?.internal_tags ?? []) {
    if (tag.name?.startsWith(PREFIX) && tag.id) {
      await client.internalTags.delete(tag.id);
    }
  }

  // Components
  const compsRes = await client.components.list();
  for (const comp of compsRes.data?.components ?? []) {
    if (comp.name?.startsWith(PREFIX) && comp.id) {
      await client.components.delete(comp.id);
    }
  }

  // Component folders
  const foldersRes = await client.componentFolders.list();
  for (const folder of foldersRes.data?.component_groups ?? []) {
    if (folder.name?.startsWith(PREFIX) && folder.id) {
      await client.componentFolders.delete(folder.id);
    }
  }

  // Datasource entries, then datasources
  const dsRes = await client.datasources.list();
  for (const ds of dsRes.data?.datasources ?? []) {
    if (ds.name?.startsWith(PREFIX) && ds.id) {
      const entriesRes = await client.datasourceEntries.list({
        query: { datasource_id: ds.id, per_page: 100 },
      });
      for (const entry of entriesRes.data?.datasource_entries ?? []) {
        if (entry.id) {
          await client.datasourceEntries.delete(entry.id);
        }
      }
      await client.datasources.delete(ds.id);
    }
  }
}

describe("schema + mapi-client MAPI round-trip", () => {
  let pageComponentId: number;
  let teaserComponentId: number;
  let sectionComponentId: number;
  let componentFolderId: number;
  let datasourceId: number;
  let internalTagId: number;
  let presetId: number;
  let storyId: number;

  beforeAll(async () => {
    await cleanup();

    // 1. Datasource + entries first — the page component schema references the datasource slug,
    //    and the MAPI validates that the datasource exists at component creation time.
    // Create payloads are plain MAPI wire objects validated by the typed client.
    const dsRes = await client.datasources.create({
      body: {
        datasource: {
          name: DATASOURCE_NAME,
          slug: DATASOURCE_SLUG,
        },
      },
    });
    datasourceId = dsRes.data!.datasource!.id!;

    for (const entry of [
      { name: "Technology", value: "tech", datasource_id: datasourceId },
      { name: "Design", value: "design", datasource_id: datasourceId },
      { name: "Business", value: "business", datasource_id: datasourceId },
    ]) {
      await client.datasourceEntries.create({ body: { datasource_entry: entry } });
    }

    // 2. Component folder
    const folderRes = await client.componentFolders.create({
      body: { component_group: { name: `${PREFIX}folder` } },
    });
    componentFolderId = folderRes.data!.component_group!.id!;
    const folderUuid = folderRes.data!.component_group!.uuid;

    // 3. Teaser component (innermost — whitelisted by section)
    const teaserRes = await client.components.create({
      body: {
        component: {
          name: teaserComponent.name,
          schema: {
            title: { type: "text", required: true, pos: 0 },
            image: { type: "asset", pos: 1 },
          },
          component_group_uuid: folderUuid,
        },
      },
    });
    teaserComponentId = teaserRes.data!.component!.id!;

    // 4. Section component (level 2 — whitelists teaser, whitelisted by page)
    const sectionRes = await client.components.create({
      body: {
        component: {
          name: sectionComponent.name,
          schema: {
            title: { type: "text", pos: 0 },
            items: { type: "bloks", component_whitelist: [teaserComponent.name], pos: 1 },
          },
          component_group_uuid: folderUuid,
        },
      },
    });
    sectionComponentId = sectionRes.data!.component!.id!;

    // 5. Page component (level 1 — whitelists both teaser and section in body)
    const pageRes = await client.components.create({
      body: {
        component: {
          name: pageComponent.name,
          schema: {
            headline: { type: "text", required: true, pos: 0 },
            rating: { type: "number", pos: 1 },
            is_featured: { type: "boolean", pos: 2 },
            description: { type: "richtext", pos: 3 },
            body: {
              type: "bloks",
              component_whitelist: [teaserComponent.name, sectionComponent.name],
              pos: 4,
            },
            category: {
              type: "option",
              source: "internal",
              datasource_slug: DATASOURCE_SLUG,
              pos: 5,
            },
            any_blocks: { type: "bloks", pos: 6 },
          },
          component_group_uuid: folderUuid,
          is_root: true,
        },
      },
    });
    pageComponentId = pageRes.data!.component!.id!;

    // 5. Internal tag
    const tagRes = await client.internalTags.create({
      body: { internal_tag: { name: `${PREFIX}tag`, object_type: "component" } },
    });
    internalTagId = tagRes.data!.internal_tag!.id!;

    // 6. Preset for page component
    const presetRes = await client.presets.create({
      body: {
        preset: {
          name: `${PREFIX}default_page`,
          component_id: pageComponentId,
          preset: { headline: "Default Headline", rating: 0, is_featured: false },
          description: `Default preset for ${pageComponent.name}`,
        },
      },
    });
    presetId = presetRes.data!.preset!.id!;

    // 8. Story: body[0]=teaser (level 2), body[1]=section{items:[teaser]} (levels 2+3)
    const storyPayload: StoryCreate<Blocks> = {
      name: STORY_NAME,
      slug: STORY_SLUG,
      content: {
        component: pageComponent.name,
        headline: "Hello from e2e",
        rating: "42",
        is_featured: true,
        description: {
          type: "doc",
          content: [{ type: "paragraph", content: [{ type: "text", text: "Rich text body." }] }],
        },
        body: [
          {
            component: teaserComponent.name,
            title: "Teaser Title",
          },
          {
            component: sectionComponent.name,
            title: "Section Title",
            items: [
              {
                component: teaserComponent.name,
                title: "Nested Teaser Title",
              },
            ],
          },
        ],
        category: "tech",
        any_blocks: [
          {
            component: teaserComponent.name,
            title: "Any Block Teaser",
          },
        ],
      },
    };
    const storyRes = await client.stories.create({ body: { story: storyPayload } });
    storyId = storyRes.data!.story!.id!;
  });

  afterAll(cleanup);

  describe("components", () => {
    it("should create page component with the correct name and schema keys", async () => {
      const res = await client.components.get(pageComponentId);
      const comp = res.data?.component;

      expect(comp).toBeDefined();
      expect(comp?.name).toBe(pageComponent.name);
      expect(comp?.schema).toMatchObject({
        headline: expect.objectContaining({ type: "text" }),
        rating: expect.objectContaining({ type: "number" }),
        is_featured: expect.objectContaining({ type: "boolean" }),
        description: expect.objectContaining({ type: "richtext" }),
        body: expect.objectContaining({ type: "bloks" }),
        category: expect.objectContaining({ type: "option" }),
      });
      expect(comp?.name).toBe(pageComponent.name);
    });

    it("should create teaser component with the correct schema", async () => {
      const res = await client.components.get(teaserComponentId);
      const comp = res.data?.component;

      expect(comp?.name).toBe(teaserComponent.name);
      expect(comp?.schema).toMatchObject({
        title: expect.objectContaining({ type: "text", required: true }),
        image: expect.objectContaining({ type: "asset" }),
      });
    });

    it("should create section component with the correct schema", async () => {
      const res = await client.components.get(sectionComponentId);
      const comp = res.data?.component;

      expect(comp?.name).toBe(sectionComponent.name);
      expect(comp?.schema).toMatchObject({
        title: expect.objectContaining({ type: "text" }),
        items: expect.objectContaining({
          type: "bloks",
          component_whitelist: [teaserComponent.name],
        }),
      });
    });

    it("should assign components to the correct component folder", async () => {
      const folderRes = await client.componentFolders.get(componentFolderId);
      const folder = folderRes.data?.component_group;

      const pageRes = await client.components.get(pageComponentId);
      const comp = pageRes.data?.component;

      expect(folder?.name).toBe(`${PREFIX}folder`);
      expect(comp?.component_group_uuid).toBe(folder?.uuid);
    });
  });

  describe("datasources", () => {
    it("should create datasource with the correct name and slug", async () => {
      const res = await client.datasources.list();
      const ds = res.data?.datasources?.find((d) => d.id === datasourceId);

      expect(ds).toBeDefined();
      expect(ds?.name).toBe(DATASOURCE_NAME);
      expect(ds?.slug).toBe(DATASOURCE_SLUG);
    });

    it("should create datasource entries with the correct names and values", async () => {
      const res = await client.datasourceEntries.list({
        query: { datasource_id: datasourceId, per_page: 100 },
      });
      const entries = res.data?.datasource_entries ?? [];

      expect(entries.length).toBeGreaterThanOrEqual(3);
      expect(entries.find((e) => e.value === "tech")?.name).toBe("Technology");
      expect(entries.find((e) => e.value === "design")?.name).toBe("Design");
      expect(entries.find((e) => e.value === "business")?.name).toBe("Business");
    });
  });

  describe("internalTags", () => {
    it("should create and retrieve internal tag", async () => {
      const res = await client.internalTags.list();
      const tag = res.data?.internal_tags?.find((t) => t.id === internalTagId);

      expect(tag).toBeDefined();
      expect(tag?.name).toBe(`${PREFIX}tag`);
      expect(tag?.object_type).toBe("component");
    });
  });

  describe("presets", () => {
    it("should create preset with the correct component_id and default values", async () => {
      const res = await client.presets.get(presetId);
      const preset = res.data?.preset;

      expect(preset).toBeDefined();
      expect(preset?.name).toBe(`${PREFIX}default_page`);
      expect(preset?.component_id).toBe(pageComponentId);
      expect(preset?.preset).toMatchObject({
        headline: "Default Headline",
        rating: 0,
        is_featured: false,
      });
    });
  });

  describe("stories", () => {
    it("should match defined schema field types at runtime for story content", async () => {
      const res = await client.stories.get(storyId);
      const story = res.data?.story;

      expect(story).toBeDefined();
      expect(story?.name).toBe(STORY_NAME);
      expect(story?.slug).toBe(STORY_SLUG);

      // TypeScript narrows story.content to the pageComponent branch here.
      // Accessing story.content.headline etc. only compiles when the component guard passes,
      // so this block validates both runtime correctness and compile-time type narrowing.
      if (story?.content?.component === pageComponent.name) {
        expect(typeof story.content.headline).toBe("string");
        expect(story.content.headline).toBe("Hello from e2e");

        expect(typeof story.content.rating).toBe("number");
        expect(story.content.rating).toBe(42);

        expect(typeof story.content.is_featured).toBe("boolean");
        expect(story.content.is_featured).toBe(true);

        expect(story.content.description).toMatchObject({ type: "doc" });

        expect(Array.isArray(story.content.body)).toBe(true);
        expect(story.content.body.length).toBeGreaterThan(0);

        expect(typeof story.content.category).toBe("string");
        expect(story.content.category).toBe("tech");
      } else {
        throw new Error(
          `Expected story.content.component to be '${pageComponent.name}', got '${story?.content?.component}'`,
        );
      }
    });

    it("should have correct structure for nested teaser blok (two levels: page → teaser)", async () => {
      const res = await client.stories.get(storyId);
      const story = res.data?.story;

      if (story?.content?.component !== pageComponent.name) {
        throw new Error("Unexpected component discriminant");
      }

      const teaser = story.content.body[0];

      expect(teaser).toBeDefined();
      expect(teaser?.component).toBe(teaserComponent.name);
      expect(typeof teaser?.title).toBe("string");
      expect(teaser?.title).toBe("Teaser Title");
    });

    it("should resolve correct types for three-level nested blok (page → section → teaser)", async () => {
      const res = await client.stories.get(storyId);
      const story = res.data?.story;

      if (story?.content?.component !== pageComponent.name) {
        throw new Error("Unexpected component discriminant at level 1");
      }

      // Level 2: narrow body[1] to section
      const section = story.content.body[1];
      if (section?.component === sectionComponent.name) {
        expect(typeof section.title).toBe("string");
        expect(section.title).toBe("Section Title");
        expect(Array.isArray(section.items)).toBe(true);
        expect(section.items.length).toBeGreaterThan(0);

        // Level 3: section.items[0] is a typed teaser — not `never`
        const nestedTeaser = section.items[0];
        if (nestedTeaser?.component === teaserComponent.name) {
          expect(typeof nestedTeaser.title).toBe("string");
          expect(nestedTeaser.title).toBe("Nested Teaser Title");
        } else {
          throw new Error(
            `Expected items[0].component to be '${teaserComponent.name}', got '${nestedTeaser?.component}'`,
          );
        }
      } else {
        throw new Error(
          `Expected body[1].component to be '${sectionComponent.name}', got '${section?.component}'`,
        );
      }
    });

    it("should resolve all schema component types for bloks field without whitelist", async () => {
      const res = await client.stories.get(storyId);
      const story = res.data?.story;

      if (story?.content?.component !== pageComponent.name) {
        throw new Error("Unexpected component discriminant");
      }

      // any_blocks has no component_whitelist — TypeScript resolves items to the full
      // schema union (page | teaser | section), not `never` and not a generic block
      // with only component: string. Accessing blok.title after narrowing to the
      // teaser discriminant proves the discriminated union is correctly typed.
      const blok = story.content.any_blocks[0];
      if (blok?.component === teaserComponent.name) {
        expect(typeof blok.title).toBe("string");
        expect(blok.title).toBe("Any Block Teaser");
      } else {
        throw new Error(
          `Expected any_blocks[0].component to be '${teaserComponent.name}', got '${blok?.component}'`,
        );
      }
    });

    it("should round-trip story update correctly", async () => {
      const updatedPayload: StoryUpdate<Blocks> = {
        name: `${STORY_NAME} (Updated)`,
        slug: STORY_SLUG,
        content: {
          component: pageComponent.name,
          headline: "Updated headline",
          rating: "100",
          is_featured: false,
          description: {
            type: "doc",
            content: [{ type: "paragraph", content: [{ type: "text", text: "Updated." }] }],
          },
          body: [],
          category: "design",
          any_blocks: [],
        },
      };

      await client.stories.update(storyId, { body: { story: updatedPayload } });

      const res = await client.stories.get(storyId);
      const story = res.data?.story;

      if (story?.content?.component !== pageComponent.name) {
        throw new Error("Unexpected component discriminant after update");
      }

      expect(story.content.headline).toBe("Updated headline");
      expect(story.content.rating).toBe(100);
      expect(story.content.is_featured).toBe(false);
      expect(story.content.category).toBe("design");
    });
  });
});