use serde::{Deserialize, Serialize};

use super::{
    condition_cap::ConditionCap, condition_commitment::ConditionCommitment,
    condition_orchestration::ConditionOrchestration, condition_payment::ConditionPayment,
    condition_prd_address_set::ConditionPrdAddressSet, condition_publish::ConditionPublish,
    item::Item, metadata::Amount,
};
#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]

pub struct TransactionModeDistribution {
    pub from_prd_update_from: String,
    pub from_role_list: Vec<String>,
    pub to_role_list: Vec<String>,
    pub from_prd_address_list: Vec<String>,
    pub to_prd_address_list: Vec<String>,
    pub method: String,
}

impl TransactionModeDistribution {
    pub fn new(
        from_prd_update_from: String,
        from_role_list: Vec<String>,
        to_role_list: Vec<String>,
        from_prd_address_list: Vec<String>,
        to_prd_address_list: Vec<String>,
        method: String,
    ) -> Self {
        TransactionModeDistribution {
            from_prd_update_from,
            from_role_list,
            to_role_list,
            from_prd_address_list,
            to_prd_address_list,
            method,
        }
    }
    // display_info method
    pub fn display_info(&self) {
        println!("TransactionModeDistribution:");
        println!("From PRD Update From: {}", self.from_prd_update_from);
        println!("From Role List: {:?}", self.from_role_list);
        println!("To Role List: {:?}", self.to_role_list);
        println!("From PRD Address List: {:?}", self.from_prd_address_list);
        println!("To PRD Address List: {:?}", self.to_prd_address_list);
        println!("Method: {}", self.method);
    }
}

#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]

pub struct TransactionModeDirect {
    pub from_prd_update_from: String,
    pub to_role_owner: String,
}

impl TransactionModeDirect {
    pub fn new(from_prd_update_from: String, to_role_owner: String) -> Self {
        TransactionModeDirect {
            from_prd_update_from,
            to_role_owner,
        }
    }

    // display_info method
    pub fn display_info(&self) {
        println!("TransactionModeDirect:");
        println!("From PRD Update From: {}", self.from_prd_update_from);
        println!("To Role Owner: {}", self.to_role_owner);
    }
}

#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct TransactionMode {
    pub amount: Amount,
    pub role_transaction_distribution: TransactionModeDistribution,
    pub role_transaction_direct: TransactionModeDirect,
}

impl TransactionMode {
    pub fn new(
        amount: Amount,
        role_transaction_distribution: TransactionModeDistribution,
        role_transaction_direct: TransactionModeDirect,
    ) -> Self {
        TransactionMode {
            amount,
            role_transaction_distribution,
            role_transaction_direct,
        }
    }

    // display_info method
    pub fn display_info(&self) {
        println!("TransactionMode:");

        println!("Amount:");
        self.amount.display_info(); // Assuming Amount has a display_info method

        println!("Role Transaction Distribution:");
        self.role_transaction_distribution.display_info(); // Assuming TransactionModeDistribution has a display_info method

        println!("Role Transaction Direct:");
        self.role_transaction_direct.display_info(); // Assuming TransactionModeDirect has a display_info method
    }
}

#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]

pub struct Role {
    pub item: Item,
    pub required_2fa: bool,
    pub validation_timeout: u64,
    pub condition_prd_address_set_list: Vec<ConditionPrdAddressSet>, // Assuming ConditionPrdAddressSet is a predefined struct
    pub condition_publish: ConditionPublish, // Assuming ConditionPublish is a predefined struct
    pub condition_cap_list: Vec<ConditionCap>, // Assuming ConditionCap is a predefined struct
    pub condition_payment_list: Vec<ConditionPayment>, // Assuming ConditionPayment is a predefined struct
    pub condition_commitment_list: Vec<ConditionCommitment>, // Assuming ConditionCommitment is a predefined struct
    pub condition_attribute_encryption_list: Vec<String>,
    pub condition_orchestration: ConditionOrchestration, // Assuming ConditionOrchestration is a predefined struct
    pub role_succession: Option<String>,
    pub role_resolve: Option<String>,
    pub role_renew: Option<String>,
}

impl Role {
    pub fn new(
        item: Item,
        required_2fa: bool,
        validation_timeout: u64,
        condition_prd_address_set_list: Vec<ConditionPrdAddressSet>,
        condition_publish: ConditionPublish,
        condition_cap_list: Vec<ConditionCap>,
        condition_payment_list: Vec<ConditionPayment>,
        condition_commitment_list: Vec<ConditionCommitment>,
        condition_attribute_encryption_list: Vec<String>,
        condition_orchestration: ConditionOrchestration,
        role_succession: Option<String>,
        role_resolve: Option<String>,
        role_renew: Option<String>,
    ) -> Self {
        Role {
            item,
            required_2fa,
            validation_timeout,
            condition_prd_address_set_list,
            condition_publish,
            condition_cap_list,
            condition_payment_list,
            condition_commitment_list,
            condition_attribute_encryption_list,
            condition_orchestration,
            role_succession,
            role_resolve,
            role_renew,
        }
    }
    // display_info method
    pub fn display_info(&self) {
        println!("Role:");
        println!("Item: {:?}", self.item); // Assuming `Item` implements Debug trait
        println!("Validation Timeout: {}", self.validation_timeout);

        println!("ConditionPrdAddressSet List:");
        for condition in &self.condition_prd_address_set_list {
            condition.display_info(); // Assuming `ConditionPrdAddressSet` has a display_info method
        }

        println!("ConditionPublish:");
        self.condition_publish.display_info(); // Assuming `ConditionPublish` has a display_info method

        println!("ConditionCap List:");
        for condition in &self.condition_cap_list {
            condition.display_info(); // Assuming `ConditionCap` has a display_info method
        }

        println!("ConditionPayment List:");
        for condition in &self.condition_payment_list {
            condition.display_info(); // Assuming `ConditionPayment` has a display_info method
        }

        println!("ConditionCommitment List:");
        for condition in &self.condition_commitment_list {
            condition.display_info(); // Assuming `ConditionCommitment` has a display_info method
        }

        println!("ConditionAttributeEncryption:");
        for condition in &self.condition_attribute_encryption_list {
            println!("ConditionAttributeEncryption: {:?}", condition);
        }

        println!("ConditionOrchestration:");
        self.condition_orchestration.display_info(); // Assuming `ConditionOrchestration` has a display_info method

        println!("Role Succession: {:?}", self.role_succession);
        println!("Role Resolve: {:?}", self.role_resolve);
        println!("Role Renew: {:?}", self.role_renew);
    }

    // Additional methods for Role can be added here
}