use crate::*;

use sp_core::{crypto::AccountId32, sr25519::Pair, Pair as _};
use std::ops::Deref;
use subxt::tx::{BaseExtrinsicParamsBuilder, PairSigner};

type SessionKeys = [u8; 128];

/// rotate session keys
pub async fn rotate_keys(client: &Client) -> Result<SessionKeys, anyhow::Error> {
	client
		.rpc()
		.rotate_keys()
		.await?
		.deref()
		.try_into()
		.map_err(|e| anyhow!("Session keys have wrong length: {:?}", e))
}

/// set session keys
pub async fn set_session_keys(
	pair: Pair,
	client: &Client,
	session_keys: SessionKeys,
) -> Result<TxProgress, subxt::Error> {
	client
		.tx()
		.sign_and_submit_then_watch(
			&runtime::tx()
				.authority_members()
				.set_session_keys(session_keys),
			&PairSigner::new(pair),
			BaseExtrinsicParamsBuilder::new(),
		)
		.await
}

/// update session keys
pub async fn update_session_keys(pair: Pair, client: &Client) -> Result<(), GcliError> {
	let session_keys = rotate_keys(client).await?;
	let progress = set_session_keys(pair, client, session_keys).await?;

	let _ = track_progress(progress).await?; // TODO
	Ok(())
}

/// submit go_online
pub async fn go_online(pair: Pair, client: &Client) -> Result<(), GcliError> {
	if client
		.storage()
		.fetch(
			&runtime::storage()
				.session()
				.next_keys(AccountId32::from(pair.public())),
			None,
		)
		.await?
		.is_none()
	{
		return Err(GcliError::Logic(
			"This account has not set session keys!".to_string(),
		));
	}

	let progress = client
		.tx()
		.sign_and_submit_then_watch(
			&runtime::tx().authority_members().go_online(),
			&PairSigner::new(pair),
			BaseExtrinsicParamsBuilder::new(),
		)
		.await?;

	let events = track_progress(progress).await?;
	if let Some(e) = events.find_first::<runtime::authority_members::events::MemberGoOnline>()? {
		println!("{e:?}");
	}
	Ok(())
}

/// submit go_offline
pub async fn go_offline(pair: Pair, client: &Client) -> Result<(), subxt::Error> {
	let progress = client
		.tx()
		.sign_and_submit_then_watch(
			&runtime::tx().authority_members().go_offline(),
			&PairSigner::new(pair),
			BaseExtrinsicParamsBuilder::new(),
		)
		.await?;
	let events = track_progress(progress).await?;
	if let Some(e) = events.find_first::<runtime::authority_members::events::MemberGoOffline>()? {
		println!("{e:?}");
	}

	Ok(())
}

/// get online authorities
pub async fn online(data: &Data) -> Result<(), anyhow::Error> {
	let client = data.client();
	let indexer = data.indexer.clone();

	let parent_hash = client
		.clone()
		.storage()
		.fetch(&runtime::storage().system().parent_hash(), None)
		.await?
		.unwrap();

	let mut identity_cache = cache::IdentityCache::new(client.clone(), indexer);

	let online_authorities = client
		.storage()
		.fetch(
			&runtime::storage().authority_members().online_authorities(),
			Some(parent_hash),
		)
		.await?
		.unwrap_or_default();

	println!("Online:");
	for identity_id in online_authorities {
		println!(
			"  {}",
			identity_cache
				.fetch_identity(identity_id, parent_hash)
				.await
				.unwrap_or_else(|_| format!("{identity_id}"))
		);
	}

	let incoming_authorities = client
		.storage()
		.fetch(
			&runtime::storage()
				.authority_members()
				.incoming_authorities(),
			Some(parent_hash),
		)
		.await?
		.unwrap_or_default();

	println!("Incoming:");
	for identity_id in incoming_authorities {
		println!(
			"  {}",
			identity_cache
				.fetch_identity(identity_id, parent_hash)
				.await
				.unwrap_or_else(|_| format!("{identity_id}"))
		);
	}

	let outgoing_authorities = client
		.storage()
		.fetch(
			&runtime::storage()
				.authority_members()
				.outgoing_authorities(),
			Some(parent_hash),
		)
		.await?
		.unwrap_or_default();

	println!("Outgoing:");
	for identity_id in outgoing_authorities {
		println!(
			"  {}",
			identity_cache
				.fetch_identity(identity_id, parent_hash)
				.await
				.unwrap_or_else(|_| format!("{identity_id}"))
		);
	}

	Ok(())
}

/// submit a certification and track progress
pub async fn cert(
	client: &Client,
	pair: Pair,
	issuer: u32,
	receiver: u32,
) -> Result<(), anyhow::Error> {
	let progress = client
		.tx()
		.sign_and_submit_then_watch(
			&runtime::tx().smith_cert().add_cert(issuer, receiver),
			&PairSigner::new(pair),
			BaseExtrinsicParamsBuilder::new(),
		)
		.await?;

	let events = track_progress(progress).await?;

	// look for the expected event
	let new_cert_event = events.find_first::<runtime::smith_cert::events::NewCert>()?;
	let renew_cert_event = events.find_first::<runtime::smith_cert::events::RenewedCert>()?;

	if let Some(event) = new_cert_event {
		println!("{event:?}");
	}
	if let Some(event) = renew_cert_event {
		println!("{event:?}");
	}

	Ok(())
}