#!/usr/bin/env node

// @effect-diagnostics nodeBuiltinImport:off - node:os resolves the shared T3 home guard.
import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
import * as NodeServices from "@effect/platform-node/NodeServices";
import * as NodeOS from "node:os";
import * as Console from "effect/Console";
import * as DateTime from "effect/DateTime";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Logger from "effect/Logger";
import * as Option from "effect/Option";
import * as Path from "effect/Path";
import * as Schema from "effect/Schema";
import { Command, Flag } from "effect/unstable/cli";

import { resolveWorktreeT3Home } from "@t3tools/shared/devHome";

import { DevSeedError, MAX_SEED_THREAD_LIMIT, seedDevDatabase } from "./lib/dev-seed.ts";
import { findRunningServerPid, findRunningServerPidSync } from "./lib/server-runtime-probe.ts";

const DEFAULT_THREAD_LIMIT = 25;
const DEFAULT_ACTIVITY_LIMIT = 200;

const resolveSharedHome = (path: Path.Path): string => {
  const configured = process.env.T3CODE_HOME?.trim();
  if (!configured) {
    return path.join(NodeOS.homedir(), ".t3");
  }
  if (configured === "~") {
    return NodeOS.homedir();
  }
  return path.resolve(
    configured.startsWith("~/") || configured.startsWith("~\\")
      ? path.join(NodeOS.homedir(), configured.slice(2))
      : configured,
  );
};

const isPathWithin = (path: Path.Path, parent: string, candidate: string): boolean => {
  const relative = path.relative(parent, candidate);
  return (
    relative === "" ||
    (relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative))
  );
};

class DevSeedTargetError extends Schema.TaggedErrorClass<DevSeedTargetError>()(
  "DevSeedTargetError",
  {
    reason: Schema.Literals([
      "shared-home",
      "missing-target",
      "not-a-worktree",
      "server-running",
      "same-source",
    ]),
    detail: Schema.String,
  },
) {
  override get message(): string {
    switch (this.reason) {
      case "shared-home":
        return [
          `Refusing to seed ${this.detail}: that database lives in the shared T3 Code home.`,
          "This command overwrites projection tables. Run it from a worktree, or pass --to <base-dir>.",
        ].join("\n");
      case "missing-target":
        return [
          `No database at ${this.detail}.`,
          "Start the dev server once so migrations run (`bun run dev`), then seed.",
        ].join("\n");
      case "not-a-worktree":
        return [
          "Not inside a git worktree, so there is no worktree-local data directory to seed.",
          "Pass --to <base-dir> to choose one explicitly.",
        ].join("\n");
      case "server-running":
        return [
          `A T3 Code server (pid ${this.detail}) is running against this data directory.`,
          "Seeding replaces its projections and empties its event log while it holds them open,",
          "which leaves the running server's in-memory read model describing rows that no longer exist.",
          "Stop it, run the seed, then start it again.",
        ].join("\n");
      case "same-source":
        return [
          `Refusing to seed ${this.detail} from itself.`,
          "The copy would restore what the delete removed, but the event log and the",
          "projector cursors are cleared either way — so the directory loses its history",
          "and keeps only whatever the thread and activity caps selected.",
        ].join("\n");
    }
  }
}

/**
 * The state directory holding a base directory's database.
 *
 * `deriveServerPaths` picks `dev` for an implicit dev home and `userdata`
 * otherwise — a split that depends on how the server was started, which the
 * person seeding has no reason to know. Hard-coding `userdata` made a
 * main-checkout `bun run dev` (whose state lives in `<base>/dev`) unreachable:
 * the seed reported "no database, start the dev server so migrations run" about
 * a server that was already running.
 *
 * When both exist, neither is categorically right — a worktree run gets
 * `userdata` (the dev runner passes an explicit home), a main-checkout run gets
 * `dev` — so the tie goes to whichever was written most recently, i.e. the one
 * the last server to run actually opened. The chosen path is printed, so a
 * wrong guess is visible rather than silent.
 *
 * Recency is the newest of the database and its `-wal` sidecar. The server runs
 * SQLite in WAL mode, where writes land in the sidecar and the main file's
 * mtime can sit unchanged until a checkpoint — so reading the database alone
 * makes a busy directory look older than a dormant one.
 */
const resolveStateDir = Effect.fn("devSeed.resolveStateDir")(function* (baseDir: string) {
  const fileSystem = yield* FileSystem.FileSystem;
  const path = yield* Path.Path;

  const modifiedAtMs = (info: FileSystem.File.Info): number =>
    Option.match(info.mtime, { onSome: (mtime) => mtime.getTime(), onNone: () => 0 });

  const candidates: Array<{ readonly stateDir: string; readonly modifiedAtMs: number }> = [];
  for (const stateDir of ["userdata", "dev"] as const) {
    const dbPath = path.join(baseDir, stateDir, "state.sqlite");
    const info = yield* fileSystem.stat(dbPath).pipe(Effect.option);
    if (Option.isNone(info)) {
      continue;
    }
    // The sidecar is absent outside WAL mode, and after a clean checkpoint.
    const walInfo = yield* fileSystem.stat(`${dbPath}-wal`).pipe(Effect.option);
    candidates.push({
      stateDir,
      modifiedAtMs: Math.max(
        modifiedAtMs(info.value),
        Option.match(walInfo, { onSome: modifiedAtMs, onNone: () => 0 }),
      ),
    });
  }

  // `userdata` first above, so an equal or missing mtime keeps the old default.
  return (
    candidates.reduce<{ readonly stateDir: string; readonly modifiedAtMs: number } | undefined>(
      (best, candidate) =>
        best === undefined || candidate.modifiedAtMs > best.modifiedAtMs ? candidate : best,
      undefined,
    )?.stateDir ?? "userdata"
  );
});

const stateDbPath = (path: Path.Path, baseDir: string, stateDir: string) =>
  path.join(baseDir, stateDir, "state.sqlite");

/**
 * Copies the files behind the copied messages' attachment references.
 *
 * The rows carry only metadata; the bytes sit in a flat directory beside the
 * database as `<attachmentId><ext>` (apps/server/src/attachmentStore.ts). Copy
 * the rows alone and a seeded thread renders an image whose request 404s.
 *
 * Matched by directory listing rather than by reconstructing the extension: the
 * server infers it from mime type and file name at upload, and duplicating that
 * inference here would rot independently of it.
 */
const copyAttachments = Effect.fn("devSeed.copyAttachments")(function* (input: {
  readonly sourceDir: string;
  readonly targetDir: string;
  readonly attachmentIds: ReadonlyArray<string>;
}) {
  const fileSystem = yield* FileSystem.FileSystem;
  const path = yield* Path.Path;

  if (input.attachmentIds.length === 0) {
    return 0;
  }

  const entries = yield* fileSystem
    .readDirectory(input.sourceDir)
    .pipe(Effect.orElseSucceed(() => [] as Array<string>));
  const wanted = new Set(input.attachmentIds);
  const matches = entries.filter((entry) => wanted.has(path.parse(entry).name));
  if (matches.length === 0) {
    return 0;
  }

  // Attachments are decoration on a dev fixture: one unreadable file should
  // leave the rest of the seed intact rather than fail a completed database
  // copy. The directory itself is subject to the same rule.
  return yield* fileSystem.makeDirectory(input.targetDir, { recursive: true }).pipe(
    Effect.andThen(
      Effect.forEach(matches, (entry) =>
        fileSystem
          .copyFile(path.join(input.sourceDir, entry), path.join(input.targetDir, entry))
          .pipe(
            Effect.as(1),
            Effect.orElseSucceed(() => 0),
          ),
      ),
    ),
    Effect.map((copied) => copied.reduce((total, one) => total + one, 0)),
    Effect.orElseSucceed(() => 0),
  );
});

const devSeedCli = Command.make("dev-seed", {
  from: Flag.string("from").pipe(
    Flag.withDescription(
      "Base directory to copy from (default: T3CODE_HOME, or ~/.t3). Read-only.",
    ),
    Flag.optional,
    Flag.map(Option.getOrUndefined),
  ),
  to: Flag.string("to").pipe(
    Flag.withDescription(
      "Base directory to seed (default: this worktree's .t3). Its projection tables are replaced.",
    ),
    Flag.optional,
    Flag.map(Option.getOrUndefined),
  ),
  // Bounded below: SQLite reads a negative LIMIT as "no limit", which would
  // quietly turn a capped copy into a full-table one. The upper bound comes
  // from the seeder itself, which binds one variable per selected thread —
  // stating it separately here is what previously let the two drift apart.
  threads: Flag.integer("threads").pipe(
    Flag.withSchema(
      Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(MAX_SEED_THREAD_LIMIT)),
    ),
    Flag.withDescription(
      `How many recent threads to copy (default ${String(DEFAULT_THREAD_LIMIT)}, max ${String(MAX_SEED_THREAD_LIMIT)}).`,
    ),
    Flag.withDefault(DEFAULT_THREAD_LIMIT),
  ),
  activities: Flag.integer("activities").pipe(
    Flag.withSchema(Schema.Int.check(Schema.isGreaterThan(0))),
    Flag.withDescription(
      `Newest activities kept per thread (default ${String(DEFAULT_ACTIVITY_LIMIT)}).`,
    ),
    Flag.withDefault(DEFAULT_ACTIVITY_LIMIT),
  ),
}).pipe(
  Command.withDescription(
    "Copy recent projects and threads from a T3 Code data directory into an isolated dev one.",
  ),
  Command.withHandler((input) =>
    Effect.gen(function* () {
      const fileSystem = yield* FileSystem.FileSystem;
      const path = yield* Path.Path;

      const sharedHome = resolveSharedHome(path);
      const sourceBaseDir = input.from ? path.resolve(input.from) : sharedHome;

      const defaultTarget = yield* resolveWorktreeT3Home(process.cwd());
      const targetBaseDir = input.to ? path.resolve(input.to) : defaultTarget;
      if (targetBaseDir === undefined) {
        return yield* new DevSeedTargetError({ reason: "not-a-worktree", detail: process.cwd() });
      }

      const [sourceStateDir, targetStateDir] = yield* Effect.all([
        resolveStateDir(sourceBaseDir),
        resolveStateDir(targetBaseDir),
      ]);
      const sourceDbPath = stateDbPath(path, sourceBaseDir, sourceStateDir);
      const targetDbPath = stateDbPath(path, targetBaseDir, targetStateDir);

      // The whole point is to keep dev data off the real home; overwriting it
      // here would be the exact accident this command exists to avoid.
      //
      // Guarded on the canonical *database* paths, not the base directories: a
      // base can canonicalize to itself while its `userdata` or `dev`
      // subdirectory is a symlink into the shared home, and comparing bases
      // then waves through a seed whose actual write target is the real
      // database. Resolve the full path first — the file itself can be the
      // symlink — and fall back to resolving the directory and re-joining the
      // filename when the file does not exist yet: a nonexistent file cannot
      // be a link to anything, but its directory still can be, and this is
      // exactly the case where the missing-target advice ("start the dev
      // server") would otherwise create the database in the shared home.
      const canonicalDbPath = (databasePath: string) =>
        fileSystem.realPath(databasePath).pipe(
          Effect.catch(() =>
            fileSystem
              .realPath(path.dirname(databasePath))
              .pipe(Effect.map((directory) => path.join(directory, path.basename(databasePath)))),
          ),
          Effect.orElseSucceed(() => databasePath),
        );
      const [canonicalTargetDb, canonicalSourceDb, canonicalShared] = yield* Effect.all([
        canonicalDbPath(targetDbPath),
        canonicalDbPath(sourceDbPath),
        fileSystem.realPath(sharedHome).pipe(Effect.orElseSucceed(() => sharedHome)),
      ]);
      if (isPathWithin(path, canonicalShared, canonicalTargetDb)) {
        return yield* new DevSeedTargetError({ reason: "shared-home", detail: canonicalTargetDb });
      }
      // After the shared-home refusal: that one must come first because the
      // missing-target advice below — start a dev server, which creates the
      // database — is exactly wrong for the shared home. Everywhere else, a
      // missing database is the more actionable diagnosis, so it outranks
      // same-source: aliased paths with nothing behind them are a setup
      // problem, not a self-seed.
      if (!(yield* fileSystem.exists(targetDbPath))) {
        return yield* new DevSeedTargetError({ reason: "missing-target", detail: targetDbPath });
      }

      // Seeding a database from itself is not the data loss it looks like —
      // the source reads a pre-transaction snapshot, so the copy puts the rows
      // back. What does not come back is the event log and the cursors, and
      // anything outside the caps. Nobody means to ask for that.
      if (canonicalTargetDb === canonicalSourceDb) {
        return yield* new DevSeedTargetError({ reason: "same-source", detail: canonicalTargetDb });
      }

      // SQLite locking is not enough on its own: the seed's transaction can take
      // the write lock between a running server's own writes and commit cleanly.
      // What it cannot do is tell that server the projections it is holding in
      // memory, and the event log it is appending to, were both replaced under
      // it. Its next write then lands on top of a read model it never built.
      //
      // Scoped to the state directory being seeded: a server using only the
      // other directory's database is not touching this one, and blocking on it
      // would refuse seeds that are perfectly safe.
      const runningPid = yield* findRunningServerPid(targetBaseDir, targetStateDir);
      if (Option.isSome(runningPid)) {
        return yield* new DevSeedTargetError({
          reason: "server-running",
          detail: String(runningPid.value),
        });
      }

      const seededAt = yield* Effect.map(DateTime.now, DateTime.formatIso);
      const summary = yield* Effect.try({
        try: () =>
          seedDevDatabase({
            sourceDbPath,
            targetDbPath,
            threadLimit: input.threads,
            activityLimit: input.activities,
            seededAt,
            // The check above happens before the copy, which can take seconds.
            // Re-checked just before the commit so a server that started in
            // between aborts the seed instead of having its database swapped.
            findRunningServerPid: () => findRunningServerPidSync(targetBaseDir, targetStateDir),
          }),
        catch: (cause) => cause as DevSeedError,
      });

      // Attachments sit beside the database, so they follow the same state dir.
      const copiedAttachments = yield* copyAttachments({
        sourceDir: path.join(sourceBaseDir, sourceStateDir, "attachments"),
        targetDir: path.join(targetBaseDir, targetStateDir, "attachments"),
        attachmentIds: summary.attachmentIds,
      });

      yield* Console.log(
        [
          `Seeded ${targetDbPath}`,
          `  from     ${sourceDbPath}`,
          `  projects ${String(summary.projects)}`,
          `  threads  ${String(summary.threads)}`,
          `  messages ${String(summary.messages)}`,
          `  activity ${String(summary.activities)}`,
          `  turns    ${String(summary.turns)}  sessions ${String(summary.sessions)}`,
          ...(summary.attachmentIds.length > 0
            ? [
                `  files    ${String(copiedAttachments)}/${String(summary.attachmentIds.length)} attachment(s)`,
              ]
            : []),
          ...(summary.skippedColumns.length > 0
            ? [
                `  note: skipped ${String(summary.skippedColumns.length)} column(s) absent from the target schema`,
                `        (${summary.skippedColumns.join(", ")})`,
              ]
            : []),
          "",
          "Restart the dev server to pick it up.",
        ].join("\n"),
      );
    }).pipe(
      Effect.tapError((error) =>
        Effect.logError(
          error instanceof DevSeedError
            ? `${error.message}${error.hint ? `\n${error.hint}` : ""}`
            : error.message,
        ),
      ),
    ),
  ),
);

if (import.meta.main) {
  Command.run(devSeedCli, { version: "0.0.0" }).pipe(
    Effect.provide(Layer.mergeAll(Logger.layer([Logger.consolePretty()]), NodeServices.layer)),
    NodeRuntime.runMain,
  );
}