use serde::{Deserialize, Serialize};

use super::key_encryption::KeyEncryption;
#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]

pub struct Number {
    pub fixed_state: bool,
    pub number: i32,
    pub number_unit: String,
}

impl Number {
    // Constructor for Number struct
    pub fn new(fixed_state: bool, number: i32, number_unit: String) -> Self {
        Number {
            fixed_state,
            number,
            number_unit,
        }
    }
    pub fn display_info(&self) {
        println!("Number:");
        println!("Fixed State: {}", self.fixed_state);
        println!("Number: {}", self.number);
        println!("Number Unit: {}", self.number_unit);
    }

    // Additional methods for Number can be added here.
}

// Struct for representing an amount with various attributes.
#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]

pub struct Amount {
    pub timestamp: u64,
    pub change_source_list: Vec<String>,
    pub amount_cent: i64,
    pub amount_unit: String,
    pub amount_unit_ref: String, // This can be a reference to an external unit system.
}

impl Amount {
    // Constructor for Amount struct
    pub fn new(
        timestamp: u64,
        change_source_list: Vec<String>,
        amount_cent: i64,
        amount_unit: String,
        amount_unit_ref: String,
    ) -> Self {
        Amount {
            timestamp,
            change_source_list,
            amount_cent,
            amount_unit,
            amount_unit_ref,
        }
    }
    pub fn display(&self) -> String {
        format!(
            "Amount: {} {} {} {} {}",
            self.timestamp,
            self.change_source_list.join(","),
            self.amount_cent,
            self.amount_unit,
            self.amount_unit_ref
        )
    }
    pub fn display_info(&self) {
        println!("Amount:");
        println!("Timestamp: {}", self.timestamp);
        println!("Change Source List: {:?}", self.change_source_list);
        println!("Amount cent: {}", self.amount_cent);
        println!("Amount Unit: {}", self.amount_unit);
        println!("Amount Unit Reference: {}", self.amount_unit_ref);
    }
    // Additional methods for Amount can be added here.
}

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

pub struct MetaData {
    pub tag_list: Vec<String>,
    pub zone_list: Vec<String>,
    pub label_list: Vec<String>,
    pub ref_list: Vec<String>,
    pub data_list: Vec<String>,
    pub amount: Amount,
    pub number: Number,
    pub render_template_list: Vec<String>,
    pub legal_text_list: Vec<String>,
    pub key_list: Vec<KeyEncryption>,
}

impl MetaData {
    pub fn new(
        tag_list: Vec<String>,
        zone_list: Vec<String>,
        label_list: Vec<String>,
        ref_list: Vec<String>,
        data_list: Vec<String>,
        amount: Amount,
        number: Number,
        render_template_list: Vec<String>,
        legal_text_list: Vec<String>,
        key_list: Vec<KeyEncryption>,
    ) -> Self {
        MetaData {
            tag_list,
            zone_list,
            label_list,
            ref_list,
            data_list,
            amount,
            number,
            render_template_list,
            legal_text_list,
            key_list,
        }
    }
    pub fn display_info(&self) {
        println!("MetaData:");
        println!("Tag List: {:?}", self.tag_list);
        println!("Zone List: {:?}", self.zone_list);
        println!("Label List: {:?}", self.label_list);
        println!("Ref List: {:?}", self.ref_list);
        println!("Data List: {:?}", self.data_list);

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

        println!("Number:");
        self.number.display_info(); // Assuming Number has a display_info method

        println!("Render Template List: {:?}", self.render_template_list);
        println!("Legal Text List: {:?}", self.legal_text_list);

        println!("Key List:");
        for key in &self.key_list {
            key.display_info(); // Assuming KeyEncryption has a display_info method
        }
    }

    // Methods for manipulating MetaData can be added here.
}