rsop-oct 0.1.3

// SPDX-FileCopyrightText: Heiko Schaefer <heiko@schaefer.name>
// SPDX-License-Identifier: MIT OR Apache-2.0

use std::time::SystemTime;

use pgp::packet::{Signature, SignatureType};
use pgp::types::Fingerprint;
use pgp::types::KeyDetails;
use rpgpie::certificate::Certificate;
use rpgpie::message::MessageResult;

pub(crate) fn to_verification(
    signature: &Signature,
    cert: &Certificate,
    key_fp: Fingerprint,
) -> sop::ops::Verification {
    let ct: SystemTime = (*signature.created().expect("FIXME")).into();

    let key_fp = hex::encode(key_fp.as_bytes());
    let cert_fp = hex::encode(cert.fingerprint().as_bytes());

    let mode = match signature.typ() {
        Some(SignatureType::Binary) => sop::ops::SignatureMode::Binary,
        Some(SignatureType::Text) => sop::ops::SignatureMode::Text,
        _ => panic!("unexpected data signature type"),
    };

    sop::ops::Verification::new(ct, key_fp, cert_fp, mode, None).expect("FIXME")
}

pub(crate) fn result_to_verifications(mr: &MessageResult) -> Vec<sop::ops::Verification> {
    mr.validated
        .iter()
        .map(|(cert, key, sig)| to_verification(sig, cert, key.fingerprint()))
        .collect()
}

pub(crate) struct DebugWrapper<'a>(
    pub std::io::BufReader<&'a mut (dyn std::io::Read + Send + Sync)>,
);

impl std::io::Read for DebugWrapper<'_> {
    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
        self.0.read(buf)
    }
}

impl std::io::BufRead for DebugWrapper<'_> {
    fn fill_buf(&mut self) -> std::io::Result<&[u8]> {
        self.0.fill_buf()
    }

    fn consume(&mut self, amt: usize) {
        self.0.consume(amt);
    }
}

impl std::fmt::Debug for DebugWrapper<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("DebugWrapper").finish()
    }
}