use notareum::{Notareum, ClientConfig, ContractAddresses, SdkError};

impl Notareum {
    pub fn new(config: ClientConfig) -> Result<Notareum, SdkError>;
}

pub struct ClientConfig {
    pub provider: std::sync::Arc<ethers::providers::Provider<ethers::providers::Http>>,
    pub signer:   Option<ethers::signers::LocalWallet>,
    pub contracts: ContractAddresses,
}

pub struct ContractAddresses {
    pub access_manager:      String,
    pub nota_token:          String,
    pub ve_nota:             String,
    pub validator_staking:   String,
    pub nota_registry:       String,
    pub verification_engine: String,
    pub slashing_manager:    String,
    pub fee_manager:         String,
}

impl NotaFileClient {
    pub fn create(&self, options: CreateNotaOptions) -> Result<NotaBuilder, SdkError>;
    pub fn parse(&self, content: &str) -> Result<NotaFile, SdkError>;
    pub fn validate(&self, nota: &NotaFile) -> Result<(), SdkError>;
    pub fn is_valid(&self, nota: &NotaFile) -> bool;
    pub fn serialize(&self, nota: &NotaFile) -> Result<String, SdkError>;
}

impl NotaBuilder {
    pub fn sign(self, private_key_hex: &str) -> Result<Self, SdkError>;
    pub fn validate(self) -> Result<Self, SdkError>;
    pub fn serialize(&self) -> Result<String, SdkError>;
    pub fn build(self) -> NotaFile;
}

pub struct CreateNotaOptions {
    pub type_: String,            // `type` is reserved in Rust; field is `type_`
    pub chain_name: String,
    pub chain_id: u64,
    pub network: Option<String>,
    pub identifier: String,
    pub name: Option<String>,
    pub alias: Option<String>,
    pub description: Option<String>,
    pub resource_metadata: Option<serde_json::Value>,
    pub issuer_name: Option<String>,
    pub issuer_entity_type: Option<String>,
}

impl CreateNotaOptions {
    pub fn new(
        type_: impl Into<String>,
        chain_name: impl Into<String>,
        chain_id: u64,
        identifier: impl Into<String>,
    ) -> Self;
}

impl RegistryClient {
    pub async fn register_resource(
        &self,
        resource_type: u8,
        chain_id: u64,
        identifier: &str,
        proof_hash: &str,
        alias: Option<&str>,
    ) -> Result<String, SdkError>;

    pub async fn get_resource(&self, resource_id: &str) -> Result<ResourceInfo, SdkError>;
    pub async fn resolve_alias(&self, alias: &str) -> Result<String, SdkError>;
    pub async fn revoke_resource(&self, resource_id: &str) -> Result<String, SdkError>;

    pub fn compute_resource_id(
        &self,
        resource_type: u8,
        chain_id: u64,
        identifier: &str,
    ) -> Result<String, SdkError>;

    pub async fn add_resource_type(&self, type_id: u8, name: &str) -> Result<String, SdkError>;
    pub async fn remove_resource_type(&self, type_id: u8) -> Result<String, SdkError>;
    pub async fn is_valid_resource_type(&self, type_id: u8) -> Result<bool, SdkError>;
    pub async fn get_resource_type_name(&self, type_id: u8) -> Result<String, SdkError>;
}

impl VerificationClient {
    pub async fn request_verification(
        &self,
        resource_id: &str,
        level: VerificationLevel,
    ) -> Result<String, SdkError>;

    pub async fn submit_attestation(
        &self,
        resource_id: &str,
        approved: bool,
    ) -> Result<String, SdkError>;

    pub async fn get_verification_request(
        &self,
        request_id: ethers::types::U256,
    ) -> Result<VerificationRequestInfo, SdkError>;

    pub async fn get_verification_fee(
        &self,
        level: VerificationLevel,
    ) -> Result<ethers::types::U256, SdkError>;
}

impl StakingClient {
    pub async fn stake(&self, amount: ethers::types::U256) -> Result<String, SdkError>;
    pub async fn unstake(&self) -> Result<String, SdkError>;
    pub async fn claim_stake(&self) -> Result<String, SdkError>;

    pub async fn get_validator_info(&self, address: &str) -> Result<ValidatorInfo, SdkError>;
    pub async fn get_tier(&self, address: &str) -> Result<ValidatorTier, SdkError>;
    pub async fn get_daily_verifications_remaining(&self, address: &str) -> Result<ethers::types::U256, SdkError>;
}

impl GovernanceClient {
    pub async fn lock(&self, amount: U256, duration: U256) -> Result<String, SdkError>;
    pub async fn extend_lock(
        &self,
        lock_id: U256,
        additional_duration: U256,
    ) -> Result<String, SdkError>;
    pub async fn unlock(&self, lock_id: U256) -> Result<String, SdkError>;

    pub async fn get_voting_power(&self, address: &str) -> Result<U256, SdkError>;
    pub async fn get_lock(&self, lock_id: U256) -> Result<VeNotaLock, SdkError>;
    pub async fn get_total_supply(&self) -> Result<U256, SdkError>;
}

impl FeeClient {
    pub async fn get_verification_fee(&self, level: VerificationLevel) -> Result<U256, SdkError>;
    pub async fn get_alias_fee(&self) -> Result<U256, SdkError>;
    pub async fn get_dispute_bond(&self) -> Result<U256, SdkError>;
    pub async fn get_fee_collector(&self) -> Result<String, SdkError>;
    pub async fn get_fee_config(&self) -> Result<FeeConfig, SdkError>;

    // Governance only
    pub async fn set_verification_fee(
        &self,
        level: VerificationLevel,
        fee: U256,
    ) -> Result<String, SdkError>;
    pub async fn set_alias_fee(&self, fee: U256) -> Result<String, SdkError>;
}

pub enum VerificationLevel { Basic, Enhanced, Institutional }
pub enum VerificationStatus { Pending, Approved, Rejected, Expired }
pub enum ValidatorTier { None, Bronze, Silver, Gold, Platinum }