/**
 * Agent path jail + permission policy.
 */

const path = require('path');
const {
  getAgentOriginRoot,
  ensureDir,
  resolveUnderAnyRoot,
  isPathInside,
  sanitizeId,
} = require('../lib/paths.js');

const policy = require('./policy.js');

const grantedRoots = new Set();
const alwaysApproveOrigins = new Set();

function setGrants(opts) {
  opts = opts || {};
  grantedRoots.clear();
  for (const r of opts.roots || []) {
    if (r) grantedRoots.add(path.resolve(String(r)));
  }
  alwaysApproveOrigins.clear();
  for (const o of opts.alwaysApproveOrigins || []) {
    if (o) alwaysApproveOrigins.add(String(o));
  }
}

function listGrantedRoots() {
  return Array.from(grantedRoots);
}

function defaultCwd(origin) {
  return ensureDir(getAgentOriginRoot(origin));
}

function workspaceRoots(origin) {
  const roots = [defaultCwd(origin)];
  for (const r of grantedRoots) roots.push(r);
  return roots;
}

function resolvePath(origin, userPath, cwd) {
  const roots = workspaceRoots(origin);
  const base = cwd && isAllowed(origin, cwd) ? cwd : roots[0];
  if (!userPath || userPath === '.' || userPath === '') return path.resolve(base);
  return resolveUnderAnyRoot(roots, userPath, base);
}

function isAllowed(origin, absPath) {
  const roots = workspaceRoots(origin);
  const resolved = path.resolve(absPath);
  return roots.some((r) => isPathInside(r, resolved));
}

function permissionMode(payload) {
  if (payload && payload._alwaysApprove) return 'always-approve';
  if (payload && payload.permissionMode) return payload.permissionMode;
  if (payload && payload._origin && alwaysApproveOrigins.has(payload._origin)) return 'always-approve';
  return 'ask';
}

function needsPermission(toolName, mode) {
  return policy.needsPermission(toolName, mode);
}

module.exports = {
  setGrants,
  listGrantedRoots,
  defaultCwd,
  workspaceRoots,
  resolvePath,
  isAllowed,
  permissionMode,
  needsPermission,
  shellAllowlisted: policy.shellAllowlisted,
  shellSafe: policy.shellSafe,
  shellName: policy.shellName,
  sanitizeId,
};