///|
fn require(ok : Bool, message : String) -> Unit raise BranchError {
  if !ok {
    raise Invalid(message)
  }
}

///|
fn valid_name(name : String) -> Bool {
  if name.length() == 0 || name.length() > 63 {
    return false
  }
  for i, c in name {
    if !((c >= 'a' && c <= 'z') || c == '_' || (i > 0 && c >= '0' && c <= '9')) {
      return false
    }
  }
  true
}

///|
fn names_in(names : Array[String], columns : Array[String]) -> Bool {
  let seen : Map[String, Bool] = Map([])
  for name in names {
    if !columns.contains(name) || seen.contains(name) {
      return false
    }
    seen[name] = true
  }
  !names.is_empty()
}

///|
pub fn validate(spec : Spec) -> Unit raise BranchError {
  require(spec.version == 1, "unsupported recipe version")
  require(valid_name(spec.schema), "invalid schema identifier")
  require(spec.max_rows > 0, "max_rows must be positive")
  require(
    !spec.tables.is_empty() && !spec.roots.is_empty(),
    "tables and roots are required",
  )
  let tables : Map[String, Table] = Map([])
  for table in spec.tables {
    require(valid_name(table.name), "invalid table identifier")
    require(!tables.contains(table.name), "duplicate table: \{table.name}")
    tables[table.name] = table
    require(
      names_in(table.columns, table.columns),
      "columns must be nonempty and unique in \{table.name}",
    )
    require(
      table.columns.all(valid_name),
      "invalid column identifier in \{table.name}",
    )
    require(
      names_in(table.key, table.columns),
      "invalid primary key for \{table.name}",
    )
  }
  for table in spec.tables {
    let seen_fks : Map[String, Bool] = Map([])
    for fk in table.foreign_keys {
      guard tables.get(fk.parent) is Some(parent) else {
        raise Invalid("missing foreign key parent for \{table.name}")
      }
      require(
        names_in(fk.columns, table.columns),
        "invalid foreign key columns in \{table.name}",
      )
      require(
        fk.columns.length() == fk.references.length() &&
        fk.references == parent.key,
        "foreign keys must reference the entire declared primary key of \{parent.name}",
      )
      let signature = @json.ToJson::to_json(fk).stringify()
      require(
        !seen_fks.contains(signature),
        "duplicate foreign key in \{table.name}",
      )
      seen_fks[signature] = true
    }
  }
  for root in spec.roots {
    guard tables.get(root.table) is Some(table) else {
      raise Invalid("unknown root table")
    }
    require(!root.keys.is_empty(), "each root needs at least one key")
    for key in root.keys {
      require(
        key.length() == table.key.length() && key.all(fn(v) { v is String(_) }),
        "root key for \{root.table} must be an array of text values matching the primary key",
      )
    }
  }
  validate_masks(spec, tables)
  for edge in spec.follow {
    guard tables.get(edge.child) is Some(child) else {
      raise Invalid("unknown follow child table")
    }
    require(
      edge.foreign_key >= 0 && edge.foreign_key < child.foreign_keys.length(),
      "invalid follow foreign key index",
    )
    require(
      child.foreign_keys[edge.foreign_key].parent == edge.from,
      "follow source must match foreign key parent",
    )
  }
}