use crate::{gdev, indexer::*, Args, Client};

use anyhow::{anyhow, Result};
use sp_core::{crypto::AccountId32, sr25519::Pair};
use std::str::FromStr;
use subxt::tx::{BaseExtrinsicParamsBuilder, PairSigner};

pub async fn get_identity(
	client: Client,
	mut account_id: Option<AccountId32>,
	mut identity_id: Option<u32>,
	mut username: Option<String>,
	args: &Args,
) -> Result<()> {
	let parent_hash = client
		.storage()
		.fetch(&gdev::storage().system().parent_hash(), None)
		.await?
		.unwrap();

	let gql_client = reqwest::Client::builder()
		.user_agent("gcli/0.1.0")
		.build()?;

	let indexer = if args.no_indexer {
		None
	} else {
		Some(Indexer {
			gql_client,
			gql_url: &args.indexer,
		})
	};

	if let Some(account_id) = &account_id {
		identity_id = client
			.storage()
			.fetch(
				&gdev::storage().identity().identity_index_of(account_id),
				Some(parent_hash),
			)
			.await?;
	} else if let Some(identity_id) = &identity_id {
		account_id = client
			.storage()
			.fetch(
				&gdev::storage().identity().identities(identity_id),
				Some(parent_hash),
			)
			.await?
			.map(|idty| idty.owner_key);
	} else if let Some(username) = &username {
		let indexer = indexer.as_ref().ok_or(anyhow!(
			"Cannot fetch identity from username without indexer."
		))?;
		if let Some(pubkey) = indexer.pubkey_by_username(username).await? {
			let some_account_id = AccountId32::from_str(&pubkey).map_err(|e| anyhow!(e))?;
			identity_id = client
				.storage()
				.fetch(
					&gdev::storage()
						.identity()
						.identity_index_of(&some_account_id),
					Some(parent_hash),
				)
				.await?;
			account_id = Some(some_account_id);
		}
	} else {
		return Err(anyhow!("One argument is needed to fetch the identity."));
	}

	println!(
		"Account id:  {}",
		account_id
			.as_ref()
			.map_or(String::new(), AccountId32::to_string)
	);
	println!(
		"Identity id: {}",
		identity_id.map_or(String::new(), |identity_id| format!("{identity_id}"))
	);

	if let (Some(indexer), Some(account_id), None) = (&indexer, &account_id, &username) {
		username = indexer.username_by_pubkey(&account_id.to_string()).await?;
	}

	println!("Username:    {}", username.unwrap_or_default());

	Ok(())
}

pub async fn create_identity(pair: Pair, client: Client, target: AccountId32) -> Result<()> {
	client
		.tx()
		.sign_and_submit_then_watch(
			&gdev::tx().identity().create_identity(target),
			&PairSigner::new(pair),
			BaseExtrinsicParamsBuilder::new(),
		)
		.await?;

	Ok(())
}

pub async fn confirm_identity(pair: Pair, client: Client, name: String) -> Result<()> {
	client
		.tx()
		.sign_and_submit_then_watch(
			&gdev::tx().identity().confirm_identity(name),
			&PairSigner::new(pair),
			BaseExtrinsicParamsBuilder::new(),
		)
		.await?;

	Ok(())
}