///|
/// v1(JAR 签名)CMS SignedData 的 signerInfo 签名值验证(W6 / M6-RSA-b + ECDSA)。
///
/// 覆盖范围:PKCS#7 `SignedData` 中每个 `SignerInfo` 的 RSA PKCS#1 v1.5 / ECDSA 签名值。
/// 验签对象口径(与 apksigner / jarsigner 一致):
/// - 若 signerInfo 带 `authenticatedAttributes`([0] IMPLICIT SET OF Attribute),
///   签名覆盖的是把这些属性**重新编码为 SET OF(tag 0x31)**的 DER 字节,
///   且其中 `messageDigest` 属性值必须等于 `.SF` 文件的摘要;
/// - 若不 signedAttrs,签名直接覆盖 `.SF` 内容。
///
/// DSA/未知算法一律 fail-closed(返回 false)。
/// 不新增 `ApkError` 变体;解析失败一律返回 false(不抛错)。

///|
/// signerInfo 的验签所需数据。
priv struct CmsSignerInfo {
  /// 摘要算法名("SHA-256" / "SHA-512" / "" 表示不支持)。
  digest_alg : String
  /// 签名算法名("RSA" / "ECDSA" / "unsupported")。
  sig_alg : String
  /// `authenticatedAttributes` 原始 DER(含 0xA0 tag);None 表示无签名属性。
  signed_attrs : Bytes?
  /// 签名值(encryptedDigest)。
  signature : Bytes
  /// signedAttrs 中 `messageDigest` 属性值;无 signedAttrs 时为 None。
  message_digest : Bytes?
}

///|
/// v1 signerInfo 验签结论(crypto 是否通过 + 算法名 + 诊断)。
fn verify_v1_signer_info(
  certs : Array[Bytes],
  sf_bytes : Bytes,
  pkcs7_der : Bytes,
) -> (Bool, String, String) {
  if certs.length() == 0 {
    return (false, "unsupported", "v1 signerInfo: no certificate available")
  }
  let spki = match x509_spki(certs[0]) {
    Some(s) => s
    None =>
      return (
        false, "unsupported", "v1 signerInfo: certificate SPKI unreadable",
      )
  }
  let rsa_key = rsa_public_key_from_spki(spki)
  let ec_key = match rsa_key {
    Some(_) => None
    None => ec_public_key_from_spki(spki)
  }
  match (rsa_key, ec_key) {
    (None, None) =>
      return (
        false, "unsupported", "v1 signerInfo: certificate key is not a parseable RSA or EC SPKI",
      )
    _ => ()
  }
  if rsa_key is Some(key) {
    if rsa_key_too_large(key) {
      return (false, "unsupported", "v1 signerInfo: key too large")
    }
  }
  let signers = match cms_signer_infos(pkcs7_der) {
    Some(s) => s
    None =>
      return (false, "unsupported", "v1 signerInfo: CMS SignedData unreadable")
  }
  let mut algo = "unsupported"
  let mut detail = "v1 signerInfo: no verifiable RSA or ECDSA signature"
  for si in signers {
    if si.digest_alg == "" {
      detail = "v1 signerInfo: unsupported algorithm"
      continue
    }
    if si.sig_alg == "RSA" {
      let key = match rsa_key {
        Some(k) => k
        None => {
          detail = "v1 signerInfo: certificate key is not RSA"
          continue
        }
      }
      algo = if si.digest_alg == "SHA-256" {
        "SHA256withRSA"
      } else {
        "SHA512withRSA"
      }
      match si.signed_attrs {
        Some(attrs) => {
          // 1) messageDigest 属性必须等于 .SF 摘要。
          let md_ok = match si.message_digest {
            Some(md) => cms_digest_eq(si.digest_alg, sf_bytes, md)
            None => false
          }
          if !md_ok {
            detail = "v1 signerInfo: messageDigest attribute mismatch or missing"
            continue
          }
          // 2) 签名覆盖重新编码为 SET OF(0x31)的属性字节。
          let signed_bytes = cms_attrs_as_set(attrs)
          let digest = cms_hash(si.digest_alg, signed_bytes)
          if rsa_verify_pkcs1(key, si.signature, digest, si.digest_alg) {
            return (
              true, algo, "v1 signerInfo: RSA signature verified over signed attributes",
            )
          }
          detail = "v1 signerInfo: signature over signed attributes failed verification"
        }
        None => {
          let digest = cms_hash(si.digest_alg, sf_bytes)
          if rsa_verify_pkcs1(key, si.signature, digest, si.digest_alg) {
            return (
              true, algo, "v1 signerInfo: RSA signature verified over .SF content",
            )
          }
          detail = "v1 signerInfo: signature over content failed verification"
        }
      }
    } else if si.sig_alg == "ECDSA" {
      let (curve, qx, qy) = match ec_key {
        Some(v) => v
        None => {
          detail = "v1 signerInfo: certificate key is not EC"
          continue
        }
      }
      let params = match ec_params(curve) {
        Some(p) => p
        None => {
          detail = "v1 signerInfo: unsupported EC curve"
          continue
        }
      }
      algo = if si.digest_alg == "SHA-256" {
        "SHA256withECDSA"
      } else {
        "SHA512withECDSA"
      }
      match si.signed_attrs {
        Some(attrs) => {
          // 1) messageDigest 属性必须等于 .SF 摘要(与 RSA 路径一致)。
          let md_ok = match si.message_digest {
            Some(md) => cms_digest_eq(si.digest_alg, sf_bytes, md)
            None => false
          }
          if !md_ok {
            detail = "v1 signerInfo: messageDigest attribute mismatch or missing"
            continue
          }
          // 2) 签名覆盖重新编码为 SET OF(0x31)的属性字节。
          let signed_bytes = cms_attrs_as_set(attrs)
          let digest = cms_hash(si.digest_alg, signed_bytes)
          let (ok, why) = cms_ecdsa_verify(
            params,
            qx,
            qy,
            si.signature,
            ec_hash_to_e(digest, params.n),
            si.digest_alg,
          )
          if ok {
            return (
              true, algo, "v1 signerInfo: ECDSA signature verified over signed attributes",
            )
          }
          detail = why
        }
        None => {
          let digest = cms_hash(si.digest_alg, sf_bytes)
          let (ok, why) = cms_ecdsa_verify(
            params,
            qx,
            qy,
            si.signature,
            ec_hash_to_e(digest, params.n),
            si.digest_alg,
          )
          if ok {
            return (
              true, algo, "v1 signerInfo: ECDSA signature verified over .SF content",
            )
          }
          detail = why
        }
      }
    } else {
      detail = "v1 signerInfo: unsupported algorithm"
    }
  }
  (false, algo, detail)
}

///|
/// v1 CMS ECDSA 签名值验签:DER 解码 `SEQUENCE{INTEGER r, INTEGER s}` 后调
/// `ec_ecdsa_verify`(r/s 越界、曲线不匹配、公钥非法均由其内部 fail-closed)。
fn cms_ecdsa_verify(
  params : EcParams,
  qx : BigInt,
  qy : BigInt,
  sig_der : Bytes,
  e : BigInt,
  hash_name : String,
) -> (Bool, String) {
  match ec_sig_from_der(sig_der) {
    None => (false, "v1 signerInfo: ECDSA signature value is not valid DER")
    Some((r, s)) =>
      if ec_ecdsa_verify(params, qx, qy, e, r, s) {
        (true, "")
      } else {
        (
          false,
          "v1 signerInfo: ECDSA " + hash_name + " signature failed verification",
        )
      }
  }
}

///|
/// 按算法名计算摘要;不支持返回空 Bytes。
fn cms_hash(alg : String, data : Bytes) -> Bytes {
  if alg == "SHA-256" {
    sha256(data)
  } else if alg == "SHA-512" {
    sha512(data)
  } else {
    b""
  }
}

///|
/// 比较摘要与期望值。
fn cms_digest_eq(alg : String, data : Bytes, expected : Bytes) -> Bool {
  let actual = cms_hash(alg, data)
  if actual.length() == 0 {
    return false
  }
  if actual.length() != expected.length() {
    return false
  }
  for i = 0; i < actual.length(); i = i + 1 {
    if actual[i] != expected[i] {
      return false
    }
  }
  true
}

///|
/// 把 `authenticatedAttributes`([0] IMPLICIT,tag 0xA0)重新编码为 SET OF(tag 0x31),
/// 即 jarsigner 签名时使用的 DER 字节;长度编码原样保留。
fn cms_attrs_as_set(attrs : Bytes) -> Bytes {
  let out : Array[Byte] = []
  if attrs.length() == 0 {
    return b""
  }
  out.push(b'\x31')
  for i = 1; i < attrs.length(); i = i + 1 {
    out.push(attrs[i])
  }
  Bytes::from_array(out[:])
}

///|
/// 解析 CMS SignedData 的 signerInfos;结构异常返回 None。
fn cms_signer_infos(der : Bytes) -> Array[CmsSignerInfo]? {
  let len = der.length()
  let ci = match der_read(der, 0, len) {
    Some(t) => t
    None => return None
  }
  if ci.tag != 0x30 {
    return None
  }
  // ContentInfo.contentType 必须为 signedData (1.2.840.113549.1.7.2)
  let oid = match der_read(der, ci.body, ci.end) {
    Some(t) => t
    None => return None
  }
  if oid.tag != 0x06 || !der_oid_is(der, oid.body, oid.end, oid_signed_data) {
    return None
  }
  let ctx = match der_read(der, oid.end, ci.end) {
    Some(t) => t
    None => return None
  }
  if ctx.tag != 0xA0 {
    return None
  }
  let sd = match der_read(der, ctx.body, ctx.end) {
    Some(t) => t
    None => return None
  }
  if sd.tag != 0x30 {
    return None
  }
  // SignedData: version INTEGER, digestAlgorithms SET, contentInfo SEQ,
  //             [0] certs?, [1] crls?, signerInfos SET
  let mut p = sd.body
  // version
  let version = match der_read(der, p, sd.end) {
    Some(t) => t
    None => return None
  }
  if version.tag != 0x02 {
    return None
  }
  p = version.end
  // digestAlgorithms
  let dig_algs = match der_read(der, p, sd.end) {
    Some(t) => t
    None => return None
  }
  if dig_algs.tag != 0x31 {
    return None
  }
  p = dig_algs.end
  // encapContentInfo
  let encap = match der_read(der, p, sd.end) {
    Some(t) => t
    None => return None
  }
  if encap.tag != 0x30 {
    return None
  }
  p = encap.end
  // 可选 [0] certs / [1] crls
  while p < sd.end {
    let c = match der_read(der, p, sd.end) {
      Some(t) => t
      None => return None
    }
    if c.tag == 0xA0 || c.tag == 0xA1 {
      p = c.end
      continue
    }
    break
  }
  // signerInfos SET OF SignerInfo
  let infos = match der_read(der, p, sd.end) {
    Some(t) => t
    None => return None
  }
  if infos.tag != 0x31 {
    return None
  }
  let out : Array[CmsSignerInfo] = []
  let mut q = infos.body
  while q < infos.end {
    let si = match der_read(der, q, infos.end) {
      Some(t) => t
      None => return None
    }
    if si.tag != 0x30 {
      return None
    }
    match cms_parse_signer_info(der, si) {
      Some(v) => out.push(v)
      None => return None
    }
    q = si.end
  }
  Some(out)
}

///|
/// 解析单个 SignerInfo SEQUENCE。
fn cms_parse_signer_info(der : Bytes, si : DerTlv) -> CmsSignerInfo? {
  let mut p = si.body
  // version INTEGER
  let version = match der_read(der, p, si.end) {
    Some(t) => t
    None => return None
  }
  if version.tag != 0x02 {
    return None
  }
  p = version.end
  // issuerAndSerialNumber SEQUENCE
  let ias = match der_read(der, p, si.end) {
    Some(t) => t
    None => return None
  }
  if ias.tag != 0x30 {
    return None
  }
  p = ias.end
  // digestAlgorithm AlgorithmIdentifier
  let dig = match der_read(der, p, si.end) {
    Some(t) => t
    None => return None
  }
  if dig.tag != 0x30 {
    return None
  }
  let digest_alg = cms_digest_alg_name(der, dig)
  p = dig.end
  // authenticatedAttributes [0] IMPLICIT OPTIONAL
  let mut signed_attrs : Bytes? = None
  let mut message_digest : Bytes? = None
  let maybe_attrs = match der_read(der, p, si.end) {
    Some(t) => t
    None => return None
  }
  if maybe_attrs.tag == 0xA0 {
    let raw = der[maybe_attrs.start:maybe_attrs.end].to_owned()
    signed_attrs = Some(raw)
    message_digest = cms_find_message_digest(der, maybe_attrs)
    p = maybe_attrs.end
  }
  // digestEncryptionAlgorithm AlgorithmIdentifier
  let sigalg = match der_read(der, p, si.end) {
    Some(t) => t
    None => return None
  }
  if sigalg.tag != 0x30 {
    return None
  }
  let sig_alg = cms_sig_alg_name(der, sigalg)
  p = sigalg.end
  // encryptedDigest OCTET STRING
  let sig = match der_read(der, p, si.end) {
    Some(t) => t
    None => return None
  }
  if sig.tag != 0x04 {
    return None
  }
  let signature = der[sig.body:sig.end].to_owned()
  Some({ digest_alg, sig_alg, signed_attrs, signature, message_digest, })
}

///|
/// 在 attributes SET 中查找 `messageDigest`(1.2.840.113549.1.9.4)属性值。
fn cms_find_message_digest(der : Bytes, attrs : DerTlv) -> Bytes? {
  let mut p = attrs.body
  while p < attrs.end {
    let attr = match der_read(der, p, attrs.end) {
      Some(t) => t
      None => return None
    }
    if attr.tag != 0x30 {
      return None
    }
    let oid = match der_read(der, attr.body, attr.end) {
      Some(t) => t
      None => return None
    }
    if oid.tag == 0x06 && der_oid_is(der, oid.body, oid.end, oid_message_digest) {
      let values = match der_read(der, oid.end, attr.end) {
        Some(t) => t
        None => return None
      }
      if values.tag != 0x31 {
        return None
      }
      let octet = match der_read(der, values.body, values.end) {
        Some(t) => t
        None => return None
      }
      if octet.tag != 0x04 {
        return None
      }
      return Some(der[octet.body:octet.end].to_owned())
    }
    p = attr.end
  }
  None
}

///|
/// AlgorithmIdentifier → 摘要算法名(仅 SHA-256 / SHA-512,其余为空串)。
fn cms_digest_alg_name(der : Bytes, alg : DerTlv) -> String {
  let oid = match der_read(der, alg.body, alg.end) {
    Some(t) => t
    None => return ""
  }
  if oid.tag != 0x06 {
    return ""
  }
  if der_oid_is(der, oid.body, oid.end, oid_sha256) {
    "SHA-256"
  } else if der_oid_is(der, oid.body, oid.end, oid_sha512) {
    "SHA-512"
  } else {
    ""
  }
}

///|
/// AlgorithmIdentifier → 签名算法名(RSA / ECDSA 系列,其余 "unsupported")。
fn cms_sig_alg_name(der : Bytes, alg : DerTlv) -> String {
  let oid = match der_read(der, alg.body, alg.end) {
    Some(t) => t
    None => return "unsupported"
  }
  if oid.tag != 0x06 {
    return "unsupported"
  }
  if der_oid_is(der, oid.body, oid.end, oid_sha256_with_rsa) ||
    der_oid_is(der, oid.body, oid.end, oid_sha512_with_rsa) ||
    der_oid_is(der, oid.body, oid.end, oid_rsa_encryption) {
    "RSA"
  } else if der_oid_is(der, oid.body, oid.end, oid_ecdsa_with_sha256) ||
    der_oid_is(der, oid.body, oid.end, oid_ecdsa_with_sha512) ||
    der_oid_is(der, oid.body, oid.end, oid_ecdsa_with_sha1) ||
    der_oid_is(der, oid.body, oid.end, oid_ecdsa_secp521r1) {
    // 具体摘要以 signerInfo 的 digestAlgorithm 为准(ECDSA 无 PSS 变体)。
    "ECDSA"
  } else {
    "unsupported"
  }
}

///|
/// 从 X.509 证书 DER 提取 SubjectPublicKeyInfo(SPKI)。
///
/// Certificate = SEQUENCE { tbsCertificate, signatureAlgorithm, signatureValue };
/// tbsCertificate 的子项顺序(version 可选):serial, sigAlg, issuer, validity,
/// subject, SPKI, ...,故 SPKI 为第 base+5 个子项。
fn x509_spki(cert : Bytes) -> Bytes? {
  let len = cert.length()
  let c = match der_read(cert, 0, len) {
    Some(t) => t
    None => return None
  }
  if c.tag != 0x30 {
    return None
  }
  let tbs = match der_read(cert, c.body, c.end) {
    Some(t) => t
    None => return None
  }
  if tbs.tag != 0x30 {
    return None
  }
  let kids : Array[DerTlv] = []
  let mut p = tbs.body
  while p < tbs.end {
    let k = match der_read(cert, p, tbs.end) {
      Some(t) => t
      None => return None
    }
    kids.push(k)
    p = k.end
  }
  let base = if kids.length() > 0 && kids[0].tag == 0xA0 { 1 } else { 0 }
  let idx = base + 5
  if idx >= kids.length() {
    return None
  }
  let spki = kids[idx]
  if spki.tag != 0x30 {
    return None
  }
  Some(cert[spki.start:spki.end].to_owned())
}

///|
/// OID 内容字节比较。
fn der_oid_is(b : Bytes, start : Int32, end : Int32, expected : Bytes) -> Bool {
  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
}

///|
/// OID 1.2.840.113549.1.7.2(signedData)。
let oid_signed_data : Bytes = b"\x2a\x86\x48\x86\xf7\x0d\x01\x07\x02"

///|
/// OID 1.2.840.113549.1.9.4(messageDigest)。
let oid_message_digest : Bytes = b"\x2a\x86\x48\x86\xf7\x0d\x01\x09\x04"

///|
/// OID 1.2.840.113549.1.1.1(rsaEncryption)。
let oid_rsa_encryption : Bytes = b"\x2a\x86\x48\x86\xf7\x0d\x01\x01\x01"

///|
/// OID 1.2.840.113549.1.1.11(sha256WithRSAEncryption)。
let oid_sha256_with_rsa : Bytes = b"\x2a\x86\x48\x86\xf7\x0d\x01\x01\x0b"

///|
/// OID 1.2.840.113549.1.1.13(sha512WithRSAEncryption)。
let oid_sha512_with_rsa : Bytes = b"\x2a\x86\x48\x86\xf7\x0d\x01\x01\x0d"

///|
/// OID 2.16.840.1.101.3.4.2.1(sha256)。
let oid_sha256 : Bytes = b"\x60\x86\x48\x01\x65\x03\x04\x02\x01"

///|
/// OID 2.16.840.1.101.3.4.2.3(sha512)。
let oid_sha512 : Bytes = b"\x60\x86\x48\x01\x65\x03\x04\x02\x03"

///|
/// OID 1.2.840.10045.4.3.2(ecdsa-with-SHA256)。
let oid_ecdsa_with_sha256 : Bytes = b"\x2a\x86\x48\xce\x3d\x04\x03\x02"

///|
/// OID 1.2.840.10045.4.3.3(ecdsa-with-SHA512)。
let oid_ecdsa_with_sha512 : Bytes = b"\x2a\x86\x48\xce\x3d\x04\x03\x03"

///|
/// OID 1.2.840.10045.4.1(ecdsa-with-SHA1;部分工具使用的通配签名算法 OID)。
let oid_ecdsa_with_sha1 : Bytes = b"\x2a\x86\x48\xce\x3d\x04\x01"

///|
/// OID 1.3.132.0.35(secp521r1;部分工具用作 ECDSA 签名算法别名)。
let oid_ecdsa_secp521r1 : Bytes = b"\x2b\x81\x04\x00\x23"