use crate::games::slots::SlotsGame;
use crate::games::traits::{Game, GameError, GamePhase, GameState};
use std::collections::HashMap;
use std::io::Write;

pub struct GameManager {
    current_session: Option<GameState>,
    pending_game_type: Option<String>,
    games: HashMap<String, Box<dyn Game>>,
}

impl GameManager {
    pub fn new() -> Self {
        let mut games: HashMap<String, Box<dyn Game>> = HashMap::new();
        games.insert("slots".to_string(), Box::new(SlotsGame::new()));

        Self {
            current_session: None,
            pending_game_type: None,
            games,
        }
    }

    pub fn get_available_games(&self) -> Vec<(&str, &str)> {
        self.games
            .iter()
            .map(|(k, v)| (k.as_str(), v.get_name()))
            .collect()
    }

    pub fn enter_game(&mut self, game_type: &str) -> Result<(), GameError> {
        if self.current_session.is_some() {
            return Err(GameError::InvalidAction);
        }

        if !self.games.contains_key(game_type) {
            return Err(GameError::InvalidAction);
        }

        self.pending_game_type = Some(game_type.to_string());

        self.current_session = Some(GameState {
            game_type: game_type.to_string(),
            bet_amount: 10,
            phase: GamePhase::WaitingToStart,
            data: HashMap::new(),
        });

        Ok(())
    }

    pub fn start_game(
        &mut self,
        stream: &mut crate::connection::TlsStream,
    ) -> Result<(), GameError> {
        let game_type = self
            .pending_game_type
            .take()
            .ok_or(GameError::InvalidAction)?;

        let state = self
            .current_session
            .as_mut()
            .ok_or(GameError::InvalidAction)?;

        if state.phase != GamePhase::WaitingToStart {
            return Err(GameError::InvalidAction);
        }

        let bet_amount = state.bet_amount;

        let writer = stream;
        writeln!(writer, "PLAY_START {} {}", game_type, bet_amount)
            .map_err(|_| GameError::NetworkError)?;

        Ok(())
    }

    pub fn get_current_game(&self) -> Option<&dyn Game> {
        self.current_session
            .as_ref()
            .and_then(|session| self.games.get(&session.game_type).map(|game| game.as_ref()))
    }

    pub fn get_current_state(&self) -> Option<&GameState> {
        self.current_session.as_ref()
    }

    pub fn get_current_render_lines(&self) -> Option<usize> {
        let session = self.current_session.as_ref()?;
        let game = self.games.get(&session.game_type)?;
        Some(game.render_lines(session))
    }

    pub fn is_in_game(&self) -> bool {
        self.current_session.is_some()
    }

    pub fn is_game_started(&self) -> bool {
        self.current_session
            .as_ref()
            .map(|s| s.phase != GamePhase::WaitingToStart)
            .unwrap_or(false)
    }

    pub fn end_game(&mut self) {
        self.current_session = None;
        self.pending_game_type = None;
    }

    pub fn adjust_bet(&mut self, delta: i64) -> Result<u64, GameError> {
        if let Some(ref session) = self.current_session {
            if session.phase != GamePhase::WaitingToStart {
                return Err(GameError::InvalidAction);
            }
        }

        if let Some(ref mut session) = self.current_session {
            let current_bet = session.bet_amount as i64;
            let new_bet = (current_bet + delta).max(10) as u64;
            session.bet_amount = new_bet;
            Ok(new_bet)
        } else {
            Err(GameError::InvalidAction)
        }
    }
}