// IF / IFERROR are lazy; AND / OR are eager (AND(TRUE,1/0) is #DIV/0!).

fn fn_if(_ctx : Ctx, args : Array[Thunk]) -> Value {
  match to_bool(scalarize(args[0]())) {
    Err(e) => Value::Err(e)
    Ok(b) =>
      if b {
        args[1]()
      } else if args.length() == 3 {
        args[2]()
      } else {
        Value::Bool(false)
      }
  }
}

// AND/OR argument channels, matching Excel:
// * references: numbers and booleans are used (numbers as <>0), text and
//   blanks are ignored, errors propagate;
// * literals: numbers/booleans used, text "TRUE"/"FALSE" parsed and any
//   other text ignored, errors propagate.
// If no logical value is found at all the result is #VALUE!.
fn and_or(args : Array[Thunk], want_all : Bool) -> Value {
  let vals = eager(args)
  let mut result = want_all
  let mut seen = false
  for v in vals {
    match v {
      Range(r) =>
        for c in r.cells {
          match c {
            Bool(b) => {
              seen = true
              result = if want_all { result && b } else { result || b }
            }
            Num(d) => {
              seen = true
              let b = d != 0.0
              result = if want_all { result && b } else { result || b }
            }
            Err(e) => return Value::Err(e)
            _ => ()
          }
        }
      _ =>
        match scalarize(v) {
          Bool(b) => {
            seen = true
            result = if want_all { result && b } else { result || b }
          }
          Num(d) => {
            seen = true
            let b = d != 0.0
            result = if want_all { result && b } else { result || b }
          }
          Text(t) =>
            if t.compare_ignore_ascii_case("TRUE") == 0 {
              seen = true
              result = if want_all { result } else { true }
            } else if t.compare_ignore_ascii_case("FALSE") == 0 {
              seen = true
              result = if want_all { false } else { result }
            }
          Err(e) => return Value::Err(e)
          _ => ()
        }
    }
  }
  if !seen {
    return Value::Err(XlError::Value)
  }
  Value::Bool(result)
}

fn fn_and(_ctx : Ctx, args : Array[Thunk]) -> Value {
  and_or(args, true)
}

fn fn_or(_ctx : Ctx, args : Array[Thunk]) -> Value {
  and_or(args, false)
}

fn fn_not(_ctx : Ctx, args : Array[Thunk]) -> Value {
  match to_bool(scalarize(args[0]())) {
    Err(e) => Value::Err(e)
    Ok(b) => Value::Bool(!b)
  }
}

fn fn_iferror(_ctx : Ctx, args : Array[Thunk]) -> Value {
  let v = scalar_output(args[0]())
  match v {
    Err(_) => args[1]()
    _ => v
  }
}
// IFS(cond1, value1, cond2, value2, ...) — lazy: conditions are evaluated in
// order and only the winning value is evaluated; no match -> #N/A; an odd
// argument count is a shape error (#VALUE!).
fn fn_ifs(_ctx : Ctx, args : Array[Thunk]) -> Value {
  if args.length() % 2 != 0 {
    return Value::Err(XlError::Value)
  }
  let mut i = 0
  while i + 1 < args.length() {
    let cond = match args[i]() {
      Err(e) => return Value::Err(e)
      v => scalarize(v)
    }
    match to_bool(cond) {
      Err(e) => return Value::Err(e)
      Ok(true) => return args[i + 1]()
      Ok(false) => ()
    }
    i += 2
  }
  Value::Err(XlError::NA)
}

// SWITCH(expr, value1, result1, [value2, result2, ...], [default]) — expr is
// evaluated once; comparison uses Excel "=" semantics (cell_eq, no wildcards);
// the matching result (or the trailing default) is evaluated lazily.
fn fn_switch(_ctx : Ctx, args : Array[Thunk]) -> Value {
  let expr = match args[0]() {
    Err(e) => return Value::Err(e)
    v => scalarize(v)
  }
  match expr {
    // Real Excel propagates an error expression / candidate immediately
    // (corpus logic-switch-0008 / 0009), it is not treated as a no-match.
    Err(e) => return Value::Err(e)
    Range(_) => return Value::Err(XlError::Value)
    _ => ()
  }
  let mut i = 1
  while i + 1 < args.length() {
    let candidate = match args[i]() {
      Err(e) => return Value::Err(e)
      v => scalarize(v)
    }
    match candidate {
      Err(e) => return Value::Err(e)
      Range(_) => return Value::Err(XlError::Value)
      _ => ()
    }
    if cell_eq(expr, candidate) {
      return args[i + 1]()
    }
    i += 2
  }
  // A trailing unpaired argument is the default value.
  if i < args.length() {
    return args[i]()
  }
  Value::Err(XlError::NA)
}