use serde::Deserialize;

use crate::database::{BoardRow, Database, Error};

#[derive(Debug, Deserialize)]
pub struct Emboard {
	guildName: String,
	leaderboard: Vec<EmboardRow>,
}

#[derive(Debug, Deserialize)]
pub struct EmboardRow {
	guildId: String,
	discordId: String,
	points: String,
	username: String,
}

pub fn import(db: &Database, json: String) {
	let embaord: Emboard = match serde_json::from_str(&json) {
		Ok(e) => e,
		Err(e) => {
			panic!("{e}");
		}
	};

	let Some(first) = embaord.leaderboard.first() else {
		return;
	};

	let guild_id = u64::from_str_radix(&first.guildId, 10).unwrap();
	if db.get_leaderboard(guild_id).is_err() {
		db.create_leaderboard(guild_id).unwrap();
	}

	for user in embaord.leaderboard {
		let user_id = u64::from_str_radix(&user.discordId, 10).unwrap();
		let points = i64::from_str_radix(&user.points, 10).unwrap();

		let res = db.give_user_points(guild_id, user_id, points);
		if let Err(Error::UserNotExist) = res {
			db.add_user_to_leaderboard(
				guild_id,
				BoardRow {
					user_id,
					user_handle: user.username,
					user_nickname: None,
					points,
				},
			)
			.unwrap();
		}
	}
}

#[cfg(feature = "emboard-direct")]
pub mod emboard_direct {
	use std::{sync::Arc, time::Duration};

	use twilight_model::{
		gateway::payload::incoming::InteractionCreate,
		http::interaction::{InteractionResponse, InteractionResponseType},
		id::{Id, marker::GuildMarker},
	};
	use twilight_util::builder::InteractionResponseDataBuilder;
	use ureq::{Agent, RequestBuilder, config::Config, typestate::WithoutBody};

	use crate::brain::Brain;

	const DATA_URL: &str =
		"https://emboard.evolvedmesh.com/api/backend/dashboard/emboard_guild/leaderboard";

	pub async fn import(brain: Arc<Brain>, guild_id: Id<GuildMarker>, create: &InteractionCreate) {
		let member = create.member.clone().unwrap();
		let permissions = member.permissions.unwrap();
		if !permissions.contains(twilight_model::guild::Permissions::MANAGE_GUILD) {
			brain
				.interaction_respond(
					create,
					InteractionResponseDataBuilder::new()
						.content(
							"❌ You must have the Manage Server permission to perform this action",
						)
						.build(),
				)
				.await;

			return;
		}

		let url = format!("{DATA_URL}/{guild_id}");
		let config = Config::builder()
			.user_agent("leaberblord +gen@nyble.dev")
			.build();

		let data = InteractionResponseDataBuilder::new()
			.content(
				"⏳ waiting on emboard for the leaderboard. we'll display the leaderboard when it's imported",
			)
			.build();

		brain.interaction_respond(create, data).await;

		match config.new_agent().get(url).call() {
			Err(_e) => todo!(),
			Ok(mut resp) => {
				let body: String = resp.body_mut().read_to_string().unwrap();
				super::import(&brain.db, body);

				let embed = crate::get_leaderboard(brain.clone(), guild_id)
					.embeds
					.unwrap()[0]
					.clone();

				brain
					.send_message_with_embed(
						create.channel.as_ref().unwrap().id,
						"✅ imported leaderboard from emboard",
						embed,
					)
					.await;
			}
		}
	}
}