use std::{collections::HashMap, net::SocketAddr, sync::Arc};

use rand::RngExt;
use tokio::sync::{
  mpsc::{error::SendError, UnboundedSender},
  RwLock,
};
use tokio_tungstenite::tungstenite::Message;
use tracing::error;

use crate::{
  tournaments::Tournament,
  types::{Client, Color, Match},
};

pub mod server;
pub mod tournaments;
pub mod types;

pub type Clients = Arc<RwLock<HashMap<String, Arc<RwLock<Client>>>>>;
pub type Usernames = Arc<RwLock<HashMap<SocketAddr, String>>>;
pub type Observers = Arc<RwLock<HashMap<SocketAddr, UnboundedSender<Message>>>>;
pub type Matches = Arc<RwLock<HashMap<u32, Arc<RwLock<Match>>>>>;
pub type Reservations = Arc<RwLock<Vec<(String, String)>>>;
pub type WrappedTournament = Arc<RwLock<Option<Arc<RwLock<dyn Tournament + Send + Sync>>>>>;

pub const SERVER_PLAYER_USERNAME: &str = "The Server";
// pub const SERVER_PLAYER_ADDR: &str = "127.0.0.1:6666";

pub async fn broadcast_message(observers: &Observers, msg: &str) {
  let observer_guard = observers.read().await;
  for tx in observer_guard.values() {
    let _ = send(tx, msg);
  }
}

pub async fn gen_match_id(matches: &Matches) -> u32 {
  let matches_guard = matches.read().await;
  let mut result = rand::rng().random_range(100000..=999999);
  while matches_guard.get(&result).is_some() {
    result = rand::rng().random_range(100000..=999999);
  }
  result
}

pub fn random_move(board: &[Vec<Color>]) -> usize {
  let mut random = rand::rng().random_range(0..7);
  while board[random][5] != Color::None {
    random = rand::rng().random_range(0..7);
  }

  random
}

pub fn send(tx: &UnboundedSender<Message>, text: &str) -> Result<(), SendError<Message>> {
  tx.send(Message::text(text))
}