#![feature(if_let_guard)]

use crate::game_handler::*;
use anyhow::{Context, Result};
use axum::extract::ws::Message;
use game_handler::GameHandlerMessage;
use lib::*;
use std::{
    collections::{HashMap, HashSet},
    fs::{read_to_string, File},
    io::{BufRead, BufReader},
    net::SocketAddr,
    sync::{Arc, RwLock},
};
use tokio::sync::mpsc::Sender;
use tokio::sync::{broadcast, mpsc};
use user_handler::UserHandlerMessage;
use uuid::Uuid;
pub mod game_handler;
pub mod message_handler;
pub mod user_handler;
pub mod websocket;

/// User
#[derive(Debug)]
pub struct User {
    pub uuid: Uuid,
    pub name: String,
    pub tx: Sender<String>,
}

impl User {
    /// Create a new user object from incoming data
    pub fn new(name: String, tx: Sender<String>) -> User {
        User {
            uuid: Uuid::now_v7(),
            name,
            tx,
        }
    }

    pub fn change_name(&mut self, new_name: String) {
        self.name = new_name;
    }
}

/// Parse json for card data
pub fn load_cards_from_json(path: &str) -> Result<(CardPacks, CardPacksMeta)> {
    let data: String =
        read_to_string(path).with_context(|| format!("Invalid JSON path: \"{}\"", path))?;
    let jayson: Vec<CardPack> = serde_json::from_str(&data)
        .with_context(|| format!("The contents of \"{path}\" is not valid JSON."))?;

    let mut official: HashMap<u8, CardSet> = HashMap::new();
    let mut unofficial: HashMap<u8, CardSet> = HashMap::new();

    let mut official_meta: Vec<CardPackMeta> = vec![];
    let mut unofficial_meta: Vec<CardPackMeta> = vec![];

    for set in jayson {
        let mut num_white = 0;
        let mut num_black = 0;

        let mut newset = CardSet {
            white: Option::None,
            black: Option::None,
        };

        // No safe default for this so make it an Option
        let mut pack: Option<u8> = Option::None;

        if let Some(ref white) = set.white {
            num_white = white.len();
            if num_white > 0 {
                pack = Some(white[0].pack);
                newset.white = Some(set.white.unwrap());
            }
        }

        if let Some(ref black) = set.black {
            num_black = black.len();
            if num_black > 0 {
                pack = Some(black[0].pack);
                newset.black = Some(set.black.unwrap());
            }
        }

        let meta = CardPackMeta {
            name: set.name,
            pack: pack.expect("No card pack number!"),
            num_white,
            num_black,
        };

        if set.official {
            official_meta.push(meta);
            official.insert(pack.unwrap(), newset);
        } else {
            unofficial_meta.push(meta);
            unofficial.insert(pack.unwrap(), newset);
        }
    }

    official.shrink_to_fit();
    unofficial.shrink_to_fit();

    official_meta.shrink_to_fit();
    unofficial_meta.shrink_to_fit();

    tracing::debug!("{} official", official.len());
    tracing::debug!("{} official meta", official_meta.len());
    tracing::debug!("{} unofficial", unofficial.len());
    tracing::debug!("{} unofficial meta", unofficial_meta.len());
    tracing::debug!("{:#?}", official_meta[0]);
    tracing::debug!("{:#?}", unofficial_meta[0]);

    let packs = CardPacks {
        official,
        unofficial,
    };

    let packs_meta = CardPacksMeta {
        official_meta,
        unofficial_meta,
    };

    Ok((packs, packs_meta))
}

/// Parse name list
pub fn load_names(path: &str) -> Result<Vec<String>> {
    let f = File::open(path).with_context(|| format!("Invalid names path: \"{}\"", path))?;
    let f = BufReader::new(f);

    let mut buf = vec![];

    for line in f.lines() {
        buf.push(line?)
    }

    Ok(buf)
}

// Our shared state
pub struct AppState {
    pub broadcast_tx: broadcast::Sender<String>,
    pub users_tx: mpsc::Sender<UserHandlerMessage>,
    pub messages_tx: mpsc::Sender<(SocketAddr, Message)>,
    pub games_tx: mpsc::Sender<GameHandlerMessage>,
    pub first_names: Vec<String>,
    pub last_names: Vec<String>,
    pub reserved_names: RwLock<HashSet<String>>,
    pub user_uuid: RwLock<HashMap<Uuid, Arc<RwLock<User>>>>,
    pub online_users: RwLock<HashMap<SocketAddr, Arc<RwLock<User>>>>,
    pub offline_users: RwLock<HashMap<String, Arc<RwLock<User>>>>,
    pub packs: CardPacks,
    pub packs_meta: CardPacksMeta,
    pub games: RwLock<HashMap<String, Arc<RwLock<Game>>>>,
}