use crate::{
    checks::{check_account_for_fee, check_unique_pubkeys},
    cli::{
        generate_unique_signers, log_instruction_custom_error, CliCommand, CliCommandInfo,
        CliConfig, CliError, ProcessResult, SignerIndex,
    },
};
use clap::{App, Arg, ArgMatches, SubCommand};
use solana_clap_utils::{input_parsers::*, input_validators::*, keypair::signer_from_path};
use solana_client::rpc_client::RpcClient;
use solana_remote_wallet::remote_wallet::RemoteWalletManager;
use solana_sdk::{
    account_utils::StateMut, message::Message, pubkey::Pubkey, system_instruction::SystemError,
    transaction::Transaction,
};
use solana_storage_program::storage_instruction::{self, StorageAccountType};
use std::sync::Arc;

pub trait StorageSubCommands {
    fn storage_subcommands(self) -> Self;
}

impl StorageSubCommands for App<'_, '_> {
    fn storage_subcommands(self) -> Self {
        self.subcommand(
            SubCommand::with_name("create-archiver-storage-account")
                .about("Create an archiver storage account")
                .arg(
                    Arg::with_name("storage_account_owner")
                        .index(1)
                        .value_name("AUTHORITY_PUBKEY")
                        .takes_value(true)
                        .required(true)
                        .validator(is_valid_pubkey),
                )
                .arg(
                    Arg::with_name("storage_account")
                        .index(2)
                        .value_name("ACCOUNT_KEYPAIR")
                        .takes_value(true)
                        .required(true)
                        .validator(is_valid_signer),
                ),
        )
        .subcommand(
            SubCommand::with_name("create-validator-storage-account")
                .about("Create a validator storage account")
                .arg(
                    Arg::with_name("storage_account_owner")
                        .index(1)
                        .value_name("AUTHORITY_PUBKEY")
                        .takes_value(true)
                        .required(true)
                        .validator(is_valid_pubkey),
                )
                .arg(
                    Arg::with_name("storage_account")
                        .index(2)
                        .value_name("ACCOUNT_KEYPAIR")
                        .takes_value(true)
                        .required(true)
                        .validator(is_valid_signer),
                ),
        )
        .subcommand(
            SubCommand::with_name("claim-storage-reward")
                .about("Redeem storage reward credits")
                .arg(
                    Arg::with_name("node_account_pubkey")
                        .index(1)
                        .value_name("NODE_ACCOUNT_ADDRESS")
                        .takes_value(true)
                        .required(true)
                        .validator(is_valid_pubkey)
                        .help("The node account to credit the rewards to"),
                )
                .arg(
                    Arg::with_name("storage_account_pubkey")
                        .index(2)
                        .value_name("STORAGE_ACCOUNT_ADDRESS")
                        .takes_value(true)
                        .required(true)
                        .validator(is_valid_pubkey)
                        .help("Storage account address to redeem credits for"),
                ),
        )
        .subcommand(
            SubCommand::with_name("storage-account")
                .about("Show the contents of a storage account")
                .alias("show-storage-account")
                .arg(
                    Arg::with_name("storage_account_pubkey")
                        .index(1)
                        .value_name("STORAGE_ACCOUNT_ADDRESS")
                        .takes_value(true)
                        .required(true)
                        .validator(is_valid_pubkey)
                        .help("Storage account address"),
                ),
        )
    }
}

pub fn parse_storage_create_archiver_account(
    matches: &ArgMatches<'_>,
    default_signer_path: &str,
    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> {
    let account_owner =
        pubkey_of_signer(matches, "storage_account_owner", wallet_manager)?.unwrap();
    let (storage_account, storage_account_pubkey) =
        signer_of(matches, "storage_account", wallet_manager)?;

    let payer_provided = None;
    let signer_info = generate_unique_signers(
        vec![payer_provided, storage_account],
        matches,
        default_signer_path,
        wallet_manager,
    )?;

    Ok(CliCommandInfo {
        command: CliCommand::CreateStorageAccount {
            account_owner,
            storage_account: signer_info.index_of(storage_account_pubkey).unwrap(),
            account_type: StorageAccountType::Archiver,
        },
        signers: signer_info.signers,
    })
}

pub fn parse_storage_create_validator_account(
    matches: &ArgMatches<'_>,
    default_signer_path: &str,
    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> {
    let account_owner =
        pubkey_of_signer(matches, "storage_account_owner", wallet_manager)?.unwrap();
    let (storage_account, storage_account_pubkey) =
        signer_of(matches, "storage_account", wallet_manager)?;

    let payer_provided = None;
    let signer_info = generate_unique_signers(
        vec![payer_provided, storage_account],
        matches,
        default_signer_path,
        wallet_manager,
    )?;

    Ok(CliCommandInfo {
        command: CliCommand::CreateStorageAccount {
            account_owner,
            storage_account: signer_info.index_of(storage_account_pubkey).unwrap(),
            account_type: StorageAccountType::Validator,
        },
        signers: signer_info.signers,
    })
}

pub fn parse_storage_claim_reward(
    matches: &ArgMatches<'_>,
    default_signer_path: &str,
    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> {
    let node_account_pubkey =
        pubkey_of_signer(matches, "node_account_pubkey", wallet_manager)?.unwrap();
    let storage_account_pubkey =
        pubkey_of_signer(matches, "storage_account_pubkey", wallet_manager)?.unwrap();
    Ok(CliCommandInfo {
        command: CliCommand::ClaimStorageReward {
            node_account_pubkey,
            storage_account_pubkey,
        },
        signers: vec![signer_from_path(
            matches,
            default_signer_path,
            "keypair",
            wallet_manager,
        )?],
    })
}

pub fn parse_storage_get_account_command(
    matches: &ArgMatches<'_>,
    wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> {
    let storage_account_pubkey =
        pubkey_of_signer(matches, "storage_account_pubkey", wallet_manager)?.unwrap();
    Ok(CliCommandInfo {
        command: CliCommand::ShowStorageAccount(storage_account_pubkey),
        signers: vec![],
    })
}

pub fn process_create_storage_account(
    rpc_client: &RpcClient,
    config: &CliConfig,
    storage_account: SignerIndex,
    account_owner: &Pubkey,
    account_type: StorageAccountType,
) -> ProcessResult {
    let storage_account = config.signers[storage_account];
    let storage_account_pubkey = storage_account.pubkey();
    check_unique_pubkeys(
        (&config.signers[0].pubkey(), "cli keypair".to_string()),
        (
            &storage_account_pubkey,
            "storage_account_pubkey".to_string(),
        ),
    )?;

    if let Ok(storage_account) = rpc_client.get_account(&storage_account_pubkey) {
        let err_msg = if storage_account.owner == solana_storage_program::id() {
            format!("Storage account {} already exists", storage_account_pubkey)
        } else {
            format!(
                "Account {} already exists and is not a storage account",
                storage_account_pubkey
            )
        };
        return Err(CliError::BadParameter(err_msg).into());
    }

    use solana_storage_program::storage_contract::STORAGE_ACCOUNT_SPACE;
    let required_balance = rpc_client
        .get_minimum_balance_for_rent_exemption(STORAGE_ACCOUNT_SPACE as usize)?
        .max(1);

    let ixs = storage_instruction::create_storage_account(
        &config.signers[0].pubkey(),
        &account_owner,
        &storage_account_pubkey,
        required_balance,
        account_type,
    );
    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;

    let message = Message::new(&ixs);
    let mut tx = Transaction::new_unsigned(message);
    tx.try_sign(&config.signers, recent_blockhash)?;
    check_account_for_fee(
        rpc_client,
        &config.signers[0].pubkey(),
        &fee_calculator,
        &tx.message,
    )?;
    let result = rpc_client.send_and_confirm_transaction_with_spinner(&tx);
    log_instruction_custom_error::<SystemError>(result, &config)
}

pub fn process_claim_storage_reward(
    rpc_client: &RpcClient,
    config: &CliConfig,
    node_account_pubkey: &Pubkey,
    storage_account_pubkey: &Pubkey,
) -> ProcessResult {
    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;

    let instruction =
        storage_instruction::claim_reward(node_account_pubkey, storage_account_pubkey);
    let signers = [config.signers[0]];
    let message = Message::new_with_payer(&[instruction], Some(&signers[0].pubkey()));
    let mut tx = Transaction::new_unsigned(message);
    tx.try_sign(&signers, recent_blockhash)?;
    check_account_for_fee(
        rpc_client,
        &config.signers[0].pubkey(),
        &fee_calculator,
        &tx.message,
    )?;
    let signature = rpc_client.send_and_confirm_transaction_with_spinner(&tx)?;
    Ok(signature.to_string())
}

pub fn process_show_storage_account(
    rpc_client: &RpcClient,
    _config: &CliConfig,
    storage_account_pubkey: &Pubkey,
) -> ProcessResult {
    let account = rpc_client.get_account(storage_account_pubkey)?;

    if account.owner != solana_storage_program::id() {
        return Err(CliError::RpcRequestError(format!(
            "{:?} is not a storage account",
            storage_account_pubkey
        ))
        .into());
    }

    use solana_storage_program::storage_contract::StorageContract;
    let storage_contract: StorageContract = account.state().map_err(|err| {
        CliError::RpcRequestError(format!("Unable to deserialize storage account: {}", err))
    })?;
    println!("{:#?}", storage_contract);
    println!("Account Lamports: {}", account.lamports);
    Ok("".to_string())
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::cli::{app, parse_command};
    use solana_sdk::signature::{read_keypair_file, write_keypair, Keypair, Signer};
    use tempfile::NamedTempFile;

    fn make_tmp_file() -> (String, NamedTempFile) {
        let tmp_file = NamedTempFile::new().unwrap();
        (String::from(tmp_file.path().to_str().unwrap()), tmp_file)
    }

    #[test]
    fn test_parse_command() {
        let test_commands = app("test", "desc", "version");
        let pubkey = Pubkey::new_rand();
        let pubkey_string = pubkey.to_string();

        let default_keypair = Keypair::new();
        let (default_keypair_file, mut tmp_file) = make_tmp_file();
        write_keypair(&default_keypair, tmp_file.as_file_mut()).unwrap();

        let (keypair_file, mut tmp_file) = make_tmp_file();
        let storage_account_keypair = Keypair::new();
        write_keypair(&storage_account_keypair, tmp_file.as_file_mut()).unwrap();

        let test_create_archiver_storage_account = test_commands.clone().get_matches_from(vec![
            "test",
            "create-archiver-storage-account",
            &pubkey_string,
            &keypair_file,
        ]);
        assert_eq!(
            parse_command(
                &test_create_archiver_storage_account,
                &default_keypair_file,
                &mut None
            )
            .unwrap(),
            CliCommandInfo {
                command: CliCommand::CreateStorageAccount {
                    account_owner: pubkey,
                    storage_account: 1,
                    account_type: StorageAccountType::Archiver,
                },
                signers: vec![
                    read_keypair_file(&default_keypair_file).unwrap().into(),
                    storage_account_keypair.into()
                ],
            }
        );

        let (keypair_file, mut tmp_file) = make_tmp_file();
        let storage_account_keypair = Keypair::new();
        write_keypair(&storage_account_keypair, tmp_file.as_file_mut()).unwrap();
        let storage_account_pubkey = storage_account_keypair.pubkey();
        let storage_account_string = storage_account_pubkey.to_string();

        let test_create_validator_storage_account = test_commands.clone().get_matches_from(vec![
            "test",
            "create-validator-storage-account",
            &pubkey_string,
            &keypair_file,
        ]);
        assert_eq!(
            parse_command(
                &test_create_validator_storage_account,
                &default_keypair_file,
                &mut None
            )
            .unwrap(),
            CliCommandInfo {
                command: CliCommand::CreateStorageAccount {
                    account_owner: pubkey,
                    storage_account: 1,
                    account_type: StorageAccountType::Validator,
                },
                signers: vec![
                    read_keypair_file(&default_keypair_file).unwrap().into(),
                    storage_account_keypair.into()
                ],
            }
        );

        let test_claim_storage_reward = test_commands.clone().get_matches_from(vec![
            "test",
            "claim-storage-reward",
            &pubkey_string,
            &storage_account_string,
        ]);
        assert_eq!(
            parse_command(&test_claim_storage_reward, &default_keypair_file, &mut None).unwrap(),
            CliCommandInfo {
                command: CliCommand::ClaimStorageReward {
                    node_account_pubkey: pubkey,
                    storage_account_pubkey,
                },
                signers: vec![read_keypair_file(&default_keypair_file).unwrap().into()],
            }
        );
    }
}