import { existsSync, readFileSync } from "node:fs";
import { join } from "node:path";
import { describe, expect, test } from "vitest";

const root = existsSync(join(process.cwd(), "turbo.json"))
  ? process.cwd()
  : join(process.cwd(), "..", "..");

describe("workspace boundaries", () => {
  test("declares the root as a turbo-managed bun workspace", () => {
    const packageJson = JSON.parse(
      readFileSync(join(root, "package.json"), "utf8"),
    ) as {
      private?: boolean;
      scripts?: Record<string, string>;
      workspaces?: string[];
    };

    expect(packageJson.private).toBe(true);
    expect(packageJson.workspaces).toEqual(["apps/*", "packages/*"]);
    expect(packageJson.scripts?.build).toBe("turbo run build");
    expect(existsSync(join(root, "turbo.json"))).toBe(true);
  });

  test("keeps release orchestration in the root turbo task graph", () => {
    const rootPackage = JSON.parse(
      readFileSync(join(root, "package.json"), "utf8"),
    ) as {
      scripts?: Record<string, string>;
    };
    const webPackage = JSON.parse(
      readFileSync(join(root, "apps/web/package.json"), "utf8"),
    ) as { scripts?: Record<string, string> };
    const turboConfig = JSON.parse(
      readFileSync(join(root, "turbo.json"), "utf8"),
    ) as {
      globalDependencies?: string[];
      tasks?: Record<string, { env?: string[] }>;
    };

    expect(rootPackage.scripts?.["test:qa"]).toBe(
      "turbo run check test:unit build @dimensionlab/ui#build-storybook @dimensionlab/web#test:e2e",
    );
    expect(webPackage.scripts).not.toHaveProperty("test:qa");
    expect(turboConfig.tasks).not.toHaveProperty("test:qa");
    expect(turboConfig.globalDependencies).toEqual(
      expect.arrayContaining(["bun.lock", "tsconfig.base.json"]),
    );
    expect(turboConfig.tasks?.["test:e2e"]?.env).toEqual(
      expect.arrayContaining([
        "CI",
        "PLAYWRIGHT_DATABASE_URL",
        "PLAYWRIGHT_PORT",
        "PLAYWRIGHT_STORYBOOK_PORT",
      ]),
    );
  });

  test("lets turbo build app and Storybook artifacts before e2e serves them", () => {
    const playwrightConfig = readFileSync(
      join(root, "apps/web/playwright.config.ts"),
      "utf8",
    );
    const turboConfig = JSON.parse(
      readFileSync(join(root, "turbo.json"), "utf8"),
    ) as {
      tasks?: Record<string, { dependsOn?: string[] }>;
    };

    expect(playwrightConfig).not.toContain("bun run build &&");
    expect(playwrightConfig).not.toContain("bun run build-storybook");
    expect(turboConfig.tasks?.["test:e2e"]?.dependsOn).toEqual(
      expect.arrayContaining(["@dimensionlab/ui#build-storybook"]),
    );
  });

  test("accounts for local env files in cacheable Vite and Storybook task hashes", () => {
    const turboConfig = JSON.parse(
      readFileSync(join(root, "turbo.json"), "utf8"),
    ) as {
      tasks?: Record<string, { inputs?: string[] }>;
    };

    for (const taskName of ["build", "build-storybook"]) {
      expect(turboConfig.tasks?.[taskName]?.inputs).toEqual([
        "$TURBO_DEFAULT$",
        ".env*",
      ]);
    }
  });

  test("keeps the website app and reusable UI library as separate packages", () => {
    const webPackage = JSON.parse(
      readFileSync(join(root, "apps/web/package.json"), "utf8"),
    ) as { dependencies?: Record<string, string>; name?: string };
    const uiPackage = JSON.parse(
      readFileSync(join(root, "packages/ui/package.json"), "utf8"),
    ) as { exports?: Record<string, unknown>; name?: string };

    expect(webPackage.name).toBe("@dimensionlab/web");
    expect(webPackage.dependencies?.["@dimensionlab/ui"]).toBe("workspace:*");
    expect(uiPackage.name).toBe("@dimensionlab/ui");
    expect(uiPackage.exports).toHaveProperty(".");
    expect(uiPackage.exports).toHaveProperty("./styles.css");
  });

  test("keeps the dashboard model in a reusable internal package", () => {
    const webPackage = JSON.parse(
      readFileSync(join(root, "apps/web/package.json"), "utf8"),
    ) as { dependencies?: Record<string, string> };
    const modelPackage = JSON.parse(
      readFileSync(join(root, "packages/dashboard-model/package.json"), "utf8"),
    ) as { exports?: Record<string, unknown>; name?: string };
    const tsconfig = JSON.parse(
      readFileSync(join(root, "tsconfig.json"), "utf8"),
    ) as { references?: Array<{ path: string }> };

    expect(webPackage.dependencies?.["@dimensionlab/dashboard-model"]).toBe(
      "workspace:*",
    );
    expect(modelPackage.name).toBe("@dimensionlab/dashboard-model");
    expect(modelPackage.exports).toHaveProperty(".");
    expect(modelPackage.exports).toHaveProperty("./fixtures");
    expect(tsconfig.references).toEqual(
      expect.arrayContaining([{ path: "./packages/dashboard-model" }]),
    );
    expect(existsSync(join(root, "apps/web/src/lib/model/index.ts"))).toBe(
      false,
    );
  });

  test("consumes workspace packages through package exports instead of source aliases", () => {
    const webTsconfig = JSON.parse(
      readFileSync(join(root, "apps/web/tsconfig.json"), "utf8"),
    ) as { compilerOptions?: { paths?: Record<string, string[]> } };
    const modelPackage = JSON.parse(
      readFileSync(join(root, "packages/dashboard-model/package.json"), "utf8"),
    ) as { exports?: Record<string, WorkspacePackageExport> };
    const uiPackage = JSON.parse(
      readFileSync(join(root, "packages/ui/package.json"), "utf8"),
    ) as { exports?: Record<string, WorkspacePackageExport> };
    const viteConfig = readFileSync(join(root, "apps/web/vite.config.ts"), "utf8");
    const turboConfig = JSON.parse(
      readFileSync(join(root, "turbo.json"), "utf8"),
    ) as { tasks?: Record<string, { dependsOn?: string[] }> };

    expect(webTsconfig.compilerOptions?.paths).not.toHaveProperty(
      "@dimensionlab/dashboard-model",
    );
    expect(webTsconfig.compilerOptions?.paths).not.toHaveProperty(
      "@dimensionlab/dashboard-model/fixtures",
    );
    expect(webTsconfig.compilerOptions?.paths).not.toHaveProperty("@dimensionlab/ui");
    expect(webTsconfig.compilerOptions?.paths).not.toHaveProperty(
      "@dimensionlab/ui/styles.css",
    );
    expect(webTsconfig.compilerOptions?.paths).toEqual({
      "$lib/*": ["src/lib/*"],
    });
    expect(viteConfig).not.toContain("../../packages/dashboard-model/src");
    expect(viteConfig).not.toContain("../../packages/ui/src");
    expect(turboConfig.tasks?.dev?.dependsOn).toEqual(["^build"]);
    expectPackageExport(modelPackage.exports?.["."], {
      types: "./dist/index.d.ts",
      development: "./src/index.ts",
      default: "./dist/index.js",
    });
    expectPackageExport(modelPackage.exports?.["./fixtures"], {
      types: "./dist/fixtures/index.d.ts",
      development: "./src/fixtures/index.ts",
      default: "./dist/fixtures/index.js",
    });
    expectPackageExport(uiPackage.exports?.["."], {
      types: "./dist/index.d.ts",
      development: "./src/index.ts",
      default: "./dist/index.js",
    });
    expectPackageExport(uiPackage.exports?.["./styles.css"], {
      development: "./src/styles.css",
      default: "./dist/styles.css",
    });
    expectPackageExport(uiPackage.exports?.["./tokens.css"], {
      development: "./src/tokens.css",
      default: "./dist/tokens.css",
    });
  });

  test("builds the internal container from a turbo-pruned web workspace", () => {
    const containerfile = readFileSync(
      join(root, "apps/web/Containerfile"),
      "utf8",
    );
    const pruneCommand = "turbo prune @dimensionlab/web --docker";
    const jsonCopy = "COPY --from=pruner /repo/out/json/ ./";
    const sourceCopy = "COPY --from=pruner /repo/out/full/ ./";
    const tsconfigCopy =
      "COPY --from=pruner /repo/tsconfig.base.json /repo/tsconfig.json ./";
    const installCommand = "RUN bun install --frozen-lockfile";

    expect(containerfile).toContain("AS pruner");
    expect(containerfile).toContain(pruneCommand);
    expect(containerfile).toContain(jsonCopy);
    expect(containerfile).toContain(sourceCopy);
    expect(containerfile).toContain(tsconfigCopy);
    expect(containerfile).not.toContain(
      "COPY packages/dashboard-model/package.json",
    );
    expect(containerfile).not.toContain("COPY packages/ui/package.json");

    const jsonCopyIndex = containerfile.indexOf(jsonCopy);
    const installIndex = containerfile.indexOf(installCommand);
    const sourceCopyIndex = containerfile.indexOf(sourceCopy);
    const tsconfigCopyIndex = containerfile.indexOf(tsconfigCopy);

    expect(jsonCopyIndex).toBeGreaterThan(-1);
    expect(installIndex).toBeGreaterThan(jsonCopyIndex);
    expect(sourceCopyIndex).toBeGreaterThan(installIndex);
    expect(tsconfigCopyIndex).toBeGreaterThan(sourceCopyIndex);
    expect(containerfile.indexOf("RUN bun run build")).toBeGreaterThan(
      tsconfigCopyIndex,
    );
  });

  test("keeps local turbo prune output out of git and container contexts", () => {
    const webPackage = JSON.parse(
      readFileSync(join(root, "apps/web/package.json"), "utf8"),
    ) as { scripts?: Record<string, string> };
    const gitignore = readFileSync(join(root, ".gitignore"), "utf8");
    const containerignore = readFileSync(join(root, ".containerignore"), "utf8");
    const containerIgnoreRules = new Set(
      containerignore
        .split(/\r?\n/)
        .map((line) => line.trim())
        .filter(Boolean),
    );

    expect(gitignore).toContain("out/");
    expect(containerignore).toContain("out");
    expect([...containerIgnoreRules]).toEqual(
      expect.arrayContaining([
        "apps/*/.turbo",
        "apps/*/build",
        "apps/*/data",
        "apps/*/dist",
        "apps/*/playwright-report",
        "apps/*/test-results",
        "packages/*/.turbo",
        "packages/*/dist",
        "packages/*/storybook-static",
      ]),
    );
    expect(webPackage.scripts?.build).toBe(
      "rm -rf build && vite build && bun build src/server/index.ts --target bun --outdir build",
    );
  });
});

type WorkspacePackageExport =
  | string
  | {
      types?: string;
      development?: string;
      default?: string;
    };

function expectPackageExport(
  actual: WorkspacePackageExport | undefined,
  expected: Exclude<WorkspacePackageExport, string>,
): void {
  expect(actual).toMatchObject(expected);
}