use std::{
    collections::hash_map::DefaultHasher,
    hash::{Hash, Hasher},
};

use serde::{Deserialize, Serialize};

use super::{
    item_enum::ItemEnum, key_encryption::KeyEncryption, message_client::MessageClient,
    pagination::Pagination, pcd_item_generic_enc::PcdItemGenericEnc, request::Request,
    shared_peer::Peer, shared_process::Process,
};

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

pub struct Pcd {
    pub request: Request, // Assuming Request is a predefined struct
    pub item_list: Vec<PcdItemGenericEnc>,
    pub pagination: Pagination, // Assuming Pagination is a predefined struct
}

impl Pcd {
    pub const TYPE: &'static str = "pcd";
    pub fn new(
        request_item_name: Option<String>,
        request_version: i64,
        request_process_hash: String,
        request_pcd_reference_hash: Option<String>,
        request_item_reference_hash: Option<String>,
        item_list: Vec<ItemEnum>,
        pagination: Pagination,
        process_public_enc_key: KeyEncryption,
        member_private_enc_key: KeyEncryption,
    ) -> Self {
        let request = Request::new(
            request_item_name,
            Self::TYPE.to_string(),
            request_version,
            request_process_hash,
            request_pcd_reference_hash,
            request_item_reference_hash,
        );

        // TODO: encrypt item_list
        let mut item_enc_list: Vec<PcdItemGenericEnc> = Vec::new();

        item_list.iter().for_each(|item| match item {
            ItemEnum::Process(item_process) => {
                let item_enc = item_process.enc(
                    process_public_enc_key.clone(),
                    member_private_enc_key.clone(),
                );
                item_enc_list.push(item_enc);
            }
            ItemEnum::Member(item_member) => {
                let item_enc = item_member.enc(
                    process_public_enc_key.clone(),
                    member_private_enc_key.clone(),
                );
                item_enc_list.push(item_enc);
            }
            ItemEnum::Artefact(item_artefact) => {
                let item_enc = item_artefact.enc(
                    process_public_enc_key.clone(),
                    member_private_enc_key.clone(),
                );
                item_enc_list.push(item_enc);
            }
            ItemEnum::Peer(item_peer) => {
                let item_enc = item_peer.enc(
                    process_public_enc_key.clone(),
                    member_private_enc_key.clone(),
                );
                item_enc_list.push(item_enc);
            }
            ItemEnum::Payments(item_Payments) => {
                let item_enc = item_Payments.enc(
                    process_public_enc_key.clone(),
                    member_private_enc_key.clone(),
                );
                item_enc_list.push(item_enc);
            }
            ItemEnum::Deposit(item_deposit) => {
                let item_enc = item_deposit.enc(
                    process_public_enc_key.clone(),
                    member_private_enc_key.clone(),
                );
                item_enc_list.push(item_enc);
            }
            ItemEnum::commit(item_commit) => {
                let item_enc = item_commit.enc(
                    process_public_enc_key.clone(),
                    member_private_enc_key.clone(),
                );
                item_enc_list.push(item_enc);
            }
        });

        Pcd {
            request,
            item_list: item_enc_list,
            pagination,
        }
    }
    pub fn display_info(&self) {
        println!("Pcd:");
        println!("Request:");
        self.request.display_info();

        println!("Item List:");
        for item in &self.item_list {
            item.display_info();
        }

        println!("Pagination:");
        self.pagination.display_info();
    }

    pub fn to_message(
        &self,
        process_public_enc_key: KeyEncryption,
        message_shared_peer_list: Vec<Peer>,
        message_shared_process_list: Vec<Process>,
        message_faucet_sp_address: String,
        pow_pathern: String,
        pow_difficulty: usize,
    ) -> MessageClient {
        let mut hasher: DefaultHasher = DefaultHasher::new();
        self.hash(&mut hasher);
        let request_hash = hasher.finish().to_string();
        let request_enc: String = process_public_enc_key.enc_pcd(self.clone()).to_string();

        MessageClient::new(
            request_enc,
            request_hash,
            message_shared_peer_list,
            message_shared_process_list,
            message_faucet_sp_address,
            pow_pathern,
            pow_difficulty,
        )
    }
}