use serde::{Deserialize, Serialize};

use super::{
    item::Item, key_encryption::KeyEncryption,
    pcd_item_enc_attribute_private::PcdItemEncAttributePrivate,
    pcd_item_enc_attribute_public::PcdItemEncAttributePublic,
    pcd_item_enc_attribute_role_confidential::PcdItemEncAttributeRoleConfidential,
    pcd_item_generic_enc::PcdItemGenericEnc,
};
#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]

pub struct ItemMemberPublicAttributeGroup {
    pub sp_address_public: String,
    pub sp_address_public_sig: String,
    pub sp_address_revoke_public: String,
    pub sp_address_revoke_public_sig: String,
    pub third_sp_address_list_public: Vec<String>,
    pub data_size_max: i64,
    pub payment_method_list_public: Vec<String>,
    pub succession_process_hash: String,
}

impl ItemMemberPublicAttributeGroup {
    pub fn new(
        sp_address_public: String,
        sp_address_public_sig: String,
        sp_address_revoke_public: String,
        sp_address_revoke_public_sig: String,
        third_sp_address_list_public: Vec<String>,
        data_size_max: i64,
        payment_method_list_public: Vec<String>,
        succession_process_hash: String,
    ) -> Self {
        ItemMemberPublicAttributeGroup {
            sp_address_public,
            sp_address_public_sig,
            sp_address_revoke_public,
            sp_address_revoke_public_sig,
            third_sp_address_list_public,
            data_size_max,
            payment_method_list_public,
            succession_process_hash,
        }
    }
    pub fn enc_group(
        &self,
        process_public_enc_key: KeyEncryption,
    ) -> Vec<PcdItemEncAttributePublic> {
        let mut enc_attribute_list: Vec<PcdItemEncAttributePublic> = Vec::new();

        let sp_address_public_enc = PcdItemEncAttributePublic::new(
            "sp_address_public".to_owned(),
            process_public_enc_key.enc_string(self.sp_address_public.clone()),
        );
        enc_attribute_list.push(sp_address_public_enc);

        let sp_address_public_sig_enc = PcdItemEncAttributePublic::new(
            "sp_address_public_sig".to_owned(),
            process_public_enc_key.enc_string(self.sp_address_public_sig.clone()),
        );
        enc_attribute_list.push(sp_address_public_sig_enc);

        let sp_address_revoke_public_enc = PcdItemEncAttributePublic::new(
            "sp_address_revoke_public".to_owned(),
            process_public_enc_key.enc_string(self.sp_address_revoke_public.clone()),
        );
        enc_attribute_list.push(sp_address_revoke_public_enc);

        let sp_address_revoke_public_sig_enc = PcdItemEncAttributePublic::new(
            "sp_address_revoke_public_sig".to_owned(),
            process_public_enc_key.enc_string(self.sp_address_revoke_public_sig.clone()),
        );
        enc_attribute_list.push(sp_address_revoke_public_sig_enc);

        let third_sp_address_list_public_enc = PcdItemEncAttributePublic::new(
            "third_sp_address_list_public".to_owned(),
            process_public_enc_key.enc_vec_string(self.third_sp_address_list_public.clone()),
        );
        enc_attribute_list.push(third_sp_address_list_public_enc);

        let data_size_max_enc = PcdItemEncAttributePublic::new(
            "data_size_max".to_owned(),
            process_public_enc_key.enc_i64(self.data_size_max),
        );
        enc_attribute_list.push(data_size_max_enc);

        let payment_method_list_public_enc = PcdItemEncAttributePublic::new(
            "payment_method_list_public".to_owned(),
            process_public_enc_key.enc_vec_string(self.payment_method_list_public.clone()),
        );
        enc_attribute_list.push(payment_method_list_public_enc);

        let succession_process_hash_enc = PcdItemEncAttributePublic::new(
            "succession_process_hash".to_owned(),
            process_public_enc_key.enc_string(self.succession_process_hash.clone()),
        );
        enc_attribute_list.push(succession_process_hash_enc);

        enc_attribute_list
    }
    pub fn display_info(&self) {
        println!("ItemMemberPublicAttributeGroup:");
        println!("SP Address Public: {}", self.sp_address_public);
        println!(
            "SP Address Public Signature: {}",
            self.sp_address_public_sig
        );
        println!(
            "SP Address Revoke Public: {}",
            self.sp_address_revoke_public
        );
        println!(
            "SP Address Revoke Public Signature: {}",
            self.sp_address_revoke_public_sig
        );
        println!(
            "Third SP Address List Public: {:?}",
            self.third_sp_address_list_public
        );
        println!("Data Size Max: {}", self.data_size_max);
        println!(
            "Payment Method List Public: {:?}",
            self.payment_method_list_public
        );
        println!("Succession Process Hash: {}", self.succession_process_hash);
    }
}

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

pub struct ItemMemberRoleConfidentialAttributeGroup {
    pub payment_method_list_confidential: Vec<String>,
    pub id_shard_info: String,
}

impl ItemMemberRoleConfidentialAttributeGroup {
    pub fn new(payment_method_list_confidential: Vec<String>, id_shard_info: String) -> Self {
        ItemMemberRoleConfidentialAttributeGroup {
            payment_method_list_confidential,
            id_shard_info,
        }
    }

    pub fn enc_group(&self) -> Vec<PcdItemEncAttributeRoleConfidential> {
        let mut enc_attribute_list: Vec<PcdItemEncAttributeRoleConfidential> = Vec::new();

        let mut enc_payment_method_list_confidential_key = KeyEncryption::new(
            Some("payment_method_list_confidential".to_owned()),
            None,
            None,
        );
        if let Ok(_new) = enc_payment_method_list_confidential_key.key_new_random() {
            let payment_method_list_confidential_enc = PcdItemEncAttributeRoleConfidential::new(
                "payment_method_list_confidential".to_owned(),
                enc_payment_method_list_confidential_key
                    .enc_vec_string(self.payment_method_list_confidential.clone()),
                enc_payment_method_list_confidential_key,
            );
            enc_attribute_list.push(payment_method_list_confidential_enc);
        }

        let mut enc_id_shard_info_key =
            KeyEncryption::new(Some("id_shard_info".to_owned()), None, None);

        if let Ok(_new) = enc_id_shard_info_key.key_new_random() {
            let id_shard_info_enc = PcdItemEncAttributeRoleConfidential::new(
                "id_shard_info".to_owned(),
                enc_id_shard_info_key.enc_string(self.id_shard_info.clone()),
                enc_id_shard_info_key,
            );
            enc_attribute_list.push(id_shard_info_enc);
        }

        return enc_attribute_list;
    }
    pub fn display_info(&self) {
        println!("ItemMemberRoleConfidentialAttributeGroup:");
        println!(
            "Confidential Payment Method List: {:?}",
            self.payment_method_list_confidential
        );
        println!("ID Shard Info: {}", self.id_shard_info);
    }
}

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

pub struct ItemMemberPrivateAttributeGroup {
    pub payment_method_list_private: Vec<String>,
    pub pcd_list: Vec<String>, // Assuming this is a list of strings
    pub prd_list_list: Vec<String>,
    pub prd_update_list: Vec<String>,
    pub prd_response_list: Vec<String>,
    pub prd_message_list: Vec<String>,
    pub prd_confirm_list: Vec<String>,
    pub prd_key_backup_list: Vec<String>,
    pub prd_key_hello_list: Vec<String>,
    pub tx_sp_list: Vec<String>,
}

impl ItemMemberPrivateAttributeGroup {
    pub fn new(
        payment_method_list_private: Vec<String>,
        pcd_list: Vec<String>,
        prd_list_list: Vec<String>,
        prd_update_list: Vec<String>,
        prd_response_list: Vec<String>,
        prd_message_list: Vec<String>,
        prd_confirm_list: Vec<String>,
        prd_key_backup_list: Vec<String>,
        prd_key_hello_list: Vec<String>,
        tx_sp_list: Vec<String>,
    ) -> Self {
        ItemMemberPrivateAttributeGroup {
            payment_method_list_private,
            pcd_list,
            prd_list_list,
            prd_update_list,
            prd_response_list,
            prd_message_list,
            prd_confirm_list,
            prd_key_backup_list,
            prd_key_hello_list,
            tx_sp_list,
        }
    }

    pub fn enc_group(&self, member_enc_key: KeyEncryption) -> Vec<PcdItemEncAttributePrivate> {
        let mut enc_attribute_list: Vec<PcdItemEncAttributePrivate> = Vec::new();

        let payment_method_list_private_enc = PcdItemEncAttributePrivate::new(
            "payment_method_list_private".to_owned(),
            member_enc_key.enc_vec_string(self.payment_method_list_private.clone()),
        );
        enc_attribute_list.push(payment_method_list_private_enc);

        let pcd_list_enc = PcdItemEncAttributePrivate::new(
            "pcd_list".to_owned(),
            member_enc_key.enc_vec_string(self.pcd_list.clone()),
        );
        enc_attribute_list.push(pcd_list_enc);

        let prd_list_list_enc = PcdItemEncAttributePrivate::new(
            "prd_list_list".to_owned(),
            member_enc_key.enc_vec_string(self.prd_list_list.clone()),
        );
        enc_attribute_list.push(prd_list_list_enc);

        let prd_update_list_enc = PcdItemEncAttributePrivate::new(
            "prd_update_list".to_owned(),
            member_enc_key.enc_vec_string(self.prd_update_list.clone()),
        );
        enc_attribute_list.push(prd_update_list_enc);

        let prd_response_list_enc = PcdItemEncAttributePrivate::new(
            "prd_response_list".to_owned(),
            member_enc_key.enc_vec_string(self.prd_response_list.clone()),
        );
        enc_attribute_list.push(prd_response_list_enc);

        let prd_message_list_enc = PcdItemEncAttributePrivate::new(
            "prd_message_list".to_owned(),
            member_enc_key.enc_vec_string(self.prd_message_list.clone()),
        );
        enc_attribute_list.push(prd_message_list_enc);

        let prd_confirm_list_enc = PcdItemEncAttributePrivate::new(
            "prd_confirm_list".to_owned(),
            member_enc_key.enc_vec_string(self.prd_confirm_list.clone()),
        );
        enc_attribute_list.push(prd_confirm_list_enc);

        let prd_key_backup_list_enc = PcdItemEncAttributePrivate::new(
            "prd_key_backup_list".to_owned(),
            member_enc_key.enc_vec_string(self.prd_key_backup_list.clone()),
        );
        enc_attribute_list.push(prd_key_backup_list_enc);

        let prd_key_hello_list_enc = PcdItemEncAttributePrivate::new(
            "prd_key_hello_list".to_owned(),
            member_enc_key.enc_vec_string(self.prd_key_hello_list.clone()),
        );
        enc_attribute_list.push(prd_key_hello_list_enc);

        let tx_sp_list_enc = PcdItemEncAttributePrivate::new(
            "tx_sp_list".to_owned(),
            member_enc_key.enc_vec_string(self.tx_sp_list.clone()),
        );
        enc_attribute_list.push(tx_sp_list_enc);

        enc_attribute_list
    }
    pub fn display_info(&self) {
        println!("ItemMemberPrivateAttributeGroup:");
        println!(
            "Private Payment Method List: {:?}",
            self.payment_method_list_private
        );
        println!("PCD List: {:?}", self.pcd_list);
        println!("PRD List List: {:?}", self.prd_list_list);
        println!("PRD Update List: {:?}", self.prd_update_list);
        println!("PRD Response List: {:?}", self.prd_response_list);
        println!("PRD Message List: {:?}", self.prd_message_list);
        println!("PRD Confirm List: {:?}", self.prd_confirm_list);
        println!("PRD Key Backup List: {:?}", self.prd_key_backup_list);
        println!("PRD Key Hello List: {:?}", self.prd_key_hello_list);
        println!("TX SP List: {:?}", self.tx_sp_list);
    }
}

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

pub struct ItemMember {
    pub item: Item,
    pub public_attribute_group: ItemMemberPublicAttributeGroup,
    pub role_confidential_attribute_group: ItemMemberRoleConfidentialAttributeGroup,
    pub private_attribute_group: ItemMemberPrivateAttributeGroup,
}

impl ItemMember {
    pub const ITEM_NAME: &'static str = "member";
    pub fn new(
        mut item: Item,
        public_attribute_group: ItemMemberPublicAttributeGroup,
        role_confidential_attribute_group: ItemMemberRoleConfidentialAttributeGroup,
        private_attribute_group: ItemMemberPrivateAttributeGroup,
    ) -> Self {
        item.name = Self::ITEM_NAME.to_string();
        ItemMember {
            item,
            public_attribute_group,
            role_confidential_attribute_group,
            private_attribute_group,
        }
    }
    pub fn enc(
        &self,
        process_public_enc_key: KeyEncryption,
        member_private_enc_key: KeyEncryption,
    ) -> PcdItemGenericEnc {
        let enc_metadata_contract_public = self
            .public_attribute_group
            .enc_group(process_public_enc_key.clone());

        let enc_role_confidential_attribute_group =
            self.role_confidential_attribute_group.enc_group();

        let enc_metadata_private = self
            .private_attribute_group
            .enc_group(member_private_enc_key.clone());

        PcdItemGenericEnc::new(
            self.item
                .enc(process_public_enc_key, member_private_enc_key),
            Some(enc_metadata_contract_public),
            Some(enc_role_confidential_attribute_group),
            Some(enc_metadata_private),
        )
    }
    pub fn display_info(&self) {
        println!("ItemMember:");
        println!("Item:");
        self.item.display_info(); // Affiche les informations de l'objet `item`

        println!("Member Public Attribute Group:");
        self.public_attribute_group.display_info(); // Affiche les informations du groupe d'attributs publics

        println!("Member Role Confidential Attribute Group:");
        self.role_confidential_attribute_group.display_info(); // Affiche les informations du groupe d'attributs confidentiels

        println!("Member Private Attribute Group:");
        self.private_attribute_group.display_info(); // Affiche les informations du groupe d'attributs privés
    }
}