///|
/// What a dyndep file says about one edge.
pub struct Dyndeps {
  edge : Edge
  mut used : Bool
  mut restat : Bool
  implicit_inputs : Array[Node]
  implicit_outputs : Array[Node]
}

///|
pub fn Dyndeps::restat(self : Dyndeps) -> Bool {
  self.restat
}

///|
pub fn Dyndeps::implicit_inputs(self : Dyndeps) -> Array[Node] {
  self.implicit_inputs
}

///|
pub fn Dyndeps::implicit_outputs(self : Dyndeps) -> Array[Node] {
  self.implicit_outputs
}

///|
/// The contents of a dyndep file, by edge (ninja's `DyndepFile`).
pub struct DyndepFile {
  entries : Map[Int32, Dyndeps]
}

///|
pub fn DyndepFile::new() -> DyndepFile {
  { entries: Map([]), }
}

///|
pub fn DyndepFile::length(self : DyndepFile) -> Int32 {
  self.entries.length()
}

///|
pub fn DyndepFile::get(self : DyndepFile, edge : Edge) -> Dyndeps? {
  self.entries.get(edge.id)
}

///|
/// Parses dyndep files: `ninja_dyndep_version = 1` followed by
/// `build out | implicit-outs: dyndep | implicit-ins` statements for edges
/// that already exist.
pub struct DyndepParser {
  state : State
  read : ((String) -> String raise NinjaError)?
  file : DyndepFile
  mut lexer : Lexer
  /// Dyndep files have no variables of their own.
  env : BindingEnv
}

///|
pub fn[R : FileReader] DyndepParser::new(
  state : State,
  reader : R,
  file : DyndepFile,
) -> DyndepParser {
  {
    state,
    read: Some(fn(path : String) raise NinjaError { reader.read_file(path) }),
    file,
    lexer: Lexer::new(""),
    env: BindingEnv::new(),
  }
}

///|
pub fn DyndepParser::without_files(
  state : State,
  file : DyndepFile,
) -> DyndepParser {
  { state, read: None, file, lexer: Lexer::new(""), env: BindingEnv::new(), }
}

///|
pub fn DyndepParser::load(
  self : DyndepParser,
  filename : String,
) -> Unit raise NinjaError {
  let contents = match self.read {
    Some(read) =>
      read(filename) catch {
        error => raise Error("loading '\{filename}': \{error.message()}")
      }
    None => raise Error("loading '\{filename}': No such file or directory")
  }
  self.parse(filename, contents)
}

///|
pub fn DyndepParser::parse_test(
  self : DyndepParser,
  input : String,
) -> Unit raise NinjaError {
  self.parse("input", input)
}

///|
pub fn DyndepParser::parse(
  self : DyndepParser,
  filename : String,
  input : String,
) -> Unit raise NinjaError {
  self.lexer = Lexer::new(input, filename~)
  // The version must come first, before any syntax it might not know.
  let mut have_version = false
  while true {
    let token = self.lexer.read_token()
    match token {
      Build => {
        if !have_version {
          raise self.lexer.fail("expected 'ninja_dyndep_version = ...'")
        }
        self.parse_edge()
      }
      Ident => {
        self.lexer.unread_token()
        if have_version {
          raise self.lexer.fail("unexpected \{token.name()}")
        }
        self.parse_dyndep_version()
        have_version = true
      }
      Error => raise self.lexer.fail(self.lexer.describe_last_error())
      Eof => {
        if !have_version {
          raise self.lexer.fail("expected 'ninja_dyndep_version = ...'")
        }
        return
      }
      Newline => ()
      _ => raise self.lexer.fail("unexpected \{token.name()}")
    }
  }
}

///|
fn DyndepParser::parse_let(
  self : DyndepParser,
) -> (String, EvalString) raise NinjaError {
  guard self.lexer.read_ident() is Some(key) else {
    raise self.lexer.fail("expected variable name")
  }
  let token = self.lexer.read_token()
  if token != Equals {
    raise self.lexer.fail(
      "expected \{Equals.name()}, got \{token.name()}\{Equals.error_hint()}",
    )
  }
  (key, self.lexer.read_var_value())
}

///|
fn DyndepParser::expect_token(
  self : DyndepParser,
  expected : Token,
) -> Unit raise NinjaError {
  let token = self.lexer.read_token()
  if token != expected {
    raise self.lexer.fail(
      "expected \{expected.name()}, got \{token.name()}\{expected.error_hint()}",
    )
  }
}

///|
fn DyndepParser::parse_dyndep_version(
  self : DyndepParser,
) -> Unit raise NinjaError {
  let (name, value) = self.parse_let()
  if name != "ninja_dyndep_version" {
    raise self.lexer.fail("expected 'ninja_dyndep_version = ...'")
  }
  let version = value.evaluate(self.env)
  let (major, minor) = parse_version(version)
  if major != 1 || minor != 0 {
    raise self.lexer.fail("unsupported 'ninja_dyndep_version = \{version}'")
  }
}

///|
fn DyndepParser::read_paths(
  self : DyndepParser,
) -> Array[EvalString] raise NinjaError {
  let paths = []
  while true {
    let path = self.lexer.read_path()
    if path.is_empty() {
      break
    }
    paths.push(path)
  }
  paths
}

///|
fn DyndepParser::nodes(
  self : DyndepParser,
  paths : Array[EvalString],
  into : Array[Node],
) -> Unit raise NinjaError {
  for eval in paths {
    let path = eval.evaluate(self.env)
    if path == "" {
      raise self.lexer.fail("empty path")
    }
    let (path, slash_bits) = canonicalize_path(
      path,
      platform=self.state.platform,
    )
    into.push(self.state.get_node(path, slash_bits))
  }
}

///|
fn DyndepParser::parse_edge(self : DyndepParser) -> Unit raise NinjaError {
  // One explicit output, which must already have an edge.
  let out0 = self.lexer.read_path()
  if out0.is_empty() {
    raise self.lexer.fail("expected path")
  }
  let path = out0.evaluate(self.env)
  if path == "" {
    raise self.lexer.fail("empty path")
  }
  let (path, _) = canonicalize_path(path, platform=self.state.platform)
  guard self.state.lookup_node(path) is Some(node) && node.in_edge is Some(edge) else {
    raise self.lexer.fail("no build statement exists for '\{path}'")
  }
  if self.file.entries.contains(edge.id) {
    raise self.lexer.fail("multiple statements for '\{path}'")
  }
  let dyndeps : Dyndeps = {
    edge,
    used: false,
    restat: false,
    implicit_inputs: [],
    implicit_outputs: [],
  }
  self.file.entries[edge.id] = dyndeps
  if !self.lexer.read_path().is_empty() {
    raise self.lexer.fail("explicit outputs not supported")
  }
  let outs = if self.lexer.peek_token(Pipe) { self.read_paths() } else { [] }
  self.expect_token(Colon)
  guard self.lexer.read_ident() is Some("dyndep") else {
    raise self.lexer.fail("expected build command name 'dyndep'")
  }
  if !self.lexer.read_path().is_empty() {
    raise self.lexer.fail("explicit inputs not supported")
  }
  let ins = if self.lexer.peek_token(Pipe) { self.read_paths() } else { [] }
  if self.lexer.peek_token(Pipe2) {
    raise self.lexer.fail("order-only inputs not supported")
  }
  self.expect_token(Newline)
  if self.lexer.peek_token(Indent) {
    let (key, value) = self.parse_let()
    if key != "restat" {
      raise self.lexer.fail("binding is not 'restat'")
    }
    dyndeps.restat = value.evaluate(self.env) != ""
  }
  self.nodes(ins, dyndeps.implicit_inputs)
  self.nodes(outs, dyndeps.implicit_outputs)
}

///|
/// Loads the dyndep file `node` and adds what it says to the edges that
/// name it in their `dyndep` binding. The file's contents go to `file`.
pub fn[R : FileReader] load_dyndeps(
  state : State,
  reader : R,
  node : Node,
  file~ : DyndepFile = DyndepFile::new(),
) -> Unit raise NinjaError {
  // The file is no longer pending once loaded.
  node.dyndep_pending = false
  DyndepParser::new(state, reader, file).load(node.path)
  apply_dyndeps(node, file)
}

///|
fn update_edge(edge : Edge, dyndeps : Dyndeps) -> Unit raise NinjaError {
  // The edge has its own scope, since it has a dyndep binding.
  if dyndeps.restat {
    edge.env.add_binding("restat", "1")
  }
  for node in dyndeps.implicit_outputs {
    edge.outputs.push(node)
  }
  edge.implicit_outs += dyndeps.implicit_outputs.length()
  for node in dyndeps.implicit_outputs {
    if node.in_edge is Some(_) {
      raise Error("multiple rules generate \{node.path}")
    }
    node.in_edge = Some(edge)
  }
  let at = edge.inputs.length() - edge.order_only_deps
  for i, node in dyndeps.implicit_inputs {
    edge.inputs.insert(at + i, node)
  }
  edge.implicit_deps += dyndeps.implicit_inputs.length()
  for node in dyndeps.implicit_inputs {
    node.out_edges.push(edge)
  }
}