///|
fn Faker::mime_types(self : Faker) -> Map[String, Json] raise {
  match self.definition("system.mime_type") {
    Object(fields) => fields
    _ => raise InvalidDefinition("system.mime_type")
  }
}

///|
pub fn Faker::system_mime_type(self : Faker) -> String raise {
  self.array_element(self.mime_types().keys().to_array())
}

///|
pub fn Faker::system_file_type(self : Faker) -> String raise {
  let types : Array[String] = []
  for key, _ in self.mime_types() {
    let group = key.split("/").next().unwrap().to_owned()
    if !types.contains(group) {
      types.push(group)
    }
  }
  self.array_element(types)
}

///|
pub fn Faker::system_file_ext(
  self : Faker,
  mime_type? : String,
) -> String raise {
  let types = self.mime_types()
  if mime_type is Some(key) {
    guard types.get(key) is Some({ "extensions": Array(values), .. }) else {
      raise InvalidArgument("unsupported MIME type: " + key)
    }
    return json_string(self.array_element(values))
  }
  let extensions : Array[String] = []
  for _, value in types {
    if value is { "extensions": Array(values), .. } {
      for value in values {
        let ext = json_string(value)
        if !extensions.contains(ext) {
          extensions.push(ext)
        }
      }
    }
  }
  self.array_element(extensions)
}

///|
pub fn Faker::system_common_file_ext(self : Faker) -> String raise {
  self.system_file_ext(
    mime_type=self.array_element([
      "application/pdf", "audio/mpeg", "audio/wav", "image/png", "image/jpeg", "image/gif",
      "video/mp4", "video/mpeg", "text/html",
    ]),
  )
}

///|
pub fn Faker::system_common_file_type(self : Faker) -> String raise {
  self.array_element(["video", "audio", "image", "text", "application"])
}

///|
pub fn Faker::system_file_name(
  self : Faker,
  extension_count~ : Int32 = 1,
) -> String raise {
  let name = String::from_array(
    @unicode.lower(self.word_words())
    .to_array()
    .map(c => if c is ('a'..<='z' | '0'..<='9' | '_') { c } else { '_' }),
  )
  let suffix = multiple(_ => self.system_file_ext(), count=extension_count).join(
    ".",
  )
  if suffix == "" {
    name
  } else {
    name + "." + suffix
  }
}

///|
pub fn Faker::system_common_file_name(
  self : Faker,
  extension? : String,
) -> String raise {
  let name = self.system_file_name(extension_count=0)
  let ext = match extension {
    Some(s) if s != "" => s
    _ => self.system_common_file_ext()
  }
  name + "." + ext
}

///|
pub fn Faker::system_directory_path(self : Faker) -> String raise {
  self.sample("system.directory_path")
}

///|
pub fn Faker::system_file_path(self : Faker) -> String raise {
  self.system_directory_path() + "/" + self.system_file_name()
}

///|
pub fn Faker::system_semver(self : Faker) -> String raise {
  "\{self.int(max=9)}.\{self.int(max=20)}.\{self.int(max=20)}"
}

///|
pub fn Faker::system_cron(
  self : Faker,
  include_year~ : Bool = false,
  include_non_standard~ : Bool = false,
) -> String raise {
  let minutes = [self.int(max=59).to_string(), "*"]
  let hours = [self.int(max=23).to_string(), "*"]
  let days = [self.int(min=1, max=31).to_string(), "*", "?"]
  let months = [self.int(min=1, max=12).to_string(), "*"]
  let weekdays = [
    self.int(max=6).to_string(),
    self.array_element(["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"]),
    "*",
    "?",
  ]
  let years = [self.int(min=1970, max=2099).to_string(), "*"]
  let result = [
    self.array_element(minutes),
    self.array_element(hours),
    self.array_element(days),
    self.array_element(months),
    self.array_element(weekdays),
  ]
  let year = self.array_element(years)
  if include_year {
    result.push(year)
  }
  if !include_non_standard || self.boolean() {
    result.join(" ")
  } else {
    self.array_element([
      "@annually", "@daily", "@hourly", "@monthly", "@reboot", "@weekly", "@yearly",
    ])
  }
}

///|
pub fn Faker::system_network_interface(
  self : Faker,
  interface_type? : String,
  schema? : String,
) -> String raise {
  let kind = interface_type.unwrap_or_else(() => {
    self.array_element(["en", "wl", "ww"])
  })
  let schema = schema.unwrap_or_else(() => {
    self.array_element(["index", "slot", "mac", "pci"])
  })
  fn optional_suffix(letter : String) -> String raise {
    if self.boolean() {
      letter + self.numeric()
    } else {
      ""
    }
  }
  match schema {
    "index" => kind + "o" + self.numeric()
    "slot" =>
      kind + "s" + self.numeric() + optional_suffix("f") + optional_suffix("d")
    "mac" => kind + "x" + self.internet_mac(separator="")
    "pci" => {
      let prefix = optional_suffix("P")
      prefix +
      kind +
      "p" +
      self.numeric() +
      "s" +
      self.numeric() +
      optional_suffix("f") +
      optional_suffix("d")
    }
    _ => raise InvalidArgument("invalid interface schema")
  }
}

///|
pub fn Faker::database_mongodb_object_id(self : Faker) -> String raise {
  self.hexadecimal(length=24, prefix="", casing=Lower)
}