///|
/// 最小 X.509 证书结构解析(W3)。
///
/// 目标:把 `SignatureInfo.certificates` 的 DER 字节变成可合规初筛的结构事实。
/// **边界**:只解结构,不验签、不验证书链、不判信任;未知扩展一律跳过不报错。
///
/// 错误模型:畸形 DER / 关键结构缺失一律 `ApkError::BadSigningBlock(off, reason)`
/// (复用既有变体,不新增错误变体);`off` 为证书 DER 内偏移;不 panic、不越界。
///
/// 时间归一化:UTCTime 两位年按 X.509 规则(>=50 -> 19xx,<50 -> 20xx)输出
/// `"YYYY-MM-DDTHH:MM:SSZ"`;GeneralizedTime 直接按 4 位年解析。

///|
/// 单个 X.509 证书的结构事实(不含信任结论)。
pub(all) struct CertificateInfo {
  /// X.509 version 原始编码值:v1=0 / v2=1 / v3=2。
  version : Int32
  /// 序列号十六进制(小写,无前缀)。
  serial_hex : String
  /// RFC 4514 风格颁发者 DN(顺序与 DER 一致,如 `CN=Test CA,O=Example,C=US`)。
  issuer : String
  /// RFC 4514 风格主体 DN。
  subject : String
  /// 有效期起始(`"YYYY-MM-DDTHH:MM:SSZ"`)。
  not_before : String
  /// 有效期结束(同格式)。
  not_after : String
  /// 证书内签名算法 OID(点分十进制,如 `1.2.840.113549.1.1.11`)。
  signature_algo_oid : String
  /// 主体公钥算法 OID(如 `1.2.840.113549.1.1.1` = RSA)。
  public_key_algo_oid : String
  /// RSA 模长(位)/ EC 曲线估算位长;无法判定为 -1。
  public_key_bits : Int32
  /// 整份证书 DER 的 SHA-256 指纹(小写 hex)。
  sha256_fingerprint_hex : String
}

///|
/// 解析单个 X.509 证书 DER 字节;结构非法 raise `BadSigningBlock`。
pub fn parse_certificate(der : Bytes) -> CertificateInfo raise ApkError {
  let len = der.length()
  let outer = cert_tlv(der, 0, len, "certificate outer SEQUENCE")
  guard outer.tag == 0x30 else {
    raise ApkError::BadSigningBlock(0, "certificate outer tag is not SEQUENCE")
  }
  let tbs = cert_tlv(der, outer.body, outer.end, "tbsCertificate SEQUENCE")
  guard tbs.tag == 0x30 else {
    raise ApkError::BadSigningBlock(
      tbs.start,
      "tbsCertificate tag is not SEQUENCE",
    )
  }
  // TBS 子字段顺序:[0] version OPTIONAL / serialNumber / signature / issuer /
  // validity / subject / subjectPublicKeyInfo。
  let mut p = tbs.body
  let version_t = cert_tlv(der, p, tbs.end, "version")
  let mut version = 0
  if version_t.tag == 0xA0 {
    let v_int = cert_tlv(der, version_t.body, version_t.end, "version INTEGER")
    version = cert_int_value(der, v_int)
    p = version_t.end
  }
  let serial_t = cert_tlv(der, p, tbs.end, "serialNumber INTEGER")
  guard serial_t.tag == 0x02 else {
    raise ApkError::BadSigningBlock(
      serial_t.start,
      "serialNumber is not INTEGER",
    )
  }
  let serial_hex = cert_hex(der[serial_t.body:serial_t.end].to_owned())
  p = serial_t.end
  let sig_algo_t = cert_tlv(der, p, tbs.end, "signature AlgorithmIdentifier")
  guard sig_algo_t.tag == 0x30 else {
    raise ApkError::BadSigningBlock(
      sig_algo_t.start,
      "signature algo not SEQUENCE",
    )
  }
  let signature_algo_oid = cert_first_oid(der, sig_algo_t)
  p = sig_algo_t.end
  let issuer_t = cert_tlv(der, p, tbs.end, "issuer Name")
  guard issuer_t.tag == 0x30 else {
    raise ApkError::BadSigningBlock(issuer_t.start, "issuer not SEQUENCE")
  }
  let issuer = cert_dn(der, issuer_t)
  p = issuer_t.end
  let validity_t = cert_tlv(der, p, tbs.end, "validity SEQUENCE")
  guard validity_t.tag == 0x30 else {
    raise ApkError::BadSigningBlock(validity_t.start, "validity not SEQUENCE")
  }
  let not_before_t = cert_tlv(der, validity_t.body, validity_t.end, "notBefore")
  let not_after_t = cert_tlv(der, not_before_t.end, validity_t.end, "notAfter")
  let not_before = cert_time(der, not_before_t)
  let not_after = cert_time(der, not_after_t)
  p = validity_t.end
  let subject_t = cert_tlv(der, p, tbs.end, "subject Name")
  guard subject_t.tag == 0x30 else {
    raise ApkError::BadSigningBlock(subject_t.start, "subject not SEQUENCE")
  }
  let subject = cert_dn(der, subject_t)
  p = subject_t.end
  let spki_t = cert_tlv(der, p, tbs.end, "subjectPublicKeyInfo SEQUENCE")
  guard spki_t.tag == 0x30 else {
    raise ApkError::BadSigningBlock(spki_t.start, "SPKI not SEQUENCE")
  }
  let algo_t = cert_tlv(der, spki_t.body, spki_t.end, "SPKI algorithm")
  guard algo_t.tag == 0x30 else {
    raise ApkError::BadSigningBlock(algo_t.start, "SPKI algo not SEQUENCE")
  }
  let public_key_algo_oid = cert_first_oid(der, algo_t)
  let public_key_bits = cert_public_key_bits(
    der, spki_t, algo_t, public_key_algo_oid,
  )
  {
    version,
    serial_hex,
    issuer,
    subject,
    not_before,
    not_after,
    signature_algo_oid,
    public_key_algo_oid,
    public_key_bits,
    sha256_fingerprint_hex: cert_sha256_hex(der),
  }
}

///|
/// 聚合 APK 中全部证书 DER(v1 PKCS#7 + v2/v3/v3.1 signer)并按 DER 字节去重。
pub fn Apk::certificate_infos(
  self : Apk,
) -> Array[CertificateInfo] raise ApkError {
  let seen : Array[Bytes] = []
  let out : Array[CertificateInfo] = []
  for s in self.signatures() {
    for cert in s.certificates {
      let mut dup = false
      for x in seen {
        if x == cert {
          dup = true
        }
      }
      if !dup {
        seen.push(cert)
        out.push(parse_certificate(cert))
      }
    }
  }
  out
}

///|
/// 从 SPKI 估算公钥位长。RSA:解析 RSAPublicKey.modulus 字节数 x 8;
/// EC:按曲线 OID 映射位长(P-256/P-384/P-521);其余返回 -1。
fn cert_public_key_bits(
  der : Bytes,
  spki : CertTlv,
  algo : CertTlv,
  oid : String,
) -> Int32 {
  // subjectPublicKey BIT STRING 是 AlgorithmIdentifier 之后的下一个 TLV。
  let bitstr = match cert_tlv_opt(der, algo.end, spki.end) {
    Some(t) => t
    None => return -1
  }
  if bitstr.tag != 0x03 {
    return -1
  }
  // BIT STRING body 首字节为 unused-bits;其后是位串内容。
  if bitstr.body >= bitstr.end {
    return -1
  }
  let content = der[bitstr.body + 1:bitstr.end].to_owned()
  if oid == "1.2.840.113549.1.1.1" {
    // RSA RSAPublicKey:SEQUENCE { modulus INTEGER, publicExponent INTEGER }。
    let seq = match cert_tlv_opt(content, 0, content.length()) {
      Some(t) => t
      None => return -1
    }
    if seq.tag != 0x30 {
      return -1
    }
    let mod_int = match cert_tlv_opt(content, seq.body, seq.end) {
      Some(t) => t
      None => return -1
    }
    if mod_int.tag != 0x02 {
      return -1
    }
    let n = mod_int.end - mod_int.body
    // 整数位长:若首字节为 0x00 则是 DER 符号位填充,减 8;否则即 n*8。
    let mut bits = n * 8
    if n > 0 && content[mod_int.body].to_int() == 0 {
      bits = bits - 8
    }
    if bits < 0 {
      bits = 0
    }
    return bits
  }
  // EC 曲线 OID -> 位长。
  match oid {
    "1.2.840.10045.3.1.7" => 256
    "1.3.132.840.10045.3.1" => 384
    "1.3.132.840.10045.3.2" => 521
    _ => -1
  }
}

///|
/// DER TLV 结果(start/body/end 均为字节内偏移)。
priv struct CertTlv {
  tag : Int32
  start : Int32
  body : Int32
  end : Int32
}

///|
/// 读取一个 DER TLV;失败 raise `BadSigningBlock`(带上下文 reason)。
fn cert_tlv(
  der : Bytes,
  off : Int32,
  limit : Int32,
  reason : String,
) -> CertTlv raise ApkError {
  match cert_tlv_opt(der, off, limit) {
    Some(t) => t
    None =>
      raise ApkError::BadSigningBlock(
        cert_clamp(der, off),
        "DER TLV truncated: " + reason,
      )
  }
}

///|
/// 读取一个 DER TLV;越界/坏长度返回 None。短/长格式长度均支持(长度字节数上限 4)。
fn cert_tlv_opt(der : Bytes, off : Int32, limit : Int32) -> CertTlv? {
  if off < 0 || off + 2 > limit {
    return None
  }
  let tag = der[off].to_int()
  let l0 = der[off + 1].to_int()
  if l0 < 0x80 {
    let body = off + 2
    let end = body + l0
    if end > limit {
      return None
    }
    return Some({ tag, start: off, body, end, })
  }
  let n = l0 & 0x7F
  if n == 0 || n > 4 || off + 2 + n > limit {
    return None
  }
  let mut len = 0
  for i = 0; i < n; i = i + 1 {
    len = (len << 8) | der[off + 2 + i].to_int()
  }
  let body = off + 2 + n
  let end = body + len
  if end > limit || end < body {
    return None
  }
  Some({ tag, start: off, body, end, })
}

///|
/// 把偏移夹到 `[0, der.length()]`。
fn cert_clamp(der : Bytes, off : Int32) -> Int32 {
  if off < 0 {
    0
  } else if off > der.length() {
    der.length()
  } else {
    off
  }
}

///|
/// 读取整数 TLV 的值(大端;超 4 字节时只取低 4 字节)。
fn cert_int_value(der : Bytes, t : CertTlv) -> Int32 {
  let mut v = 0
  let n = t.end - t.body
  let start = if n > 4 { t.end - 4 } else { t.body }
  for i = start; i < t.end; i = i + 1 {
    v = (v << 8) | der[i].to_int()
  }
  v
}

///|
/// 取 SEQUENCE 内第一个 OID TLV 的点分十进制字符串。
fn cert_first_oid(der : Bytes, seq : CertTlv) -> String {
  let oid = match cert_tlv_opt(der, seq.body, seq.end) {
    Some(t) => t
    None => return ""
  }
  if oid.tag != 0x06 {
    return ""
  }
  cert_oid_dotted(der[oid.body:oid.end].to_owned())
}

///|
/// 把 OID 内容字节解码为点分十进制。
fn cert_oid_dotted(b : Bytes) -> String {
  if b.length() == 0 {
    return ""
  }
  let parts : Array[String] = []
  let first = b[0].to_int()
  parts.push((first / 40).to_string())
  parts.push((first % 40).to_string())
  let mut value = 0
  let mut started = false
  for i = 1; i < b.length(); i = i + 1 {
    let x = b[i].to_int()
    value = (value << 7) | (x & 0x7F)
    started = true
    if x < 0x80 {
      parts.push(value.to_string())
      value = 0
      started = false
    }
  }
  if started {
    parts.push(value.to_string())
  }
  let mut out = ""
  for i = 0; i < parts.length(); i = i + 1 {
    if i > 0 {
      out = out + "."
    }
    out = out + parts[i]
  }
  out
}

///|
/// 把 Name SEQUENCE 解码为 RFC 4514 风格 DN(多值按 DER 顺序拼接,逗号分隔)。
fn cert_dn(der : Bytes, name : CertTlv) -> String {
  let mut out = ""
  let mut rdn = name.body
  while rdn < name.end {
    let set = match cert_tlv_opt(der, rdn, name.end) {
      Some(t) => t
      None => break
    }
    if set.tag != 0x31 {
      break
    }
    let attr = match cert_tlv_opt(der, set.body, set.end) {
      Some(t) => t
      None => break
    }
    if attr.tag != 0x30 {
      break
    }
    let oid_t = match cert_tlv_opt(der, attr.body, attr.end) {
      Some(t) => t
      None => break
    }
    let val_t = match cert_tlv_opt(der, oid_t.end, attr.end) {
      Some(t) => t
      None => break
    }
    let key = match oid_t.tag {
      0x06 =>
        cert_oid_key(cert_oid_dotted(der[oid_t.body:oid_t.end].to_owned()))
      _ => "OID"
    }
    let val = cert_dn_value(der, val_t)
    if out != "" {
      out = out + ","
    }
    out = out + key + "=" + val
    rdn = set.end
  }
  out
}

///|
/// 常见 DN OID -> 短键;未知返回 `OID.`。
fn cert_oid_key(dotted : String) -> String {
  match dotted {
    "2.5.4.3" => "CN"
    "2.5.4.10" => "O"
    "2.5.4.11" => "OU"
    "2.5.4.6" => "C"
    "2.5.4.8" => "ST"
    "2.5.4.7" => "L"
    _ => "OID." + dotted
  }
}

///|
/// 取 RDN AttributeValue 的可打印字符串(UTF8String/PrintableString/IA5String 等)。
fn cert_dn_value(der : Bytes, t : CertTlv) -> String {
  @encoding/utf8.decode(der[t.body:t.end].to_owned()) catch {
    _ => ""
  }
}

///|
/// 解析 UTCTime / GeneralizedTime 为归一化 `YYYY-MM-DDTHH:MM:SSZ`。
fn cert_time(der : Bytes, t : CertTlv) -> String raise ApkError {
  let raw = @encoding/utf8.decode(der[t.body:t.end].to_owned()) catch {
    _ => ""
  }
  let sv = raw.trim()
  // UTCTime: "YYMMDDHHMMSSZ";GeneralizedTime: "YYYYMMDDHHMMSSZ"。
  let (year_off, year_len) = if t.tag == 0x18 { (0, 4) } else { (0, 2) }
  guard sv.length() >= year_len + 10 else {
    raise ApkError::BadSigningBlock(t.start, "invalid time string")
  }
  let mut year = cert_digit(sv, year_off, year_len)
  if year_len == 2 {
    year = if year >= 50 { 1900 + year } else { 2000 + year }
  }
  let month = cert_digit(sv, year_off + year_len, 2)
  let day = cert_digit(sv, year_off + year_len + 2, 2)
  let hour = cert_digit(sv, year_off + year_len + 4, 2)
  let minute = cert_digit(sv, year_off + year_len + 6, 2)
  let second = cert_digit(sv, year_off + year_len + 8, 2)
  cert_pad4(year) +
  "-" +
  cert_pad2(month) +
  "-" +
  cert_pad2(day) +
  "T" +
  cert_pad2(hour) +
  ":" +
  cert_pad2(minute) +
  ":" +
  cert_pad2(second) +
  "Z"
}

///|
/// 从字符串视图取两位数字(0..99);非数字返回 0(fail-closed,配合上游 raise)。
fn cert_digit(sv : StringView, off : Int32, len : Int32) -> Int32 {
  let mut v = 0
  let mut i = off
  while i < off + len {
    let c = sv[i].to_int()
    if c < 48 || c > 57 {
      return 0
    }
    v = v * 10 + (c - 48)
    i = i + 1
  }
  v
}

///|
fn cert_pad2(v : Int32) -> String {
  if v < 10 {
    "0" + v.to_string()
  } else {
    v.to_string()
  }
}

///|
fn cert_pad4(v : Int32) -> String {
  if v < 10 {
    "000" + v.to_string()
  } else if v < 100 {
    "00" + v.to_string()
  } else if v < 1000 {
    "0" + v.to_string()
  } else {
    v.to_string()
  }
}

///|
/// 字节串转小写 hex。
fn cert_hex(b : Bytes) -> String {
  let mut out = ""
  for x in b {
    let hi = (x.to_int() >> 4) & 0xF
    let lo = x.to_int() & 0xF
    out = out + cert_hex_nibble(hi) + cert_hex_nibble(lo)
  }
  out
}

///|
fn cert_hex_nibble(v : Int32) -> String {
  if v < 10 {
    v.to_string()
  } else {
    match v {
      10 => "a"
      11 => "b"
      12 => "c"
      13 => "d"
      14 => "e"
      _ => "f"
    }
  }
}

///|
/// 整份证书 DER 的 SHA-256 小写 hex。
fn cert_sha256_hex(der : Bytes) -> String {
  cert_hex(sha256(der))
}