///|
pub fn mbt_string_to_utf8_bytes(str : String, is_filename : Bool) -> Bytes {
  let buf = @buffer.new()
  @encoding.encode_to(str, buf, encoding=UTF8)
  if is_filename {
    buf.write_byte((0).to_byte())
  }
  buf.to_bytes()
}

///|
pub fn utf8_bytes_to_mbt_string(bytes : Bytes) -> String raise {
  let decoder = @encoding.decoder(UTF8)
  decoder.consume(bytes)
}

///|
fn parse_address(input : String) -> Result[SocketAddr, String] {
  // 先尝试解析 IPv6 格式 [addr]:port
  if input.has_prefix("[") {
    return try_parse_ipv6(input)
  }
  // 否则尝试解析 IPv4 格式 addr:port
  return try_parse_ipv4(input)
}

///|
fn parse_ipv6_str(ip_str : String) -> Result[String, String] {
  // 处理特殊压缩情况 (::)
  println("Parsing IPv6 string: \{ip_str}")
  if ip_str == "::" {
    return Ok("0:0:0:0:0:0:0:0")
  }

  // 分割字符串部分
  let parts = ip_str.split(":").collect()
  let part_count = parts.length()

  // 检查压缩形式 (::)
  let mut compression_index = -1
  for i in 0..= 0 {
        return Err("IPv6 address can't have multiple '::'".to_string())
      }
      compression_index = i
    }
  }
  // 计算需要填充的零组数量
  let mut zero_groups = 8 - part_count + 1
  if compression_index >= 0 {
    // 压缩形式存在
    if zero_groups < 1 {
      return Err("IPv6 address has too many parts".to_string())
    }
  } else {
    // 没有压缩形式
    zero_groups = 0
    guard part_count == 8 else {
      return Err("IPv6 address must have 8 parts".to_string())
    }
  }

  // 解析各部分
  let groups = Array::make(8, UInt::default())
  let mut index = 0
  for i in 0.. bytes
        Err(e) => return Err(e)
      }
      groups[index] = (ipv4_bytes[0] << 8) | ipv4_bytes[1]
      groups[index + 1] = (ipv4_bytes[2] << 8) | ipv4_bytes[3]
      index += 2
    } else {
      // 解析十六进制组
      guard !part.is_empty() else { // 跳过空部分
        continue
      }
      match (try? @strconv.parse_uint(part.to_string(), base=16)) {
        Ok(num) => {
          guard num <= 0xFFFF else {
            return Err("IPv6 group out of range".to_string())
          }
          groups[index] = num
          index += 1
        }
        _ => return Err("Invalid hex in IPv6 address".to_string())
      }
    }
  }

  // 验证最终组数
  guard index == 8 else {
    return Err("IPv6 address must have 8 groups".to_string())
  }
  Ok(groups.map(g => g.to_string()).join(":"))
}

///|
fn parse_ipv4_to_bytes(ip_str : @string.View) -> Result[Array[UInt], String] {
  let parts = ip_str.split(".").collect()
  guard parts.length() == 4 else {
    return Err("IPv4 address must have 4 parts")
  }
  let octets = Array::make(4, UInt::default())
  for i in 0..<4 {
    let part = parts[i].to_string()
    match (try? @strconv.parse_uint(part)) {
      Ok(num) => {
        guard num >= 0 && num <= 255 else {
          return Err("IP segment out of range (0-255)".to_string())
        }
        octets[i] = num
      }
      _ => return Err("Invalid number in IP address".to_string())
    }
  }
  Ok(octets)
}

///|
fn try_parse_ipv4(input : String) -> Result[SocketAddr, String] {
  // 找到最后一个冒号（端口分隔符）
  guard input.rev_find(":") is Some(last_colon) else {
    return Err("Invalid IPv4 address format: missing port".to_string())
  }

  // 提取 IP 部分字符串
  let ip_str = input
    .charcodes(end=input.offset_of_nth_char(last_colon).unwrap())
    .to_string()

  // 提取端口部分字符串
  let port_str = input
    .charcodes(start=input.offset_of_nth_char(last_colon + 1).unwrap())
    .to_string()

  // 解析 IPv4 地址
  let ip = match parse_ipv4_str(ip_str) {
    Ok(ip) => ip
    Err(e) => return Err(e)
  }

  // 解析端口号
  let port = match parse_port(port_str) {
    Ok(port) => port
    Err(_) => return Err("Invalid port number".to_string())
  }
  Ok(SocketAddr::V4(ip, port))
}

// 手动实现 IPv4 地址解析

///|
fn parse_ipv4_str(ip_str : String) -> Result[String, String] {
  let parts = Array::new()
  let mut current = []
  // 分割 IP 字符串为四个部分
  for i in 0.. {
        // 验证范围 (0-255)
        guard num >= 0 && num <= 255 else {
          return Err("IP segment out of range (0-255)".to_string())
        }
        octets[index] = num.to_string()
        index += 1
      }
      _ => return Err("Invalid number in IP address".to_string())
    }
  }
  return Ok(octets.join("."))
}

// IPv6 解析函数

///|
fn try_parse_ipv6(input : String) -> Result[SocketAddr, String] {

  // 查找端口分隔符
  guard input.rev_find(":") is Some(colon_pos) else {
    return Err("Missing port after IPv6 address".to_string())
  }
  let ip_part = input
    .charcodes(end=input.offset_of_nth_char(colon_pos).unwrap())
    .to_string()
  // 提取端口部分
  let port_str = input
    .charcodes(start=input.offset_of_nth_char(colon_pos + 1).unwrap())
    .to_string()
  guard ip_part.trim_space() is [a, .. res, b] && a == '[' && b == ']' else {
    return Err("Invalid IPv6 address format".to_string())
  }

  // 提取 IPv6 地址部分
  let ip_str = res.to_string()

  // 解析 IPv6 地址（简化的实现）
  let ip = match parse_ipv6_str(ip_str) {
    Ok(ip) => ip
    Err(e) => return Err(e)
  }

  // 解析端口
  let port = match parse_port(port_str) {
    Ok(port) => port
    Err(_) => return Err("Invalid port number".to_string())
  }
  Ok(SocketAddr::V6(ip, port, flowinfo=0, scope_id=0))
}

// 端口解析函数

///|
fn parse_port(port_str : String) -> Result[UInt16, String] {
  match (try? @strconv.parse_int(port_str)) {
    Ok(port) => {
      guard port >= 0 && port <= 65535 else {
        return Err("Port out of range (0-65535)".to_string())
      }
      Ok(port.to_uint16())
    }
    _ => Err("Invalid port number".to_string())
  }
}