use anchor_lang::{
    prelude::{ProgramError, Pubkey},
    AccountDeserialize, Discriminator,
};
use solana_account_decoder::UiAccountEncoding;
use solana_clap_utils::keypair::DefaultSigner;
use solana_cli_config::{Config, ConfigInput};
use solana_client::{
    client_error::ClientError as SolanaClientError,
    pubsub_client::PubsubClientError,
    rpc_client::RpcClient,
    rpc_config::{RpcAccountInfoConfig, RpcProgramAccountsConfig, RpcSendTransactionConfig},
    rpc_filter::{Memcmp, MemcmpEncodedBytes, RpcFilterType},
};
use solana_program::instruction::Instruction;
use solana_remote_wallet::remote_wallet::RemoteWalletManager;
use solana_sdk::{
    account::Account,
    bs58,
    commitment_config::{CommitmentConfig, CommitmentLevel},
    signer::Signer,
    transaction::Transaction,
};
use std::{io, iter::Map, rc::Rc, sync::Arc, time::Duration, vec::IntoIter};
use thiserror::Error;

pub struct ProgramAccountsIterator<T> {
    inner: Map<IntoIter<(Pubkey, Account)>, AccountConverterFunction<T>>,
}

/// Function type that accepts solana accounts and returns deserialized anchor accounts
type AccountConverterFunction<T> = fn((Pubkey, Account)) -> Result<(Pubkey, T), ClientError>;

impl<T> Iterator for ProgramAccountsIterator<T> {
    type Item = Result<(Pubkey, T), ClientError>;

    fn next(&mut self) -> Option<Self::Item> {
        self.inner.next()
    }
}

#[derive(Debug, Error)]
pub enum ClientError {
    #[error("Account not found")]
    AccountNotFound,
    #[error("{0}")]
    AnchorError(#[from] anchor_lang::error::Error),
    #[error("{0}")]
    ProgramError(#[from] ProgramError),
    #[error("{0}")]
    SolanaClientError(#[from] SolanaClientError),
    #[error("{0}")]
    SolanaClientPubsubError(#[from] PubsubClientError),
    #[error("Unable to parse log: {0}")]
    LogParseError(String),
}

pub struct Client {
    pub config_path: String,
    pub config: Config,
    pub rpc_timeout: Duration,
    pub commitment: CommitmentConfig,
    pub confirm_transaction_initial_timeout: Duration,
    pub payer: Rc<dyn Signer>,
}

impl Client {
    pub fn new(config_path: String) -> Result<Self, io::Error> {
        let mut config = Config::load(config_path.as_str())?;
        let rpc_timeout = Duration::from_secs(30);

        if config.websocket_url.is_empty() {
            config.websocket_url = Config::compute_websocket_url(&config.json_rpc_url);
        }

        let commitment = CommitmentConfig {
            commitment: CommitmentLevel::Processed,
        };
        let confirm_transaction_initial_timeout = Duration::from_secs(30);
        let default_signer_arg_name = "keypair".to_string();
        let (_, default_signer_path) =
            ConfigInput::compute_keypair_path_setting("", &config.keypair_path);
        let default_signer = DefaultSigner::new(default_signer_arg_name, &default_signer_path);
        let mut wallet_manager: Option<Arc<RemoteWalletManager>> = None;
        let payer = default_signer.signer_from_path(&Default::default(), &mut wallet_manager);

        Ok(Client {
            config_path,
            config,
            rpc_timeout,
            commitment,
            confirm_transaction_initial_timeout,
            payer: Rc::from(payer.unwrap()),
        })
    }

    #[allow(dead_code)]
    pub fn rpc_client(&self) -> RpcClient {
        RpcClient::new_with_timeouts_and_commitment(
            self.config.json_rpc_url.to_string(),
            self.rpc_timeout,
            self.commitment,
            self.confirm_transaction_initial_timeout,
        )
    }

    pub fn payer_key(&self) -> Pubkey {
        self.payer.pubkey()
    }

    /// Returns the account at the given address.
    pub fn account<T: AccountDeserialize>(&self, address: Pubkey) -> Result<T, ClientError> {
        let account = self
            .rpc_client()
            .get_account_with_commitment(&address, CommitmentConfig::processed())?
            .value
            .ok_or(ClientError::AccountNotFound)?;
        let mut data: &[u8] = &account.data;
        T::try_deserialize(&mut data).map_err(Into::into)
    }

    /// Returns all program accounts of the given type matching the given filters
    pub fn accounts<T: AccountDeserialize + Discriminator>(
        &self,
        program_id: &Pubkey,
        filters: Vec<RpcFilterType>,
    ) -> Result<Vec<(Pubkey, T)>, ClientError> {
        self.accounts_lazy(program_id, filters)?.collect()
    }

    /// Returns all program accounts of the given type matching the given filters as an iterator
    /// Deserialization is executed lazily
    pub fn accounts_lazy<T: AccountDeserialize + Discriminator>(
        &self,
        program_id: &Pubkey,
        filters: Vec<RpcFilterType>,
    ) -> Result<ProgramAccountsIterator<T>, ClientError> {
        let account_type_filter = RpcFilterType::Memcmp(Memcmp {
            offset: 0,
            bytes: MemcmpEncodedBytes::Base58(bs58::encode(T::discriminator()).into_string()),
            encoding: None,
        });
        let config = RpcProgramAccountsConfig {
            filters: Some([vec![account_type_filter], filters].concat()),
            account_config: RpcAccountInfoConfig {
                encoding: Some(UiAccountEncoding::Base64),
                ..RpcAccountInfoConfig::default()
            },
            ..RpcProgramAccountsConfig::default()
        };
        Ok(ProgramAccountsIterator {
            inner: self
                .rpc_client()
                .get_program_accounts_with_config(program_id, config)?
                .into_iter()
                .map(|(key, account)| {
                    Ok((key, T::try_deserialize(&mut (&account.data as &[u8]))?))
                }),
        })
    }

    pub fn send_and_confirm(&self, ixs: &[Instruction]) {
        let rpc_client = self.rpc_client();
        let recent_blockhash = rpc_client.get_latest_blockhash().unwrap();
        let mut signers = vec![];
        signers.push(&*self.payer);
        let tx = Transaction::new_signed_with_payer(
            ixs,
            Some(&self.payer_key()),
            &signers,
            recent_blockhash,
        );
        let resp = rpc_client.send_and_confirm_transaction_with_spinner_and_config(
            &tx,
            self.commitment,
            RpcSendTransactionConfig {
                skip_preflight: true,
                preflight_commitment: None,
                encoding: None,
                max_retries: Some(3),
                min_context_slot: None,
            },
        );
        if resp.is_err() {
            println!(
                "{}",
                resp.err()
                    .unwrap()
                    .get_transaction_error()
                    .unwrap()
                    .to_string()
            );
        } else {
            println!("{}", resp.unwrap().to_string());
        }
    }
}