gem 'shell_parser'

Word = Struct.new(:parts, :pos, :len)
# parts: array of Literal, Variable, or CommandSub
# pos: character position in input
# len: total length

Literal = Struct.new(:value, :pos, :len, :quote_style)
# value: the text content
# quote_style: :none, :single, or :double

Variable = Struct.new(:name, :pos, :len, :braced, :quote_style)
# name: variable name (e.g., "HOME" for $HOME)
# braced: true if ${VAR} form, false if $VAR
# quote_style: :none or :double (variables don't expand in single quotes)

CommandSub = Struct.new(:command, :pos, :len, :style, :quote_style)
# command: the command text to execute
# style: :dollar for $(cmd) or :backtick for `cmd`
# quote_style: :none or :double

Command = Struct.new(:words, :redirects)
# words: array of Word nodes
# redirects: array of Redirect nodes

Pipeline = Struct.new(:commands, :negated)
# commands: array of Command nodes
# negated: boolean (for future ! pipeline support)

List = Struct.new(:left, :op, :right)
# left/right: Command, Pipeline, or List
# op: :and (&&), :or (||), :semi (;), :background (&)

Redirect = Struct.new(:type, :fd, :target)
# type: :in (<), :out (>), :append (>>), :heredoc (<<), etc.
# fd: file descriptor number (optional)
# target: Word node

require_relative 'shell_parser'

# Parse a command
ast = ShellParser.parse("ls -la /tmp")
# => Command with 3 words

# Parse a pipeline
ast = ShellParser.parse("cat file.txt | grep error | wc -l")
# => Pipeline with 3 commands

# Parse command lists
ast = ShellParser.parse("make && make test || echo failed")
# => List with nested lists

ast = ShellParser.parse("echo $HOME > output.txt")

ast.words.each do |word|
  word.parts.each do |part|
    case part
    when ShellParser::Literal
      case part.quote_style
      when :single then highlight_single_quoted(part.value, part.pos, part.len)
      when :double then highlight_double_quoted(part.value, part.pos, part.len)
      else highlight_literal(part.value, part.pos, part.len)
      end
    when ShellParser::Variable
      highlight_variable(part.name, part.pos, part.len, part.braced)
    when ShellParser::CommandSub
      highlight_command_sub(part.command, part.pos, part.len, part.style)
    end
  end
end

ast.redirects.each do |redir|
  highlight_redirection(redir.type, redir.target)
end

# "Hello $USER" is represented as:
word.parts #=> [
  Literal("Hello ", quote_style: :double),
  Variable("USER", quote_style: :double)
]

ast = ShellParser.parse("echo $HOME > output.txt")

# Expand words by processing their parts
def expand_word(word)
  word.parts.map do |part|
    case part
    when ShellParser::Literal
      part.value  # Use as-is
    when ShellParser::Variable
      ENV[part.name] || ""  # Look up variable
    when ShellParser::CommandSub
      `#{part.command}`.chomp  # Execute command
    end
  end.join
end

# Execute based on AST structure
case ast
when ShellParser::Command
  args = ast.words.map { |w| expand_word(w) }
  execute_command(args, ast.redirects)

when ShellParser::Pipeline
  setup_pipe do
    ast.commands.each do |cmd|
      args = cmd.words.map { |w| expand_word(w) }
      execute_in_pipeline(args, cmd.redirects)
    end
  end

when ShellParser::List
  result = execute(ast.left)
  case ast.op
  when :and then execute(ast.right) if result == 0
  when :or then execute(ast.right) if result != 0
  when :semi then execute(ast.right)
  when :background then fork { execute(ast.right) }
  end
end

part.quote_style == :none    # Apply glob expansion and word splitting
part.quote_style == :single  # Use literal value, no expansion
part.quote_style == :double  # Expand variables/commands, but no glob/split