koios-sdk 0.1.1

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

use super::{
    governance::{ProposalWithdrawal, VoterRole},
    AssetItem, ProposalType, Vote,
};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TransactionInfo {
    pub tx_hash: String,
    pub block_hash: String,
    pub block_height: u64,
    pub epoch_no: u64,
    pub epoch_slot: u64,
    pub absolute_slot: u64,
    pub tx_timestamp: u64,
    pub tx_block_index: u64,
    pub tx_size: u64,
    pub total_output: String,
    pub fee: String,
    pub treasury_donation: String,
    pub deposit: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub invalid_before: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub invalid_after: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub collateral_inputs: Option<Vec<TransactionOutput>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub collateral_output: Option<Vec<TransactionOutput>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reference_inputs: Option<Vec<TransactionOutput>>,
    pub inputs: Vec<TransactionOutput>,
    pub outputs: Vec<TransactionOutput>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub withdrawals: Option<Vec<Withdrawal>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub assets_minted: Option<Vec<AssetItem>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata: Option<HashMap<String, serde_json::Value>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub certificates: Option<Vec<Certificate>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub native_scripts: Option<Vec<NativeScript>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub plutus_contracts: Option<Vec<PlutusContract>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voting_procedures: Option<Vec<VotingProcedure>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub proposal_procedures: Option<Vec<ProposalProcedure>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VotingProcedure {
    pub proposal_tx_hash: String,
    pub proposal_index: u64,
    pub voter_role: VoterRole,
    pub voter: String,
    pub voter_hex: String,
    pub vote: Vote,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub meta_url: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub meta_hash: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProposalProcedure {
    pub index: u64,
    #[serde(rename = "type")]
    pub proposal_type: ProposalType,
    pub description: String,
    pub deposit: String,
    pub return_address: String,
    pub expiration: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub meta_url: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub meta_hash: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub withdrawal: Option<ProposalWithdrawal>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub param_proposal: Option<serde_json::Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TransactionOutput {
    pub payment_addr: PaymentAddress,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stake_addr: Option<String>,
    pub tx_hash: String,
    pub tx_index: u64,
    pub value: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub datum_hash: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub inline_datum: Option<InlineDatum>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reference_script: Option<ReferenceScript>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub asset_list: Option<Vec<AssetItem>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PaymentAddress {
    pub bech32: String,
    pub cred: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InlineDatum {
    pub bytes: String,
    pub value: serde_json::Value,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ReferenceScript {
    pub hash: String,
    pub size: u64,
    #[serde(rename = "type")]
    pub script_type: String,
    pub bytes: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub value: Option<serde_json::Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Withdrawal {
    pub amount: String,
    pub stake_addr: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Certificate {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub index: Option<u64>,
    #[serde(rename = "type")]
    pub cert_type: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub info: Option<serde_json::Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NativeScript {
    pub script_hash: String,
    pub script_json: Option<serde_json::Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PlutusContract {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub spends_input: Option<SpendInput>,
    pub script_hash: String,
    pub bytecode: String,
    pub size: u64,
    pub valid_contract: bool,
    pub input: PlutusInput,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SpendInput {
    pub tx_hash: String,
    pub tx_index: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PlutusInput {
    pub redeemer: Redeemer,
    pub datum: Datum,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Redeemer {
    pub purpose: String,
    pub fee: String,
    pub unit: RedeemerUnit,
    pub datum: Datum,
}

#[derive(Debug, Clone, Serialize, Copy, Deserialize)]
pub struct RedeemerUnit {
    pub steps: u64,
    pub mem: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Datum {
    pub hash: String,
    pub value: serde_json::Value,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TransactionCbor {
    pub tx_hash: String,
    pub block_hash: String,
    pub block_height: u64,
    pub epoch_no: u64,
    pub absolute_slot: u64,
    pub tx_timestamp: u64,
    pub cbor: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TransactionStatus {
    pub tx_hash: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub num_confirmations: Option<u64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TransactionMetadata {
    pub tx_hash: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Value>,
}

// Implementation blocks for key types
impl TransactionInfo {
    pub fn new(
        tx_hash: String,
        block_hash: String,
        block_height: u64,
        epoch_no: u64,
        epoch_slot: u64,
        absolute_slot: u64,
        tx_timestamp: u64,
        tx_block_index: u64,
        tx_size: u64,
        total_output: String,
        fee: String,
        treasury_donation: String,
        deposit: String,
        inputs: Vec<TransactionOutput>,
        outputs: Vec<TransactionOutput>,
    ) -> Self {
        Self {
            tx_hash,
            block_hash,
            block_height,
            epoch_no,
            epoch_slot,
            absolute_slot,
            tx_timestamp,
            tx_block_index,
            tx_size,
            total_output,
            fee,
            treasury_donation,
            deposit,
            invalid_before: None,
            invalid_after: None,
            collateral_inputs: None,
            collateral_output: None,
            reference_inputs: None,
            inputs,
            outputs,
            withdrawals: None,
            assets_minted: None,
            metadata: None,
            certificates: None,
            native_scripts: None,
            plutus_contracts: None,
            voting_procedures: None,
            proposal_procedures: None,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TxMetaLabels {
    pub key: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UtxoInfo {
    pub tx_hash: String,
    pub tx_index: u64,
    pub address: String,
    pub value: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stake_address: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub payment_cred: Option<String>,
    pub epoch_no: u64,
    pub block_height: u64,
    pub block_time: u64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub datum_hash: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub inline_datum: Option<serde_json::Value>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reference_script: Option<serde_json::Value>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub asset_list: Option<Vec<AssetItem>>,
    pub is_spent: bool,
}
impl UtxoInfo {
    pub fn new(
        tx_hash: String,
        tx_index: u64,
        address: String,
        value: String,
        epoch_no: u64,
        block_height: u64,
        block_time: u64,
        is_spent: bool,
    ) -> Self {
        Self {
            tx_hash,
            tx_index,
            address,
            value,
            stake_address: None,
            payment_cred: None,
            epoch_no,
            block_height,
            block_time,
            datum_hash: None,
            inline_datum: None,
            reference_script: None,
            asset_list: None,
            is_spent,
        }
    }
}