import { readFile, readdir, stat } from 'node:fs/promises';
import { resolve, basename, relative } from 'node:path';
import { z } from 'zod';
import { pathGuard, PathScopeError } from '../path_guard.js';
import { isSecretPath, SecretBlockedError, filterSecretEntries } from '../secret_guard.js';
import { grep as fileOpsGrep, findFiles as fileOpsFindFiles } from '../file_ops.js';
import { readTruncation, truncateIfNeeded } from '../truncate.js';
import type { ToolDef } from './types.js';

const MAX_FILE_BYTES = 5 * 1024 * 1024;
const DEFAULT_VIEW_LINES = 200;
const MAX_GREP_RESULTS = 200;
const DEFAULT_GREP_RESULTS = 100;
const MAX_FIND_RESULTS = 200;
const DEFAULT_FIND_RESULTS = 100;
const MAX_DIR_ENTRIES = 500;

const ViewFileInput = z.object({
  path: z.string().min(1),
  start_line: z.number().int().positive().optional(),
  end_line: z.number().int().positive().optional(),
});
type ViewFileInputT = z.infer<typeof ViewFileInput>;

export const viewFile: ToolDef<ViewFileInputT> = {
  name: 'view_file',
  description:
    "Read a file under the project. Returns first 200 lines by default, or a slice via start_line/end_line (1-indexed, inclusive). Files larger than 5MB are refused. Output is truncated if longer than the slice; the response indicates truncation.",
  inputSchema: ViewFileInput,
  jsonSchema: {
    type: 'function',
    function: {
      name: 'view_file',
      description:
        "Read a file under the project. Returns first 200 lines by default, or a slice via start_line/end_line (1-indexed, inclusive). Files larger than 5MB are refused.",
      parameters: {
        type: 'object',
        properties: {
          path: { type: 'string', description: 'absolute or project-relative path' },
          start_line: { type: 'integer', description: 'first line (1-indexed)' },
          end_line: { type: 'integer', description: 'last line (1-indexed, inclusive)' },
        },
        required: ['path'],
        additionalProperties: false,
      },
    },
  },
  async execute(input, projectRoot, extraRoots) {
    const real = await pathGuard(projectRoot, input.path, extraRoots);
    // v1.11.7: secret-file deny check. Test the project-relative path
    // (matches the form continue.dev's patterns expect: basenames + dir
    // segments). Throw a typed error so executeToolCall in inference.ts
    // surfaces a clear "blocked" message to the LLM instead of silently
    // returning content the user wanted hidden.
    // v1.13.17: when the resolved path is outside the primary projectRoot
    // (i.e. via an allowed_read_paths grant), `relative()` returns "../…"
    // which won't match secret-file basename patterns. Re-anchor on the
    // file's basename so the secret deny still fires across all grant roots.
    const rel = relative(projectRoot, real);
    const relPath = rel && !rel.startsWith('..') ? rel : basename(real);
    if (isSecretPath(relPath)) {
      throw new SecretBlockedError(relPath);
    }
    const s = await stat(real);
    if (!s.isFile()) {
      throw new PathScopeError(`not a file: ${input.path}`);
    }
    if (s.size > MAX_FILE_BYTES) {
      throw new Error(`file too large (${s.size} bytes, max ${MAX_FILE_BYTES})`);
    }
    const raw = await readFile(real, 'utf8');
    const lines = raw.split('\n');
    const total = lines.length;
    let start = input.start_line ?? 1;
    let end = input.end_line ?? Math.min(total, start + DEFAULT_VIEW_LINES - 1);
    if (input.start_line == null && input.end_line == null) {
      end = Math.min(total, DEFAULT_VIEW_LINES);
    }
    if (start < 1) start = 1;
    if (end > total) end = total;
    if (end < start) end = start;
    const slice = lines.slice(start - 1, end);
    const content = slice.join('\n');
    const truncated = total > end || start > 1;
    // v1.13.5: stash the full file on tmpfs so the model can retrieve more
    // via view_truncated_output(id) without re-reading the file (which it
    // may not have project-relative-path access to in future agent setups).
    // raw is bounded by MAX_FILE_BYTES (5MB), within truncateIfNeeded's cap.
    const wrapped = await truncateIfNeeded({
      fullContent: raw,
      slicedContent: content,
      wasTruncated: truncated,
    });
    return {
      path: relative(projectRoot, real) || basename(real),
      content: wrapped.content,
      total_lines: total,
      returned_lines: [start, end],
      truncated: wrapped.truncated,
      ...(wrapped.outputPath ? { outputPath: wrapped.outputPath } : {}),
    };
  },
};

const ListDirInput = z.object({
  path: z.string().min(1),
  show_hidden: z.boolean().optional(),
});
type ListDirInputT = z.infer<typeof ListDirInput>;

export const listDir: ToolDef<ListDirInputT> = {
  name: 'list_dir',
  description: 'List entries in a directory (up to 500). Hidden files excluded unless show_hidden=true.',
  inputSchema: ListDirInput,
  jsonSchema: {
    type: 'function',
    function: {
      name: 'list_dir',
      description:
        'List entries in a directory (up to 500). Hidden files (dot-prefixed) excluded unless show_hidden=true.',
      parameters: {
        type: 'object',
        properties: {
          path: { type: 'string' },
          show_hidden: { type: 'boolean' },
        },
        required: ['path'],
        additionalProperties: false,
      },
    },
  },
  async execute(input, projectRoot, extraRoots) {
    const real = await pathGuard(projectRoot, input.path, extraRoots);
    const s = await stat(real);
    if (!s.isDirectory()) {
      throw new PathScopeError(`not a directory: ${input.path}`);
    }
    const entries = await readdir(real, { withFileTypes: true });
    const filtered = input.show_hidden
      ? entries
      : entries.filter((e) => !e.name.startsWith('.'));
    const total = filtered.length;
    const wasTruncated = total > MAX_DIR_ENTRIES;
    const relDir = relative(projectRoot, real) || '.';
    // v1.13.5: when we'd truncate, render the FULL list to tmpfs so
    // view_truncated_output can serve it. Stat sizes for all entries when
    // truncating so the stored view matches the visible shape; this is the
    // one extra cost for big directories, bounded by total entries (which
    // is itself bounded by filesystem behavior).
    const processOne = async (e: typeof filtered[number]) => {
      const child = resolve(real, e.name);
      let size: number | undefined;
      if (e.isFile()) {
        try {
          const cs = await stat(child);
          size = cs.size;
        } catch { /* ignore */ }
      }
      return {
        name: e.name,
        type: e.isDirectory() ? ('dir' as const) : ('file' as const),
        ...(size != null ? { size } : {}),
      };
    };
    const slice = filtered.slice(0, MAX_DIR_ENTRIES);
    const out = await Promise.all(slice.map(processOne));
    // v1.11.7: filter entries whose project-relative path matches a secret
    // pattern. The same filter applies to the full-list snapshot below so
    // the stashed file never holds entries the slice would have hidden.
    const secretFilter = filterSecretEntries(out, (e) =>
      relDir === '.' ? e.name : `${relDir}/${e.name}`,
    );
    let outputPath: string | undefined;
    if (wasTruncated) {
      const fullProcessed = await Promise.all(filtered.map(processOne));
      const fullFiltered = filterSecretEntries(fullProcessed, (e) =>
        relDir === '.' ? e.name : `${relDir}/${e.name}`,
      );
      // One line per entry, view_truncated_output's line slicing semantics
      // map cleanly. Format: "<type>\t<name>[\tsize=N]". Header documents
      // the shape so the model can grep / regex without prior schema lookup.
      const header = `# list_dir ${relDir} — ${fullFiltered.kept.length} entries`;
      const lines = [header, ...fullFiltered.kept.map((e) => {
        const sz = 'size' in e && e.size != null ? `\tsize=${e.size}` : '';
        return `${e.type}\t${e.name}${sz}`;
      })];
      const wrapped = await truncateIfNeeded({
        fullContent: lines.join('\n'),
        slicedContent: '',
        wasTruncated: true,
      });
      outputPath = wrapped.outputPath;
    }
    return {
      path: relDir,
      entries: secretFilter.kept,
      total: secretFilter.kept.length,
      truncated: wasTruncated,
      ...(secretFilter.note ? { pathguard_note: secretFilter.note } : {}),
      ...(outputPath ? { outputPath } : {}),
    };
  },
};

const GrepInput = z.object({
  pattern: z.string().min(1),
  path: z.string().optional(),
  case_sensitive: z.boolean().optional(),
  max_results: z.number().int().positive().optional(),
  hidden: z.boolean().optional(),
});
type GrepInputT = z.infer<typeof GrepInput>;

export const grep: ToolDef<GrepInputT> = {
  name: 'grep',
  description:
    'Search file contents with ripgrep. Default path is project root. Max 100 results (200 cap).',
  inputSchema: GrepInput,
  jsonSchema: {
    type: 'function',
    function: {
      name: 'grep',
      description:
        'Search file contents with ripgrep. Returns up to 100 matches (cap 200). Set hidden=true to include dot-prefixed files.',
      parameters: {
        type: 'object',
        properties: {
          pattern: { type: 'string' },
          path: { type: 'string' },
          case_sensitive: { type: 'boolean' },
          max_results: { type: 'integer' },
          hidden: { type: 'boolean' },
        },
        required: ['pattern'],
        additionalProperties: false,
      },
    },
  },
  async execute(input, projectRoot, extraRoots) {
    const limit = Math.min(
      Math.max(input.max_results ?? DEFAULT_GREP_RESULTS, 1),
      MAX_GREP_RESULTS
    );
    // Delegate to file_ops.grep; reshape match objects to preserve LLM output format
    // (file_ops uses {path, line, text}; tool output uses {path, line, content})
    const result = await fileOpsGrep(projectRoot, input.pattern, {
      path: input.path,
      max_matches: limit,
      case_sensitive: input.case_sensitive,
      hidden: input.hidden,
      extra_roots: extraRoots,
    });
    const reshaped = result.matches.map((m) => ({
      path: m.path,
      line: m.line,
      content: m.text,
    }));
    // v1.11.7: drop matches whose source file is a known-secret pattern.
    // file_ops.grep returns project-relative paths, so we feed them straight
    // into isSecretPath. Multiple matches in the same secret file each get
    // dropped individually — they all count in the hidden tally.
    const secretFilter = filterSecretEntries(reshaped, (m) => m.path);
    return {
      matches: secretFilter.kept,
      total: secretFilter.kept.length,
      truncated: result.truncated,
      ...(secretFilter.note ? { pathguard_note: secretFilter.note } : {}),
    };
  },
};

const FindFilesInput = z.object({
  pattern: z.string().min(1),
  path: z.string().optional(),
  max_results: z.number().int().positive().optional(),
});
type FindFilesInputT = z.infer<typeof FindFilesInput>;

export const findFiles: ToolDef<FindFilesInputT> = {
  name: 'find_files',
  description: 'Glob for filenames. Default path is project root. Max 100 results (200 cap).',
  inputSchema: FindFilesInput,
  jsonSchema: {
    type: 'function',
    function: {
      name: 'find_files',
      description:
        'Glob for filenames under a directory. Default path is project root. Max 100 results (cap 200). Pattern uses standard glob (e.g. "**/*.ts").',
      parameters: {
        type: 'object',
        properties: {
          pattern: { type: 'string' },
          path: { type: 'string' },
          max_results: { type: 'integer' },
        },
        required: ['pattern'],
        additionalProperties: false,
      },
    },
  },
  async execute(input, projectRoot, extraRoots) {
    const limit = Math.min(
      Math.max(input.max_results ?? DEFAULT_FIND_RESULTS, 1),
      MAX_FIND_RESULTS
    );
    // Delegate to file_ops.findFiles; reshape { files, total, truncated } to
    // preserve the LLM-visible output format { paths, total, truncated }
    const result = await fileOpsFindFiles(projectRoot, input.pattern, {
      path: input.path,
      max_results: limit,
      extra_roots: extraRoots,
    });
    // v1.11.7: drop paths matching secret patterns. The original `total`
    // from file_ops includes pre-truncation count; we report the visible
    // count post-filter so the LLM can't infer hidden-count by subtraction.
    const secretFilter = filterSecretEntries(result.files, (p) => p);
    return {
      paths: secretFilter.kept,
      total: secretFilter.kept.length,
      truncated: result.truncated,
      ...(secretFilter.note ? { pathguard_note: secretFilter.note } : {}),
    };
  },
};

// v1.13.5: retrieves the full content of a previously-truncated tool output
// via the opaque id stamped on the original tool_result. Line-based slicing
// matches view_file's mental model so the model uses the same affordances.
// Tmpfs-backed, 7-day TTL (see services/truncate.ts).
const VIEW_TRUNCATED_DEFAULT_LINES = 200;

const ViewTruncatedOutputInput = z.object({
  id: z.string().regex(/^tr_[0-9a-v]{12}$/),
  start_line: z.number().int().positive().optional(),
  end_line: z.number().int().positive().optional(),
});
type ViewTruncatedOutputInputT = z.infer<typeof ViewTruncatedOutputInput>;

export const viewTruncatedOutput: ToolDef<ViewTruncatedOutputInputT> = {
  name: 'view_truncated_output',
  description: `Retrieve the full content of a previously-truncated tool output by its outputPath id. When a tool returns { truncated: true, outputPath: "tr_..." }, call this to view the full content. Defaults to the first ${VIEW_TRUNCATED_DEFAULT_LINES} lines. Use start_line and end_line (1-indexed, inclusive) to slice. Stored for 7 days.`,
  inputSchema: ViewTruncatedOutputInput,
  jsonSchema: {
    type: 'function',
    function: {
      name: 'view_truncated_output',
      description: `Retrieve the full content of a previously-truncated tool output by its outputPath id. Returns the first ${VIEW_TRUNCATED_DEFAULT_LINES} lines by default; use start_line/end_line to slice. Stored for 7 days.`,
      parameters: {
        type: 'object',
        properties: {
          id: { type: 'string', description: 'The outputPath value from an earlier truncated tool result (e.g. "tr_abc123def456").' },
          start_line: { type: 'integer', description: 'First line (1-indexed). Default 1.' },
          end_line: { type: 'integer', description: `Last line (1-indexed, inclusive). Default ${VIEW_TRUNCATED_DEFAULT_LINES} lines past start.` },
        },
        required: ['id'],
        additionalProperties: false,
      },
    },
  },
  // view_truncated_output doesn't touch the filesystem — it pulls from tmpfs
  // by opaque id. extraRoots is irrelevant here; declared for signature parity
  // with the v1.13.17 ToolDef contract.
  async execute(input, _projectRoot, _extraRoots) {
    const content = await readTruncation(input.id);
    if (content === null) {
      return {
        id: input.id,
        content: '',
        truncated: false,
        error: `No truncation found for id "${input.id}". It may have been pruned (7-day TTL) or never existed.`,
      };
    }
    const lines = content.split('\n');
    const total = lines.length;
    let start = input.start_line ?? 1;
    let end = input.end_line ?? Math.min(total, start + VIEW_TRUNCATED_DEFAULT_LINES - 1);
    if (start < 1) start = 1;
    if (end > total) end = total;
    if (end < start) end = start;
    const slice = lines.slice(start - 1, end).join('\n');
    // Re-slicing this view isn't truncation in the dual-write sense — the
    // model already has the id; no point stashing the slice again.
    const truncated = total > end || start > 1;
    return {
      id: input.id,
      content: slice,
      total_lines: total,
      returned_lines: [start, end],
      truncated,
    };
  },
};
