import { join, resolve, sep } from "node:path";

import { z } from "zod";

import { getAppsDir } from "../../apps/app-store.js";
import { RiskLevel } from "../../permissions/types.js";
import { enqueuePkbIndexJob } from "../../plugins/defaults/memory/v1/jobs/embed-pkb-file.js";
import { getLogger } from "../../util/logger.js";
import { getWorkspaceDir } from "../../util/platform.js";
import { FileSystemOps } from "../shared/filesystem/file-ops-service.js";
import { formatWriteSummary } from "../shared/filesystem/format-diff.js";
import { sandboxPolicyWithHostFallback } from "../shared/filesystem/path-policy.js";
import {
  invalidToolInputResult,
  toToolInputSchema,
} from "../shared/zod-tool-schema.js";
import type {
  ToolContext,
  ToolDefinition,
  ToolExecutionResult,
} from "../types.js";

const logger = getLogger("file-write");

/**
 * Detects an attempt to write a self-contained interactive HTML document —
 * the signature of a "visualization" / "artifact" the model should be
 * building as a real app via the app-builder skill, not dumping as a loose
 * file. We deliberately trip ONLY on standalone docs with a substantial
 * INLINE script (the data + rendering live in the file). app-builder's own
 * scaffold writes a thin shell whose only script is an external module
 * (`<script type="module" src="/src/main.tsx">`) with an empty body, so this
 * never blocks the app-builder workflow it redirects to.
 */
const STANDALONE_HTML_RE = /<!doctype\s+html|<html[\s>]/i;
const INLINE_SCRIPT_RE =
  /<script\b(?![^>]*\bsrc=)[^>]*>[\s\S]{400,}?<\/script>/i;

function isSelfContainedArtifactHtml(path: string, content: string): boolean {
  if (!/\.html?$/i.test(path)) {
    return false;
  }
  if (content.length < 3000) {
    return false;
  }
  if (!STANDALONE_HTML_RE.test(content)) {
    return false;
  }
  return INLINE_SCRIPT_RE.test(content);
}

const ARTIFACT_REDIRECT_MESSAGE =
  'Error: This looks like a self-contained interactive visualization/artifact written as a loose HTML file. Do not build these as standalone .html files. Load the app-builder skill first with `skill_load` using `skill: "app-builder"`, then build it as a real persistent app with `app_create` (the skill loads frontend-design for the visual pass and provides chart widgets). If this genuinely needs to be a raw HTML file inside an existing code project, write it under that project folder.';

/**
 * Returns `true` iff `absPath` is an absolute path that resolves strictly
 * inside `pkbRoot`. Matches the containment semantics used elsewhere in the
 * daemon (e.g. `pkb-context-tracker`): a root-with-separator prefix check,
 * guarding against `<root>siblingDir` false positives.
 */
function isInsidePkbRoot(absPath: string, pkbRoot: string): boolean {
  const normalizedRoot = resolve(pkbRoot);
  const normalized = resolve(absPath);
  if (normalized === normalizedRoot) {
    return false;
  }
  const rootWithSep = normalizedRoot.endsWith(sep)
    ? normalizedRoot
    : normalizedRoot + sep;
  return normalized.startsWith(rootWithSep);
}

/**
 * Model-input schema, the single source for both runtime validation (via
 * `TOOL_INPUT_SCHEMAS`) and the advertised `input_schema` below. Loose so
 * injected fields (e.g. `activity`, which the model must send but the tool
 * never reads) pass through untouched.
 */
export const fileWriteInputSchema = z.looseObject({
  path: z
    .string()
    .min(1)
    .describe(
      "The path to the file to write (absolute or relative to working directory)",
    ),
  content: z.string().describe("The content to write to the file"),
  activity: z
    .string()
    .describe(
      "Brief non-technical explanation of what you are doing and why, shown as a status update.",
    )
    .optional()
    .catch(undefined),
});

export const fileWriteTool = {
  name: "file_write",
  description:
    "Write content to a file on your own machine, creating it if it does not exist. Use host_file_write for files on your guardian's device instead.",
  category: "filesystem",
  executionTarget: "sandbox",
  defaultRiskLevel: RiskLevel.Low,

  input_schema: toToolInputSchema(fileWriteInputSchema, {
    advertiseRequired: ["activity"],
  }),

  async execute(
    input: Record<string, unknown>,
    context: ToolContext,
  ): Promise<ToolExecutionResult> {
    const parsed = fileWriteInputSchema.safeParse(input);
    if (!parsed.success) {
      return invalidToolInputResult("file_write", parsed.error);
    }
    const { path: rawPath, content: fileContent } = parsed.data;

    // Redirect self-contained interactive HTML artifacts to app-builder.
    // Exempt writes that land inside the apps directory (app-builder's own
    // scaffold/iteration writes) so we never block the workflow we point to.
    if (isSelfContainedArtifactHtml(rawPath, fileContent)) {
      const candidate = resolve(context.workingDir, rawPath);
      if (!isInsidePkbRoot(candidate, getAppsDir())) {
        return { content: ARTIFACT_REDIRECT_MESSAGE, isError: true };
      }
    }

    const ops = new FileSystemOps((path, opts) =>
      sandboxPolicyWithHostFallback(path, context.workingDir, opts),
    );

    const result = await ops.writeFileSafe({
      path: rawPath,
      content: fileContent,
    });

    if (!result.ok) {
      const { error } = result;
      if (error.code === "IO_ERROR") {
        const msg = error.message;
        const hint = msg.includes("ENOENT")
          ? " (parent directory does not exist)"
          : msg.includes("EACCES")
            ? " (permission denied)"
            : msg.includes("EROFS")
              ? " (read-only file system)"
              : "";
        return {
          content: `Error writing file "${rawPath}"${hint}: ${msg}`,
          isError: true,
        };
      }
      const hint =
        error.code === "PATH_OUT_OF_BOUNDS"
          ? ". To write files outside the workspace, use the host_file_write tool instead."
          : "";
      return { content: `Error: ${error.message}${hint}`, isError: true };
    }

    const { filePath, oldContent, newContent, isNewFile } = result.value;

    // If the write landed inside the workspace PKB root, enqueue a
    // fire-and-forget re-index job so Qdrant stays in sync with on-disk
    // content. Failures here must never surface to the caller — a file
    // was written successfully and that is the user-facing contract.
    try {
      const pkbRoot = join(getWorkspaceDir(), "pkb");
      // Gate on `.md` to match `scanPkbFiles`, which only walks markdown.
      // Indexing `pkb/*.json` (or any other extension) here would produce
      // chunks the reconciler can't see, leading to orphaned vectors and
      // pointless embedding work.
      if (
        filePath.toLowerCase().endsWith(".md") &&
        isInsidePkbRoot(filePath, pkbRoot)
      ) {
        enqueuePkbIndexJob({
          pkbRoot,
          absPath: filePath,
        });
      }
    } catch (err) {
      logger.warn(
        {
          filePath,
          error: err instanceof Error ? err.message : String(err),
        },
        "Failed to enqueue PKB re-index job after file_write",
      );
    }

    return {
      content: `Successfully wrote to ${filePath} ${formatWriteSummary(
        oldContent,
        newContent,
        isNewFile,
      )}`,
      isError: false,
      diff: { filePath, oldContent, newContent, isNewFile },
    };
  },
} satisfies ToolDefinition;