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 ItemCommitmentPublicAttributeGroup {
    pub for_sp_address_list: Vec<String>,
    pub goal_list: Vec<String>,
    pub provider_type: String,
    pub commitment_pcd_hash_list: Vec<String>,
    pub ref_item_hash_list: Vec<String>,
    pub ref_pcd_hash_list: Vec<String>,
    pub payload_public_list: Vec<String>,
}

impl ItemCommitmentPublicAttributeGroup {
    pub fn new(
        for_sp_address_list: Vec<String>,
        goal_list: Vec<String>,
        provider_type: String,
        commitment_pcd_hash_list: Vec<String>,
        ref_item_hash_list: Vec<String>,
        ref_pcd_hash_list: Vec<String>,
        payload_public_list: Vec<String>,
    ) -> Self {
        ItemCommitmentPublicAttributeGroup {
            for_sp_address_list,
            goal_list,
            provider_type,
            commitment_pcd_hash_list,
            ref_item_hash_list,
            ref_pcd_hash_list,
            payload_public_list,
        }
    }
    pub fn enc_group(
        &self,
        process_public_enc_key: KeyEncryption,
    ) -> Vec<PcdItemEncAttributePublic> {
        let mut enc_attribute_list: Vec<PcdItemEncAttributePublic> = Vec::new();

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

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

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

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

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

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

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

        enc_attribute_list
    }
    pub fn display_info(&self) {
        println!("ItemCommitmentPublicAttributeGroup:");
        println!("For SP Address List: {:?}", self.for_sp_address_list);
        println!("Goal List: {:?}", self.goal_list);
        println!("Provider Type: {}", self.provider_type);
        println!(
            "Commitment PCD Hash List: {:?}",
            self.commitment_pcd_hash_list
        );
        println!("Ref Item Hash List: {:?}", self.ref_item_hash_list);
        println!("Ref PCD Hash List: {:?}", self.ref_pcd_hash_list);
        println!("Payload Public List: {:?}", self.payload_public_list);
    }
}

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

pub struct ItemCommitmentRoleConfidentialAttributeGroup {
    pub payload_list_confidential: Vec<String>,
}

impl ItemCommitmentRoleConfidentialAttributeGroup {
    pub fn new(payload_list_confidential: Vec<String>) -> Self {
        ItemCommitmentRoleConfidentialAttributeGroup {
            payload_list_confidential,
        }
    }
    pub fn enc_group(&self) -> Vec<PcdItemEncAttributeRoleConfidential> {
        let mut enc_attribute_list: Vec<PcdItemEncAttributeRoleConfidential> = Vec::new();

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

        return enc_attribute_list;
    }
    pub fn display_info(&self) {
        println!("ItemCommitmentRoleConfidentialAttributeGroup:");
        for (index, payload) in self.payload_list_confidential.iter().enumerate() {
            println!("Confidential Payload {}: {}", index + 1, payload);
        }
    }
}

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

pub struct ItemCommitmentPrivateAttributeGroup {
    pub payload_list_private: Vec<String>,
}

impl ItemCommitmentPrivateAttributeGroup {
    pub fn new(payload_list_private: Vec<String>) -> Self {
        ItemCommitmentPrivateAttributeGroup {
            payload_list_private,
        }
    }
    pub fn enc_group(&self, member_enc_key: KeyEncryption) -> Vec<PcdItemEncAttributePrivate> {
        let mut enc_attribute_list: Vec<PcdItemEncAttributePrivate> = Vec::new();

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

        enc_attribute_list
    }
    pub fn display_info(&self) {
        println!("ItemCommitmentRoleConfidentialAttributeGroup:");
        for (index, payload) in self.payload_list_private.iter().enumerate() {
            println!("Private Payload {}: {}", index + 1, payload);
        }
    }
}

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

pub struct ItemCommitment {
    pub item: Item,
    pub public_attribute_group: ItemCommitmentPublicAttributeGroup,
    pub role_confidential_attribute_group: ItemCommitmentRoleConfidentialAttributeGroup,
    pub private_attribute_group: ItemCommitmentPrivateAttributeGroup,
}

impl ItemCommitment {
    pub const ITEM_NAME: &'static str = "commitment";
    pub fn new(
        mut item: Item,
        public_attribute_group: ItemCommitmentPublicAttributeGroup,
        role_confidential_attribute_group: ItemCommitmentRoleConfidentialAttributeGroup,
        private_attribute_group: ItemCommitmentPrivateAttributeGroup,
    ) -> Self {
        item.name = Self::ITEM_NAME.to_string();
        ItemCommitment {
            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!("ItemCommitment:");
        println!("Item:");
        self.item.display_info(); // Affiche les informations de `item`

        println!("Public Attribute Group:");
        self.public_attribute_group.display_info(); // Affiche les informations de `public_attribute_group`

        println!("Role Confidential Attribute Group:");
        self.role_confidential_attribute_group.display_info(); // Affiche les informations de `role_confidential_attribute_group`

        println!("Private Attribute Group:");
        self.private_attribute_group.display_info(); // Affiche les informations de `private_attribute_group`
    }
}