見積・電子契約（freeeサイン）から請求・入金消込（freee会計）・インボイス電子帳簿保存法までを3項目でつなぐバックオフィス自動化

#![forbid(unsafe_code)]

/// Performs constant-time 32-byte digest comparison to prevent timing side-channel attacks.
#[inline]
pub fn constant_time_eq_32(expected: &[u8; 32], provided: &[u8; 32]) -> bool {
    let mut diff: u8 = 0;
    for i in 0..32 {
        diff |= expected[i] ^ provided[i];
    }
    diff == 0
}

/// Verifies webhook timestamp freshness (max 300 seconds skew) and 32-byte HMAC-SHA256 digest.
#[inline]
pub fn verify_webhook_envelope(
    now_unix_sec: i64,
    header_timestamp_sec: i64,
    expected_hmac: &[u8; 32],
    provided_hmac: &[u8; 32],
) -> Result<(), ErpBridgeError> {
    let skew = (now_unix_sec - header_timestamp_sec).abs();
    if skew > 300 {
        return Err(ErpBridgeError::WebhookTimestampExpired { skew_seconds: skew });
    }
    if !constant_time_eq_32(expected_hmac, provided_hmac) {
        return Err(ErpBridgeError::InvalidWebhookSignature);
    }
    Ok(())
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum EntrySide {
    Debit,
    Credit,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct JournalLeg {
    pub account_item_id: u32,
    pub side: EntrySide,
    pub amount_yen: i64,
    pub tax_code: u16,
}

/// Immutable search index record satisfying Electronic Books Preservation Act Article 4.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ElectronicBookIndexEntry {
    pub idempotency_key: [u8; 32],
    pub transaction_date_yyyymmdd: u32,
    pub gross_amount_yen: i64,
    pub normalized_partner_name: String,
    pub document_sha256: [u8; 32],
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ErpBridgeError {
    WebhookTimestampExpired { skew_seconds: i64 },
    InvalidWebhookSignature,
    EmptyJournalLegs,
    NonPositiveLegAmount { leg_index: usize, amount_yen: i64 },
    UnbalancedDoubleEntry { debit_total_yen: i64, credit_total_yen: i64 },
    InvalidTransactionDate { yyyymmdd: u32 },
    EmptyPartnerName,
}

/// Verifies the double-entry bookkeeping invariant (Sum(Debit) == Sum(Credit) > 0)
/// and constructs a compliant Electronic Books Preservation Act 3-key search record.
pub fn build_verified_journal_and_archive_index(
    idempotency_key: [u8; 32],
    transaction_date_yyyymmdd: u32,
    partner_name: &str,
    document_sha256: [u8; 32],
    legs: &[JournalLeg],
) -> Result<ElectronicBookIndexEntry, ErpBridgeError> {
    if legs.is_empty() {
        return Err(ErpBridgeError::EmptyJournalLegs);
    }
    let year = transaction_date_yyyymmdd / 10_000;
    let month = (transaction_date_yyyymmdd / 100) % 100;
    let day = transaction_date_yyyymmdd % 100;
    if !(2000..=2100).contains(&year) || !(1..=12).contains(&month) || !(1..=31).contains(&day) {
        return Err(ErpBridgeError::InvalidTransactionDate {
            yyyymmdd: transaction_date_yyyymmdd,
        });
    }

    let normalized_partner = partner_name.trim().replace('u{3000}', " ");
    if normalized_partner.is_empty() {
        return Err(ErpBridgeError::EmptyPartnerName);
    }

    let mut debit_total_yen: i64 = 0;
    let mut credit_total_yen: i64 = 0;

    for (idx, leg) in legs.iter().enumerate() {
        if leg.amount_yen <= 0 {
            return Err(ErpBridgeError::NonPositiveLegAmount {
                leg_index: idx,
                amount_yen: leg.amount_yen,
            });
        }
        match leg.side {
            EntrySide::Debit => debit_total_yen = debit_total_yen.saturating_add(leg.amount_yen),
            EntrySide::Credit => credit_total_yen = credit_total_yen.saturating_add(leg.amount_yen),
        }
    }

    if debit_total_yen != credit_total_yen {
        return Err(ErpBridgeError::UnbalancedDoubleEntry {
            debit_total_yen,
            credit_total_yen,
        });
    }

    Ok(ElectronicBookIndexEntry {
        idempotency_key,
        transaction_date_yyyymmdd,
        gross_amount_yen: debit_total_yen,
        normalized_partner_name: normalized_partner,
        document_sha256,
    })
}