///|
pub fn Faker::finance_account_name(self : Faker) -> String raise {
  self.sample("finance.account_type") + " Account"
}

///|
pub fn Faker::finance_account_number(
  self : Faker,
  length~ : Int32 = 8,
) -> String raise {
  self.numeric(length~)
}

///|
pub fn Faker::finance_amount(
  self : Faker,
  min~ : Double = 0,
  max~ : Double = 1000,
  decimals~ : Int32 = 2,
  symbol~ : String = "",
) -> String raise {
  symbol +
  fixed_decimal(self.float(min~, max~, fraction_digits=decimals), decimals)
}

///|
pub fn Faker::finance_pin(self : Faker, length~ : Int32 = 4) -> String raise {
  guard length >= 1 else {
    raise InvalidArgument("PIN length must be positive")
  }
  self.numeric(length~)
}

///|
pub fn Faker::finance_credit_card_cvv(self : Faker) -> String raise {
  self.numeric(length=3)
}

///|
pub fn Faker::finance_currency_code(self : Faker) -> String raise {
  self.finance_currency().code
}

///|
pub fn Faker::finance_currency_name(self : Faker) -> String raise {
  self.finance_currency().name
}

///|
pub fn Faker::finance_currency_numeric_code(self : Faker) -> String raise {
  self.finance_currency().numeric_code
}

///|
pub fn Faker::finance_currency_symbol(self : Faker) -> String raise {
  guard self.definition("finance.currency") is Array(values) else {
    raise InvalidDefinition("finance.currency")
  }
  let values = values.filter(v => json_string(json_field(v, "symbol")) != "")
  json_string(json_field(self.array_element(values), "symbol"))
}

///|
pub fn Faker::finance_routing_number(self : Faker) -> String raise {
  let body = self.sample("finance.federal_reserve_routing_symbol") +
    self.numeric(length=4)
  let mut sum = 0
  for i, c in body.to_array() {
    sum += (c.to_int() - 48) * [3, 7, 1][i % 3]
  }
  body + ((10 - sum % 10) % 10).to_string()
}

///|
pub fn Faker::finance_transaction_description(self : Faker) -> String raise {
  self.pattern("finance.transaction_description_pattern")
}

///|
pub fn Faker::finance_ethereum_address(self : Faker) -> String raise {
  self.hexadecimal(length=40, casing=Lower)
}

///|
pub fn Faker::finance_litecoin_address(self : Faker) -> String raise {
  let n = self.int(min=26, max=33)
  self.from_characters("LM3") +
  self.from_characters(
    "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ",
    length=n - 1,
  )
}

///|
pub fn Faker::finance_bitcoin_address(
  self : Faker,
  family? : String,
  testnet~ : Bool = false,
) -> String raise {
  let family = family.unwrap_or_else(() => {
    self.array_element(["legacy", "segwit", "bech32", "taproot"])
  })
  let (prefix, low, high, casing, exclude) = match family {
    "legacy" => (if testnet { "m" } else { "1" }, 26, 34, Mixed, "0OIl")
    "segwit" => (if testnet { "2" } else { "3" }, 26, 34, Mixed, "0OIl")
    "bech32" => (if testnet { "tb1" } else { "bc1" }, 42, 42, Lower, "1bBiIoO")
    "taproot" =>
      (if testnet { "tb1p" } else { "bc1p" }, 62, 62, Lower, "1bBiIoO")
    _ => raise InvalidArgument("unknown bitcoin address family")
  }
  prefix +
  self.alphanumeric(
    length=self.int(min=low, max=high) - prefix.length(),
    casing~,
    exclude~,
  )
}

///|
fn json_strings(value : Json) -> Array[String] raise {
  guard value is Array(xs) else {
    raise InvalidDefinition("expected string array")
  }
  xs.map(json_string)
}

///|
pub fn Faker::finance_bic(
  self : Faker,
  include_branch_code? : Bool,
) -> String raise {
  let branch = include_branch_code.unwrap_or_else(() => self.boolean())
  let bank = self.alpha(length=4, casing=Upper)
  let country = self.array_element(
    json_strings(json_field(iban_data, "iso3166")),
  )
  let location = self.alphanumeric(length=2, casing=Upper)
  let suffix = if branch {
    if self.boolean() {
      self.alphanumeric(length=3, casing=Upper)
    } else {
      "XXX"
    }
  } else {
    ""
  }
  bank + country + location + suffix
}

///|
fn mod97(value : String) -> Int32 {
  let mut remainder = 0
  for c in value {
    let n = if c is ('A'..<='Z') { c.to_int() - 55 } else { c.to_int() - 48 }
    remainder = (remainder * (if n >= 10 { 100 } else { 10 }) + n) % 97
  }
  remainder
}

///|
pub fn Faker::finance_iban(
  self : Faker,
  country_code? : String,
  formatted~ : Bool = false,
) -> String raise {
  guard json_field(iban_data, "formats") is Array(formats) else {
    raise InvalidDefinition("IBAN formats")
  }
  let format = match country_code {
    None => self.array_element(formats)
    Some(country) => {
      let matching = formats.filter(f => {
        json_string(json_field(f, "country")) == country
      })
      guard !matching.is_empty() else {
        raise InvalidArgument("unsupported IBAN country")
      }
      matching[0]
    }
  }
  let country = json_string(json_field(format, "country"))
  guard json_field(format, "bban") is Array(parts) else {
    raise InvalidDefinition("BBAN")
  }
  let out = StringBuilder()
  for part in parts {
    let kind = json_string(json_field(part, "type"))
    let count = json_int(json_field(part, "count"))
    let block = StringBuilder()
    let mut remaining = count
    while remaining > 0 {
      match kind {
        "a" => block.write_string(self.alpha(casing=Upper))
        "c" =>
          block.write_string(
            if self.boolean(probability=0.8) {
              self.numeric()
            } else {
              self.alpha(casing=Upper)
            },
          )
        _ =>
          if remaining >= 3 && self.boolean(probability=0.3) {
            let key = if self.boolean() {
              remaining -= 2
              "pattern100"
            } else {
              remaining -= 1
              "pattern10"
            }
            block.write_string(
              self.array_element(json_strings(json_field(iban_data, key))),
            )
          } else {
            block.write_string(self.numeric())
          }
      }
      remaining -= 1
    }
    out.write_string(block.to_string()[:count].to_owned())
  }
  let body = out.to_string()
  let result = country +
    (98 - mod97(body + country + "00")).to_string().pad_start(2, '0') +
    body
  if formatted {
    group_string(result, 4, " ")
  } else {
    result
  }
}

///|
fn group_string(value : String, count : Int32, separator : String) -> String {
  let parts : Array[String] = []
  for start = 0; start < value.length(); start = start + count {
    parts.push(value[start:(start + count).min(value.length())].to_owned())
  }
  parts.join(separator)
}