pub use confy::ConfyError;
use serde::{Deserialize, Serialize};
use std::{collections::HashMap, path::PathBuf};
pub use tatami::{random_key, Keypair, PeerId};
#[cfg(feature = "integration")]
use tatami::{Module, Satellite, Shoji};
#[cfg(feature = "integration")]
use tatami::{PeerMessage, TatamiEvent};

#[cfg(feature = "integration")]
use tokio::runtime::Handle;

pub const APP_NAME: &str = "peerbook";

#[cfg(feature = "integration")]
#[derive(Debug, Serialize, Deserialize)]
enum PeerbookMessage {
	/// A satellite advertising their own nickname
	NicknameAdvert(String),
	/// A satellite requesting nicknames. None = everyone, Some(peer_id)
	NicknameRequest(Option<Vec<u8>>),
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Peerbook {
	pub nickname: Option<String>,
	pub keypair: Vec<u8>,
	pub peers: HashMap<Vec<u8>, PeerInfo>,
}

impl Default for Peerbook {
	fn default() -> Self {
		Self {
			nickname: Default::default(),
			keypair: random_key()
				.to_protobuf_encoding()
				.expect("Keypair should be encodable"),
			peers: Default::default(),
		}
	}
}

#[derive(Debug, Serialize, Deserialize, Default, Clone)]
pub struct PeerInfo {
	pub nickname: Option<String>,
	pub notes: Option<String>,
	pub color: Option<Color>,
}

#[derive(Debug, Serialize, Deserialize, Default, Clone, Copy)]
pub enum Color {
	#[default]
	Red,
	Yellow,
	Green,
	Blue,
	Purple,
	Cyan,
}

impl Peerbook {
	pub fn get() -> Peerbook {
		confy::load::<Peerbook>(APP_NAME, None).unwrap_or_default()
	}

	pub fn save(&self) -> Result<(), ConfyError> {
		confy::store(APP_NAME, None, self)
	}

	pub fn path() -> Result<PathBuf, ConfyError> {
		confy::get_configuration_file_path(APP_NAME, None)
	}

	pub fn update_nickname(&mut self, nickname: impl ToString) -> Result<(), ConfyError> {
		self.nickname = Some(nickname.to_string());
		self.save()
	}

	pub fn update_keypair(&mut self, keypair: Keypair) -> Result<(), ConfyError> {
		self.keypair = keypair
			.to_protobuf_encoding()
			.expect("Keypair should be encodable");
		self.save()
	}

	pub fn nickname(&self) -> Option<String> {
		self.nickname.clone()
	}

	#[cfg(feature = "integration")]
	pub async fn request_nicknames(&self, shoji: Shoji) {
		let message = PeerbookMessage::NicknameRequest(None);
		shoji
			.publish(serde_json::to_vec(&message).expect("Should serialize"))
			.await
			.expect("Should be able to send message");
	}

	#[cfg(feature = "integration")]
	pub async fn request_nickname(&self, shoji: Shoji, peer_id: PeerId) {
		let message = PeerbookMessage::NicknameRequest(Some(peer_id.to_bytes()));
		shoji
			.publish(serde_json::to_vec(&message).expect("Should serialize"))
			.await
			.expect("Should be able to send message");
	}

	pub fn keypair(&self) -> Keypair {
		Keypair::from_protobuf_encoding(&self.keypair).unwrap_or_else(|_| random_key())
	}

	pub fn update_peer_info(&mut self, peer_id: PeerId, info: PeerInfo) -> Result<(), ConfyError> {
		self.peers.insert(peer_id.to_bytes(), info);
		self.save()
	}

	pub fn peers(&self) -> &HashMap<Vec<u8>, PeerInfo> {
		&self.peers
	}

	pub fn get_peer_info(&self, peer_id: PeerId) -> Option<PeerInfo> {
		self.peers
			.get(&peer_id.to_bytes())
			.map(|peer_info| peer_info.to_owned())
	}
}

#[cfg(feature = "integration")]
impl Module for Peerbook {
	fn on_events(&mut self, event: TatamiEvent, satellite: &Satellite) {
		let local_peer_id = satellite.local_peer_id();
		let local_peer_id_bytes = local_peer_id.to_bytes();
		let shoji = satellite.create_shoji();

		if let TatamiEvent::MessageReceived(PeerMessage { payload, peer }) = event {
			let msg: Option<PeerbookMessage> = serde_json::from_slice(&payload).ok();
			if let Some(event) = msg {
				match event {
					PeerbookMessage::NicknameAdvert(nickname) => {
						let info = self.get_peer_info(peer);
						if let Some(info) = info {
							if info.nickname.is_none() {
								let info = PeerInfo {
									nickname: Some(nickname),
									notes: info.notes.clone(),
									color: info.color,
								};
								self.update_peer_info(peer, info)
									.expect("Should update info of peer");
							}
						} else {
							let info = PeerInfo {
								nickname: Some(nickname),
								..Default::default()
							};
							self.update_peer_info(peer, info)
								.expect("Should update info of peer");
						}
					}
					PeerbookMessage::NicknameRequest(request) => {
						let nickname = self.nickname();
						if let Some(nickname) = nickname {
							if let Some(peer_id) = request {
								if peer_id == local_peer_id_bytes {
									let message = PeerbookMessage::NicknameAdvert(nickname);
									Handle::current()
										.block_on(shoji.publish(
											serde_json::to_vec(&message).expect("Should serialize"),
										))
										.expect("Should be able to send message");
								}
							} else {
								let message = PeerbookMessage::NicknameAdvert(nickname);
								Handle::current()
									.block_on(shoji.publish(
										serde_json::to_vec(&message).expect("Should serialize"),
									))
									.expect("Should be able to send message");
							}
						}
					}
				}
			}
		}
	}
}