use serde::{Deserialize, Serialize};

use super::{
    key_encryption::KeyEncryption, metadata::MetaData,
    pcd_item_enc_attribute_private::PcdItemEncAttributePrivate,
};

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

pub struct MetadataPrivate {
    pub meta_data: MetaData,
}

impl MetadataPrivate {
    pub fn new(meta_data: MetaData) -> Self {
        MetadataPrivate { meta_data }
    }
    pub fn display_info(&self) {
        println!("MetadataPrivate:");
        // Assuming MetaData has a display_info method
        self.meta_data.display_info(); // Display information for `meta_data`
    }
    pub fn enc_list(
        &self,
        member_private_enc_key: KeyEncryption,
    ) -> Vec<PcdItemEncAttributePrivate> {
        let mut enc_attribute_list: Vec<PcdItemEncAttributePrivate> = Vec::new();

        let enc_attribute_tag_list_key = KeyEncryption::new(
            Some("tag_list".to_owned()),
            member_private_enc_key.key.clone(),
            member_private_enc_key.algorithm.clone(),
        );
        let enc_attribute_tag_list = PcdItemEncAttributePrivate::new(
            "tag_list".to_owned(),
            enc_attribute_tag_list_key.enc_vec_string(self.meta_data.tag_list.clone()),
        );
        enc_attribute_list.push(enc_attribute_tag_list);

        let enc_attribute_zone_list_key = KeyEncryption::new(
            Some("zone_list".to_owned()),
            member_private_enc_key.key.clone(),
            member_private_enc_key.algorithm.clone(),
        );
        let enc_attribute_zone_list = PcdItemEncAttributePrivate::new(
            "zone_list".to_owned(),
            enc_attribute_zone_list_key.enc_vec_string(self.meta_data.zone_list.clone()),
        );
        enc_attribute_list.push(enc_attribute_zone_list);

        let enc_attribute_label_list_key = KeyEncryption::new(
            Some("label_list".to_owned()),
            member_private_enc_key.key.clone(),
            member_private_enc_key.algorithm.clone(),
        );
        let enc_attribute_label_list = PcdItemEncAttributePrivate::new(
            "label_list".to_owned(),
            enc_attribute_label_list_key.enc_vec_string(self.meta_data.label_list.clone()),
        );
        enc_attribute_list.push(enc_attribute_label_list);

        let enc_attribute_ref_list_key = KeyEncryption::new(
            Some("ref_list".to_owned()),
            member_private_enc_key.key.clone(),
            member_private_enc_key.algorithm.clone(),
        );
        let enc_attribute_ref_list = PcdItemEncAttributePrivate::new(
            "ref_list".to_owned(),
            enc_attribute_ref_list_key.enc_vec_string(self.meta_data.ref_list.clone()),
        );
        enc_attribute_list.push(enc_attribute_ref_list);

        let enc_attribute_data_list_key = KeyEncryption::new(
            Some("data_list".to_owned()),
            member_private_enc_key.key.clone(),
            member_private_enc_key.algorithm.clone(),
        );
        let enc_attribute_data_list = PcdItemEncAttributePrivate::new(
            "data_list".to_owned(),
            enc_attribute_data_list_key.enc_vec_string(self.meta_data.data_list.clone()),
        );
        enc_attribute_list.push(enc_attribute_data_list);

        let enc_attribute_amount_key = KeyEncryption::new(
            Some("amount".to_owned()),
            member_private_enc_key.key.clone(),
            member_private_enc_key.algorithm.clone(),
        );
        let enc_attribute_amount = PcdItemEncAttributePrivate::new(
            "amount".to_owned(),
            enc_attribute_amount_key.enc_amount(self.meta_data.amount.clone()),
        );
        enc_attribute_list.push(enc_attribute_amount);

        let enc_attribute_number_key = KeyEncryption::new(
            Some("number".to_owned()),
            member_private_enc_key.key.clone(),
            member_private_enc_key.algorithm.clone(),
        );
        let enc_attribute_number = PcdItemEncAttributePrivate::new(
            "number".to_owned(),
            enc_attribute_number_key.enc_number(self.meta_data.number.clone()),
        );
        enc_attribute_list.push(enc_attribute_number);

        let enc_attribute_render_template_list_key = KeyEncryption::new(
            Some("render_template_list".to_owned()),
            member_private_enc_key.key.clone(),
            member_private_enc_key.algorithm.clone(),
        );
        let enc_attribute_render_template_list = PcdItemEncAttributePrivate::new(
            "render_template_list".to_owned(),
            enc_attribute_render_template_list_key
                .enc_vec_string(self.meta_data.render_template_list.clone()),
        );
        enc_attribute_list.push(enc_attribute_render_template_list);

        let enc_attribute_legal_text_list_key = KeyEncryption::new(
            Some("legal_text_list".to_owned()),
            member_private_enc_key.key.clone(),
            member_private_enc_key.algorithm.clone(),
        );
        let enc_attribute_legal_text_list = PcdItemEncAttributePrivate::new(
            "legal_text_list".to_owned(),
            enc_attribute_legal_text_list_key
                .enc_vec_string(self.meta_data.legal_text_list.clone()),
        );
        enc_attribute_list.push(enc_attribute_legal_text_list);

        let enc_attribute_key_list_key = KeyEncryption::new(
            Some("key_list".to_owned()),
            member_private_enc_key.key.clone(),
            member_private_enc_key.algorithm.clone(),
        );
        let enc_attribute_key_list = PcdItemEncAttributePrivate::new(
            "key_list".to_owned(),
            enc_attribute_key_list_key.enc_vec_key_encryption(self.meta_data.key_list.clone()),
        );
        enc_attribute_list.push(enc_attribute_key_list);

        return enc_attribute_list;
    }
}