///|
/// APK 签名**结构 + 摘要**校验(v1 JAR / v2 / v3 / v3.1)。
///
/// 边界(硬性):
/// - 本模块能做:解析签名块结构、解析 v1 JAR 的 `MANIFEST.MF` / `.SF` / PKCS#7 封装、
///   校验 v1 条目摘要与清单摘要(SHA-256 / SHA-512)、校验 v2/v3/v3.1 的 APK 内容分块摘要(SHA-256)。
/// - 本模块**不能做**:RSA / ECDSA / DSA 公钥验签(MoonBit 无密码学 stdlib,本库也未
///   实现大数公钥运算)。因此 `verified == true` 的语义是「结构合法且摘要一致」,
///   **不等于签名有效**;`SignatureCheck.signature_verified` 恒为 `false`。
///
/// 摘要对象(AOSP APK Signature Scheme v2/v3 规范):
///   section1 = ZIP 条目区 [0, signing_block_start)
///   section2 = 中央目录区
///   section3 = EOCD(其「中央目录偏移」字段改写为 signing block 起始偏移)
///   每个 section 按 1 MiB 切片,chunk digest = SHA-256(0xa5 || chunk_len_u32le || chunk);
///   内容摘要 = SHA-256(0x5a || chunk_count_u32le || concat(chunk_digests))。
///   该口径已用 apksigner 自产样本(fx-multidex-v2v3 / tvshell-debug)实测对齐。

///|
/// 签名者的一条摘要记录(v2/v3/v3.1 signed data 的 digests 序列项)。
priv struct SignerDigest {
  algorithm : UInt32
  digest : Bytes
}

///|
/// 签名者结构:DER 证书 + 摘要记录(v1 的摘要来自 JAR 清单,不在本结构)。
priv struct SignerData {
  certs : Array[Bytes]
  digests : Array[SignerDigest]
}

///|
/// 一个已识别的签名方案记录(内部)。
priv struct SigRecord {
  scheme : SignatureScheme
  block_id : UInt32
  certs : Array[Bytes]
  digests : Array[SignerDigest]
  pkcs7_ok : Bool
  v1_sf : String?
  v1_manifest : String?
  /// 签名方案 value 在原文件中的偏移与长度(v2/v3/v3.1 验签用)。
  value_off : Int32
  value_len : Int32
  /// v1 PKCS#7 签名块条目名(`META-INF/*.RSA|*.DSA|*.EC`,v1 验签用)。
  v1_block : String?
}

///|
/// 签名校验结论(结构 + 摘要,**不含**公钥验签)。
pub(all) struct SignatureCheck {
  scheme : SignatureScheme
  /// 结构解析是否通过(v1:PKCS#7/MANIFEST/.SF 齐全且可解析;v2/v3:signer 证书与摘要记录可解析)。
  structure_ok : Bool
  /// 本地可验证的摘要是否全部一致(v1 条目摘要 + 清单摘要;v2/v3 内容分块摘要)。
  digest_ok : Bool
  /// 摘要算法名(`"SHA-256"` / `"SHA-512"` / `"unknown"`;空串表示未识别)。
  digest_algorithm : String
  /// v1:校验过的 MANIFEST 条目数;v2/v3:0。
  entries_checked : Int32
  /// v1:摘要不一致或条目缺失的条目数;v2/v3:0。
  entries_failed : Int32
  /// 公钥验签是否通过。本库未实现 RSA/ECDSA 验签,**恒为 false**。
  signature_verified : Bool
  /// 人类可读结论 / 失败原因(用于诊断,不参与判定)。
  detail : String
}

///|
/// 返回每个已识别签名方案的结构 + 摘要校验结论。
///
/// 与 `Apk::signatures()` 使用同一套结构解析;`SignatureCheck.signature_verified`
/// 恒为 false(未做公钥验签),`digest_ok` 只代表摘要一致。
pub fn Apk::signature_checks(
  self : Apk,
) -> Array[SignatureCheck] raise ApkError {
  let out : Array[SignatureCheck] = []
  for rec in self.collect_signature_records() {
    out.push(self.verify_signature_record(rec))
  }
  out
}

///|
/// 收集已识别签名方案记录(v1 优先,v2/v3/v3.1 按块内顺序),按方案排序。
fn Apk::collect_signature_records(
  self : Apk,
) -> Array[SigRecord] raise ApkError {
  let out : Array[SigRecord] = []
  // v1:META-INF/*.RSA|*.DSA|*.EC 存在即识别;证书从 PKCS#7 提取。
  let mut v1_block : String? = None
  for e in self.entries {
    if v1_block is None &&
      e.name.has_prefix("META-INF/") &&
      (
        e.name.has_suffix(".RSA") ||
        e.name.has_suffix(".DSA") ||
        e.name.has_suffix(".EC")
      ) {
      v1_block = Some(e.name)
    }
  }
  match v1_block {
    Some(block_name) => {
      let block_bytes = self.safe_entry(block_name).unwrap_or(b"")
      let certs = pkcs7_certificates(block_bytes)
      let pkcs7_ok = certs.length() > 0
      let stem = block_name[:block_name.length() - 4].to_owned()
      let sf_name = stem + ".SF"
      let manifest_name = "META-INF/MANIFEST.MF"
      out.push({
        scheme: SignatureScheme::V1,
        block_id: 0,
        certs,
        digests: [],
        pkcs7_ok,
        v1_sf: Some(sf_name),
        v1_manifest: Some(manifest_name),
        value_off: 0,
        value_len: 0,
        v1_block: Some(block_name),
      })
    }
    None => ()
  }
  match self.signing_block_off {
    None => ()
    Some(sb) => {
      let block_start = sb.to_int()
      let size = le_u64(self.source, block_start)
      let pairs_start = block_start + 8
      let pairs_end = block_start + size.to_int() - 16
      let mut pos = pairs_start
      let mut recognized = 0
      while pos < pairs_end {
        guard pos + 8 <= pairs_end else {
          raise ApkError::BadSigningBlock(
            pos, "truncated ID-value pair length in APK Signing Block",
          )
        }
        let pair_len = le_u64(self.source, pos)
        guard pair_len >= 4 && pair_len - 4 <= (pairs_end - pos - 8).to_uint64() else {
          raise ApkError::BadSigningBlock(
            pos, "ID-value pair overruns APK Signing Block",
          )
        }
        let id = le_u32(self.source, pos + 8)
        let value_off = pos + 12
        let value_len = pair_len.to_int() - 4
        if id == SIG_ID_V2 || id == SIG_ID_V3 || id == SIG_ID_V31 {
          let sch = if id == SIG_ID_V2 {
            SignatureScheme::V2
          } else if id == SIG_ID_V3 {
            SignatureScheme::V3
          } else {
            SignatureScheme::V31
          }
          let data = extract_signer_data(
            self.source,
            sch,
            value_off,
            value_len,
            pos,
          )
          out.push({
            scheme: sch,
            block_id: id,
            certs: data.certs,
            digests: data.digests,
            pkcs7_ok: true,
            v1_sf: None,
            v1_manifest: None,
            value_off,
            value_len,
            v1_block: None,
          })
          recognized = recognized + 1
        }
        pos = pos + 8 + pair_len.to_int()
      }
      if recognized == 0 {
        raise ApkError::UnsupportedSignatureScheme(
          "APK Signing Block at offset " +
          block_start.to_string() +
          " contains no v2/v3/v3.1 signature scheme",
        )
      }
    }
  }
  out.sort_by(fn(a, b) { scheme_rank(a.scheme) - scheme_rank(b.scheme) })
  out
}

///|
/// 对单条记录做结构 + 摘要校验。
fn Apk::verify_signature_record(self : Apk, rec : SigRecord) -> SignatureCheck {
  match rec.scheme {
    SignatureScheme::V1 => self.verify_v1(rec)
    _ => self.verify_v2(rec)
  }
}

///|
/// 失败时的统一结论构造。
fn failed_check(
  scheme : SignatureScheme,
  algorithm : String,
  detail : String,
) -> SignatureCheck {
  {
    scheme,
    structure_ok: false,
    digest_ok: false,
    digest_algorithm: algorithm,
    entries_checked: 0,
    entries_failed: 0,
    signature_verified: false,
    detail,
  }
}

///|
/// v1 JAR 签名校验:MANIFEST.MF 条目摘要 + `.SF` 对 MANIFEST 的摘要。
fn Apk::verify_v1(self : Apk, rec : SigRecord) -> SignatureCheck {
  let manifest = match rec.v1_manifest {
    Some(n) => self.safe_entry(n)
    None => None
  }
  let sf = match rec.v1_sf {
    Some(n) => self.safe_entry(n)
    None => None
  }
  let structure_ok = rec.pkcs7_ok && manifest is Some(_) && sf is Some(_)
  if !structure_ok {
    let mut detail = "v1 structure incomplete"
    if !rec.pkcs7_ok {
      detail = "v1 PKCS#7 signature block could not be parsed"
    } else if manifest is None {
      detail = "v1 META-INF/MANIFEST.MF is missing or unreadable"
    } else if sf is None {
      detail = "v1 META-INF/*.SF is missing or unreadable"
    }
    return failed_check(SignatureScheme::V1, "", detail)
  }
  let mf_bytes = manifest.unwrap()
  let sf_bytes = sf.unwrap()
  let mf_text = @encoding/utf8.decode(mf_bytes) catch { _ => "" }
  let sf_text = @encoding/utf8.decode(sf_bytes) catch { _ => "" }
  let sections = parse_manifest_sections(mf_text)
  let mut entries_checked = 0
  let mut entries_failed = 0
  let mut unsupported = 0
  let mut algorithm = ""
  let mut mixed = false
  for section in sections {
    match attr_value(section, "Name") {
      None => ()
      Some(name) =>
        match entry_digest_attr(section) {
          None => ()
          Some((alg, expected_b64)) => {
            if algorithm == "" {
              algorithm = alg
            } else if algorithm != alg {
              mixed = true
            }
            if alg == "SHA-256" || alg == "SHA-512" {
              match self.safe_entry(name) {
                Some(data) => {
                  let actual = if alg == "SHA-256" {
                    sha256(data)
                  } else {
                    sha512(data)
                  }
                  if digest_matches(actual, expected_b64) {
                    entries_checked = entries_checked + 1
                  } else {
                    entries_checked = entries_checked + 1
                    entries_failed = entries_failed + 1
                  }
                }
                None => {
                  entries_checked = entries_checked + 1
                  entries_failed = entries_failed + 1
                }
              }
            } else {
              unsupported = unsupported + 1
            }
          }
        }
    }
  }
  // `.SF` 对整份 MANIFEST.MF 的摘要(同时检查 SHA-256 与 SHA-512)。
  let sf_sections = parse_manifest_sections(sf_text)
  let mut manifest_ok = false
  if sf_sections.length() > 0 {
    match attr_value(sf_sections[0], "SHA-256-Digest-Manifest") {
      Some(expected) => manifest_ok = digest_matches(sha256(mf_bytes), expected)
      None => ()
    }
    if !manifest_ok {
      match attr_value(sf_sections[0], "SHA-512-Digest-Manifest") {
        Some(expected) =>
          manifest_ok = digest_matches(sha512(mf_bytes), expected)
        None => ()
      }
    }
  }
  let digest_ok = manifest_ok &&
    entries_checked > 0 &&
    entries_failed == 0 &&
    unsupported == 0
  let detail = if digest_ok {
    let base = "v1 digests verified (" +
      entries_checked.to_string() +
      " entries + MANIFEST.MF); signature NOT verified"
    if mixed {
      base + " (mixed algorithms)"
    } else {
      base
    }
  } else if !manifest_ok {
    "v1 MANIFEST.MF digest mismatch or unavailable; signature NOT verified"
  } else if entries_failed > 0 {
    "v1 entry digest mismatch x" +
    entries_failed.to_string() +
    "; signature NOT verified"
  } else if unsupported > 0 {
    let base = "v1 digest algorithm unsupported x" +
      unsupported.to_string() +
      "; signature NOT verified"
    if mixed {
      base + " (mixed algorithms)"
    } else {
      base
    }
  } else {
    "v1 MANIFEST.MF has no verifiable entry digests; signature NOT verified"
  }
  if algorithm == "" {
    algorithm = "SHA-256"
  }
  {
    scheme: SignatureScheme::V1,
    structure_ok: true,
    digest_ok,
    digest_algorithm: algorithm,
    entries_checked,
    entries_failed,
    signature_verified: false,
    detail,
  }
}

///|
/// v2/v3/v3.1 校验:比较 signed data 中的内容摘要与本地重算的 APK 内容分块摘要。
fn Apk::verify_v2(self : Apk, rec : SigRecord) -> SignatureCheck {
  let structure_ok = rec.certs.length() > 0 && rec.digests.length() > 0
  if !structure_ok {
    return failed_check(
      rec.scheme,
      "",
      "signer has no certificate or no digest record",
    )
  }
  let mut digest_ok = false
  let mut algorithm = ""
  let mut computed_some = false
  for d in rec.digests {
    let name = content_digest_algorithm_name(d.algorithm)
    if algorithm == "" {
      algorithm = name
    }
    if name != "SHA-256" && name != "SHA-512" {
      continue
    }
    match self.content_digest(name) {
      Some(c) => {
        computed_some = true
        if d.digest == c {
          digest_ok = true
        }
      }
      None => ()
    }
  }
  let detail = if digest_ok {
    "content digest (" + algorithm + ") matched; signature NOT verified"
  } else if computed_some {
    "content digest mismatch or unsupported algorithm (" +
    algorithm +
    "); signature NOT verified"
  } else {
    "APK content digest could not be computed; signature NOT verified"
  }
  {
    scheme: rec.scheme,
    structure_ok,
    digest_ok,
    digest_algorithm: algorithm,
    entries_checked: 0,
    entries_failed: 0,
    signature_verified: false,
    detail,
  }
}

///|
/// v2/v3 内容摘要算法 ID → 摘要算法名。
/// 只认 AOSP `CONTENT_DIGEST_*` ID(0x0101/0x0103/0x0104=SHA-256;0x0102/0x0105=SHA-512);
/// 0x0201/0x0301 等是签名算法 ID,不参与内容摘要聚合。
fn content_digest_algorithm_name(id : UInt32) -> String {
  match id {
    0x0101U | 0x0103U | 0x0104U => "SHA-256"
    0x0102U | 0x0105U => "SHA-512"
    _ => "unknown"
  }
}

///|
/// 计算 v2/v3 规范的 APK 内容分块摘要。`algorithm` 为 "SHA-256" 或 "SHA-512";
/// 只在存在 APK Signing Block 时有意义;EOCD 的中央目录偏移字段改写为块起始偏移。
fn Apk::content_digest(self : Apk, algorithm : String) -> Bytes? {
  let hash_fn = match algorithm {
    "SHA-256" => sha256
    "SHA-512" => sha512
    _ => return None
  }
  let sb = match self.signing_block_off {
    Some(v) => v.to_int()
    None => return None
  }
  let eocd = match find_eocd(self.source) {
    Some(o) => o
    None => return None
  }
  let source = self.source
  let cd_off = le_u32(source, eocd + 16).reinterpret_as_int()
  let cd_size = le_u32(source, eocd + 12).reinterpret_as_int()
  if cd_off < 0 || cd_size < 0 || cd_off + cd_size > eocd {
    return None
  }
  let comment_len = le_u16(source, eocd + 20)
  let eocd_len = 22 + comment_len
  if eocd + eocd_len > source.length() {
    return None
  }
  let chunk_digests : Array[Bytes] = []
  chunk_append(source, 0, sb, chunk_digests, hash_fn)
  chunk_append(source, cd_off, cd_off + cd_size, chunk_digests, hash_fn)
  // EOCD 副本:中央目录偏移(+16)改写为 signing block 起始偏移。
  let eocd_buf : Array[Byte] = []
  for i = 0; i < eocd_len; i = i + 1 {
    eocd_buf.push(source[eocd + i])
  }
  let sb_u = sb.reinterpret_as_uint()
  eocd_buf[16] = (sb_u & 0xFFU).reinterpret_as_int().to_byte()
  eocd_buf[17] = ((sb_u >> 8) & 0xFFU).reinterpret_as_int().to_byte()
  eocd_buf[18] = ((sb_u >> 16) & 0xFFU).reinterpret_as_int().to_byte()
  eocd_buf[19] = ((sb_u >> 24) & 0xFFU).reinterpret_as_int().to_byte()
  chunk_digests.push(chunk_digest_of(Bytes::from_array(eocd_buf[:]), hash_fn))
  // 外层:0x5a || chunk_count(u32le) || chunk digests
  let outer : Array[Byte] = []
  outer.push(b'\x5a')
  push_u32_le(outer, chunk_digests.length())
  for d in chunk_digests {
    for x in d {
      outer.push(x)
    }
  }
  Some(hash_fn(Bytes::from_array(outer[:])))
}

///|
/// 按 1 MiB 切片 `source[start:end]`,追加每片摘要到 `out`。
fn chunk_append(
  source : Bytes,
  start : Int32,
  end : Int32,
  out : Array[Bytes],
  hash_fn : (Bytes) -> Bytes,
) -> Unit {
  let chunk_size = 1048576
  let mut pos = start
  while pos < end {
    let take = if end - pos > chunk_size { chunk_size } else { end - pos }
    let buf : Array[Byte] = []
    for i = pos; i < pos + take; i = i + 1 {
      buf.push(source[i])
    }
    out.push(chunk_digest_of(Bytes::from_array(buf[:]), hash_fn))
    pos = pos + take
  }
}

///|
/// 单片摘要:algorithm(0xa5 || chunk_len_u32le || chunk)。
fn chunk_digest_of(chunk : Bytes, hash_fn : (Bytes) -> Bytes) -> Bytes {
  let buf : Array[Byte] = []
  buf.push(b'\xa5')
  push_u32_le(buf, chunk.length())
  for x in chunk {
    buf.push(x)
  }
  hash_fn(Bytes::from_array(buf[:]))
}

///|
/// 小端 u32 写入字节数组。
fn push_u32_le(a : Array[Byte], v : Int32) -> Unit {
  a.push((v & 0xFF).to_byte())
  a.push(((v >> 8) & 0xFF).to_byte())
  a.push(((v >> 16) & 0xFF).to_byte())
  a.push(((v >> 24) & 0xFF).to_byte())
}

///|
/// 包内安全取条目(失败返回 None,供校验路径记录失败而非抛出)。
fn Apk::safe_entry(self : Apk, name : String) -> Bytes? {
  let mut out : Bytes? = None
  try {
    out = Some(extract_entry(self.source, self.entries, name))
  } catch {
    _ => ()
  } noraise {
    _ => ()
  }
  out
}

///|
/// base64 摘要比较(解码失败视为不一致)。
fn digest_matches(actual : Bytes, expected_b64 : String) -> Bool {
  let expected = @base64.decode(expected_b64) catch { _ => return false }
  actual == expected
}

///|
/// 从 JAR 清单 section 中取摘要属性:优先 SHA-256,其次 SHA-1/SHA-512(后者不支持校验)。
fn entry_digest_attr(section : Array[(String, String)]) -> (String, String)? {
  match attr_value(section, "SHA-256-Digest") {
    Some(v) => Some(("SHA-256", v))
    None =>
      match attr_value(section, "SHA-1-Digest") {
        Some(v) => Some(("SHA-1", v))
        None =>
          match attr_value(section, "SHA-512-Digest") {
            Some(v) => Some(("SHA-512", v))
            None => None
          }
      }
  }
}

///|
/// 取 section 的属性值。
fn attr_value(section : Array[(String, String)], key : String) -> String? {
  for (k, v) in section {
    if k == key {
      return Some(v)
    }
  }
  None
}

///|
/// 解析 JAR 清单文本为 section 数组(每个 section 是属性键值对数组)。
///
/// 处理 CRLF/LF、续行(行首单个空格)与空行分节;首 section 为主属性。
fn parse_manifest_sections(text : String) -> Array[Array[(String, String)]] {
  let logical : Array[String] = []
  for raw in text.split("\n") {
    let mut line = raw.to_owned()
    if line.has_suffix("\r") {
      line = line[:line.length() - 1].to_owned()
    }
    if line.has_prefix(" ") && logical.length() > 0 {
      let last = logical.length() - 1
      logical[last] = logical[last] + line[1:].to_owned()
    } else if line == "" {
      logical.push("")
    } else {
      logical.push(line)
    }
  }
  let sections : Array[Array[(String, String)]] = []
  let mut cur : Array[(String, String)] = []
  for line in logical {
    if line == "" {
      if cur.length() > 0 {
        sections.push(cur)
        cur = []
      }
    } else {
      match line.find(":") {
        Some(colon) => {
          let mut value = line[colon + 1:].to_owned()
          if value.has_prefix(" ") {
            value = value[1:].to_owned()
          }
          cur.push((trim_spaces(line[:colon].to_owned()), trim_spaces(value)))
        }
        None => ()
      }
    }
  }
  if cur.length() > 0 {
    sections.push(cur)
  }
  sections
}

///|
/// 去掉首尾空格(JAR 属性值/键名的规范化)。
fn trim_spaces(s : String) -> String {
  let mut start = 0
  let mut end = s.length()
  while start < end && s[start:start + 1] == " " {
    start = start + 1
  }
  while end > start && s[end - 1:end] == " " {
    end = end - 1
  }
  s[start:end].to_owned()
}

///|
/// 从 PKCS#7(DER)中提取证书 DER 原始字节;结构非法返回空数组(不抛错)。
///
/// 只做最外层结构定位:ContentInfo → signedData → [0] certificates → Certificate。
/// **不验证** SignedData 的签名值,也不校验证书链。
fn pkcs7_certificates(der : Bytes) -> Array[Bytes] {
  let certs : Array[Bytes] = []
  let len = der.length()
  if len < 4 {
    return certs
  }
  let ci = match der_read(der, 0, len) {
    Some(t) => t
    None => return certs
  }
  if ci.tag != 0x30 {
    return certs
  }
  let oid = match der_read(der, ci.body, ci.end) {
    Some(t) => t
    None => return certs
  }
  if oid.tag != 0x06 || !der_oid_is_signed_data(der, oid.body, oid.end) {
    return certs
  }
  let ctx = match der_read(der, oid.end, ci.end) {
    Some(t) => t
    None => return certs
  }
  if ctx.tag != 0xA0 {
    return certs
  }
  let sd = match der_read(der, ctx.body, ctx.end) {
    Some(t) => t
    None => return certs
  }
  if sd.tag != 0x30 {
    return certs
  }
  let mut p = sd.body
  while p < sd.end {
    let child = match der_read(der, p, sd.end) {
      Some(t) => t
      None => return certs
    }
    if child.tag == 0xA0 {
      let mut c = child.body
      while c < child.end {
        let cert = match der_read(der, c, child.end) {
          Some(t) => t
          None => return certs
        }
        if cert.tag == 0x30 {
          certs.push(der[cert.start:cert.end].to_owned())
        }
        c = cert.end
      }
    }
    p = child.end
  }
  certs
}

///|
/// 判断 OID 内容是否为 `1.2.840.113549.1.7.2`(signedData)。
fn der_oid_is_signed_data(b : Bytes, start : Int32, end : Int32) -> Bool {
  let expected = b"\x2a\x86\x48\x86\xf7\x0d\x01\x07\x02"
  if end - start != expected.length() {
    return false
  }
  for i = 0; i < expected.length(); i = i + 1 {
    if b[start + i] != expected[i] {
      return false
    }
  }
  true
}

///|
/// DER TLV 读取结果(`start` 为 tag 起始、`body` 为内容起始、`end` 为 TLV 结束)。
priv struct DerTlv {
  tag : Int32
  start : Int32
  body : Int32
  end : Int32
}

///|
/// 读取一个 DER TLV;短/长格式长度均支持(长度字节数上限 4),越界返回 None。
fn der_read(b : Bytes, off : Int32, limit : Int32) -> DerTlv? {
  if off < 0 || off + 2 > limit {
    return None
  }
  let tag = b[off].to_int()
  let l0 = b[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) | b[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, })
}