koios-sdk 0.1.1

use serde::{Deserialize, Serialize};

use super::Vote;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PoolMetadata {
    pub name: String,
    pub ticker: String,
    pub homepage: String,
    pub description: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, Copy, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum PoolStatus {
    Registered,
    Retiring,
    Retired,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PoolInfo {
    pub pool_id_bech32: String,
    pub pool_id_hex: String,
    pub active_epoch_no: u64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vrf_key_hash: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub margin: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fixed_cost: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pledge: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deposit: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reward_addr: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reward_addr_delegated_drep: Option<String>,
    pub owners: Option<Vec<String>>,
    pub relays: Vec<RelayInfo>,
    #[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 meta_json: Option<PoolMetadata>,
    pub pool_status: PoolStatus,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub retiring_epoch: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub op_cert: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub op_cert_counter: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub active_stake: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sigma: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub block_count: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub live_pledge: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub live_stake: Option<String>,
    pub live_delegators: u64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub live_saturation: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voting_power: Option<String>,
}

// Fix for PoolList struct
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PoolList {
    pub pool_id_bech32: String,
    pub pool_id_hex: String,
    pub active_epoch_no: u64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub margin: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fixed_cost: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pledge: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deposit: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reward_addr: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reward_addr_delegated_drep: Option<String>,
    pub owners: Vec<String>,
    pub relays: Vec<RelayInfo>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ticker: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub meta_url: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub meta_hash: Option<String>,
    pub pool_status: PoolStatus,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub active_stake: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub retiring_epoch: Option<u64>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PoolHistoryInfo {
    pub epoch_no: u64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub active_stake: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub active_stake_pct: Option<f64>,
    pub saturation_pct: f64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub block_cnt: Option<u64>,
    pub delegator_cnt: u64,
    pub margin: f64,
    pub fixed_cost: String,
    pub pool_fees: String,
    pub deleg_rewards: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member_rewards: Option<String>,
    pub epoch_ros: f64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PoolSnapshot {
    pub snapshot: SnapshotType,
    pub epoch_no: u64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub nonce: Option<String>,
    pub pool_stake: String,
    pub active_stake: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, Copy, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum SnapshotType {
    Mark,
    Set,
    Go,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PoolDelegatorsHistory {
    pub stake_address: String,
    pub amount: String,
    pub epoch_no: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PoolVotes {
    pub proposal_id: String,
    pub proposal_tx_hash: String,
    pub proposal_index: u64,
    pub vote_tx_hash: String,
    pub block_time: u64,
    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>,
}

// Implementation blocks
impl PoolHistoryInfo {
    pub fn new(
        epoch_no: u64,
        saturation_pct: f64,
        delegator_cnt: u64,
        margin: f64,
        fixed_cost: String,
        pool_fees: String,
        deleg_rewards: String,
        epoch_ros: f64,
    ) -> Self {
        Self {
            epoch_no,
            active_stake: None,
            active_stake_pct: None,
            saturation_pct,
            block_cnt: None,
            delegator_cnt,
            margin,
            fixed_cost,
            pool_fees,
            deleg_rewards,
            member_rewards: None,
            epoch_ros,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PoolDelegator {
    pub stake_address: String,
    pub amount: String,
    pub active_epoch_no: u64,
    pub latest_delegation_tx_hash: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PoolRegistration {
    pub pool_id_bech32: String,
    pub tx_hash: String,
    pub block_hash: String,
    pub block_height: u64,
    pub epoch_no: u64,
    pub epoch_slot: u64,
    pub active_epoch_no: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PoolDelegatorHistory {
    pub stake_address: String,
    pub amount: String,
    pub epoch_no: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PoolBlock {
    pub epoch_no: u64,
    pub epoch_slot: u64,
    pub abs_slot: u64,
    pub block_height: u64,
    pub block_hash: String,
    pub block_time: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PoolUpdate {
    pub tx_hash: String,
    pub block_time: u64,
    pub pool_id_bech32: String,
    pub pool_id_hex: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub active_epoch_no: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vrf_key_hash: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub margin: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fixed_cost: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pledge: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reward_addr: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub owners: Option<Vec<String>>,
    pub relays: Vec<PoolRelay>,
    #[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 meta_json: Option<PoolMetadata>,
    pub update_type: UpdateType,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub retiring_epoch: Option<u64>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Copy, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum UpdateType {
    Registration,
    Deregistration,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PoolRelay {
    pub pool_id_bech32: String,
    pub relays: Vec<RelayInfo>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RelayInfo {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dns: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub srv: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ipv4: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ipv6: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub port: Option<u16>,
}

// Implementation blocks
impl PoolRelay {
    pub fn new(pool_id_bech32: String) -> Self {
        Self {
            pool_id_bech32,
            relays: Vec::new(),
        }
    }
}

impl Default for RelayInfo {
    fn default() -> Self {
        Self::new()
    }
}

impl RelayInfo {
    pub fn new() -> Self {
        Self {
            dns: None,
            srv: None,
            ipv4: None,
            ipv6: None,
            port: None,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PoolMetadataInfo {
    pub pool_id_bech32: String,
    #[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 meta_json: Option<PoolMetadata>,
}

// Implementation blocks for constructors and utility methods
impl PoolDelegator {
    pub fn new(
        stake_address: String,
        amount: String,
        active_epoch_no: u64,
        latest_delegation_tx_hash: String,
    ) -> Self {
        Self {
            stake_address,
            amount,
            active_epoch_no,
            latest_delegation_tx_hash,
        }
    }
}

impl PoolBlock {
    pub fn new(
        epoch_no: u64,
        epoch_slot: u64,
        abs_slot: u64,
        block_height: u64,
        block_hash: String,
        block_time: u64,
    ) -> Self {
        Self {
            epoch_no,
            epoch_slot,
            abs_slot,
            block_height,
            block_hash,
            block_time,
        }
    }
}

impl PoolUpdate {
    pub fn new(
        tx_hash: String,
        block_time: u64,
        pool_id_bech32: String,
        pool_id_hex: String,
        update_type: UpdateType,
    ) -> Self {
        Self {
            tx_hash,
            block_time,
            pool_id_bech32,
            pool_id_hex,
            active_epoch_no: None,
            vrf_key_hash: None,
            margin: None,
            fixed_cost: None,
            pledge: None,
            reward_addr: None,
            owners: None,
            relays: Vec::new(),
            meta_url: None,
            meta_hash: None,
            meta_json: None,
            update_type,
            retiring_epoch: None,
        }
    }
}