use serde::{Deserialize, Serialize};
use tsify::Tsify;
use wasm_bindgen::prelude::*;

use sp_client::{
    bitcoin::{consensus::serialize, OutPoint}, silentpayments::utils::SilentPaymentAddress, spclient::SpWallet
};

use crate::pcd::Member;

#[derive(Debug, Serialize, Deserialize, Clone, Default, Tsify)]
#[tsify(into_wasm_abi, from_wasm_abi)]
pub struct Device {
    sp_wallet: SpWallet,
    pairing_process_commitment: Option<OutPoint>,
    paired_member: Member,
}

impl Device {
    pub fn new(sp_wallet: SpWallet) -> Self {
        let local_address = sp_wallet.get_client().get_receiving_address();
        let member = Member::new(vec![SilentPaymentAddress::try_from(local_address).unwrap()]).unwrap();
        Self {
            sp_wallet,
            pairing_process_commitment: None,
            paired_member: member,
        }
    }

    pub fn get_wallet(&self) -> &SpWallet {
        &self.sp_wallet
    }

    pub fn get_mut_wallet(&mut self) -> &mut SpWallet {
        &mut self.sp_wallet
    }

    pub fn is_linking(&self) -> bool {
        match self.pairing_process_commitment {
            Some(ref value) => serialize(value).iter().all(|&b| b == 0),
            None => false,
        }
    }

    pub fn is_linked(&self) -> bool {
        match self.pairing_process_commitment {
            Some(ref value) => !serialize(value).iter().all(|&b| b == 0),
            None => false,
        }
    }

    pub fn get_pairing_commitment(&self) -> Option<OutPoint> {
        self.pairing_process_commitment.clone()
    }

    pub fn pair(&mut self, commitment_outpoint: OutPoint, member: Member) {
        self.pairing_process_commitment = Some(commitment_outpoint);
        self.paired_member = member;
    }

    pub fn unpair(&mut self) {
        let local_address = self.get_wallet().get_client().get_receiving_address();
        let member = Member::new(vec![SilentPaymentAddress::try_from(local_address).unwrap()]).unwrap();
        self.paired_member = member;
        self.pairing_process_commitment = None;
    }

    pub fn to_member(&self) -> Member {
        self.paired_member.clone()
    }

    pub fn get_other_addresses(&self) -> Vec<String> {
        let our_address = self.get_wallet().get_client().get_receiving_address();
        self.to_member()
            .get_addresses()
            .into_iter()
            .filter(|a| *a != our_address)
            .collect()
    }
}