import { isAbsolute, join, normalize } from 'pathe';

import type { BashSyntaxNode } from '#/app/bashParser/bashParser';

const LISTING_COMMANDS: ReadonlySet<string> = new Set([
  'ls',
  'tree',
  'find',
  'dir',
  'exa',
  'eza',
  'lsd',
]);

const TRANSPARENT_WRAPPERS: ReadonlySet<string> = new Set([
  'program',
  'list',
  'pipeline',
  'redirected_statement',
]);

const LS_ARG_TAKING_OPTIONS: ReadonlySet<string> = new Set([
  '-w',
  '--width',
  '--sort',
  '--block-size',
  '-I',
  '--ignore',
  '--hide',
  '--format',
  '--time-style',
  '--indicator-style',
  '--quoting-style',
  '-T',
  '--tabsize',
]);

const TREE_LIKE_ARG_TAKING_OPTIONS: ReadonlySet<string> = new Set([
  '-w',
  '--width',
  '--sort',
  '--block-size',
  '-I',
  '--ignore',
  '--ignore-glob',
  '--hide',
  '--format',
  '--time-style',
  '--indicator-style',
  '--hyperlink',
  '--quoting-style',
  '-T',
  '--tabsize',
  '-L',
  '--level',
  '--depth',
  '-P',
  '-o',
  '--filelimit',
  '--charset',
  '--timefmt',
  '-s',
]);

const FIND_GLOBAL_OPTIONS: ReadonlySet<string> = new Set(['-H', '-L', '-P']);

const UNSAFE_OPERAND = /[$`*?[\]~]/;

export function extractBashTargetDirs(
  root: BashSyntaxNode,
  cwd: string,
  homeDir: string,
): string[] {
  const commands: CollectedCommand[] = [];
  collectCommands(root, commands);

  const targets: string[] = [];
  const seen = new Set<string>();
  let base: string | undefined = cwd;
  const push = (operand: string): void => {
    let dir: string;
    if (isAbsolute(operand)) {
      dir = normalize(operand);
    } else {
      const currentBase = base;
      if (currentBase === undefined) return;
      dir = normalize(join(currentBase, operand));
    }
    if (seen.has(dir)) return;
    seen.add(dir);
    targets.push(dir);
  };

  for (const { node, inPipeline } of commands) {
    const { name, args, dropped } = commandNameAndArgs(node);
    if (name === undefined) continue;
    if (name === 'cd') {
      if (inPipeline) continue;
      if (dropped) {
        base = undefined;
        continue;
      }
      const target = args[0];
      if (args.length === 1 && target !== undefined && !target.startsWith('-')) {
        if (isAbsolute(target)) {
          base = normalize(target);
        } else if (base !== undefined) {
          base = normalize(join(base, target));
        }
      } else if (args.length === 0) {
        base = homeDir;
      } else {
        base = undefined;
      }
      continue;
    }
    if (!LISTING_COMMANDS.has(name)) continue;
    const operands = name === 'find' ? takeLeadingPaths(args) : dropFlags(args, name);
    if (operands.length === 0) {
      if (!dropped) push('.');
      continue;
    }
    for (const operand of operands) push(operand);
  }
  return targets;
}

interface CollectedCommand {
  readonly node: BashSyntaxNode;
  readonly inPipeline: boolean;
}

function collectCommands(node: BashSyntaxNode, out: CollectedCommand[], inPipeline = false): void {
  if (node.type === 'command') {
    out.push({ node, inPipeline });
    return;
  }
  if (!TRANSPARENT_WRAPPERS.has(node.type)) return;
  const nested = inPipeline || node.type === 'pipeline';
  for (const child of node.children) collectCommands(child, out, nested);
}

function commandNameAndArgs(command: BashSyntaxNode): {
  name: string | undefined;
  args: string[];
  dropped: boolean;
} {
  const nameIndex = command.children.findIndex((child) => child.type === 'command_name');
  const nameNode = nameIndex >= 0 ? command.children[nameIndex] : undefined;
  const nameWord = nameNode?.children.find((child) => child.isNamed);
  const rawName = nameWord === undefined ? undefined : literalText(nameWord);
  if (rawName === undefined || rawName.length === 0 || rawName.includes('/')) {
    return { name: undefined, args: [], dropped: false };
  }
  const args: string[] = [];
  let dropped = false;
  for (const child of command.children.slice(nameIndex + 1)) {
    const value = literalText(child);
    if (value === undefined) {
      dropped = true;
    } else if (value.length > 0) {
      args.push(value);
    }
  }
  return { name: rawName, args, dropped };
}

function literalText(node: BashSyntaxNode): string | undefined {
  switch (node.type) {
    case 'word': {
      const raw = node.text;
      if (UNSAFE_OPERAND.test(raw)) return undefined;
      const unescaped = raw.replaceAll(/\\(.)/gs, '$1');
      return UNSAFE_OPERAND.test(unescaped) ? undefined : unescaped;
    }
    case 'number':
      return node.text;
    case 'raw_string': {
      if (node.text.length < 2) return undefined;
      const value = node.text.slice(1, -1);
      return UNSAFE_OPERAND.test(value) ? undefined : value;
    }
    case 'string': {
      let value = '';
      for (const child of node.children) {
        if (child.type === 'string_content') {
          value += child.text;
        } else if (child.isNamed) {
          return undefined;
        }
      }
      return UNSAFE_OPERAND.test(value) ? undefined : value;
    }
    default:
      return undefined;
  }
}

function dropFlags(args: readonly string[], command: string): string[] {
  const argumentTakingOptions =
    command === 'ls' || command === 'dir'
      ? LS_ARG_TAKING_OPTIONS
      : TREE_LIKE_ARG_TAKING_OPTIONS;
  const out: string[] = [];
  for (let i = 0; i < args.length; i += 1) {
    const arg = args[i]!;
    if (!arg.startsWith('-')) {
      out.push(arg);
      continue;
    }
    if (!arg.includes('=') && argumentTakingOptions.has(arg)) {
      i += 1;
    }
  }
  return out;
}

function takeLeadingPaths(args: readonly string[]): string[] {
  const out: string[] = [];
  for (const arg of args) {
    if (FIND_GLOBAL_OPTIONS.has(arg) || arg === '--') continue;
    if (arg.startsWith('-') || arg === '(' || arg === ')' || arg === '!') break;
    out.push(arg);
  }
  return out;
}