use std::time::{Duration, Instant};
use serde::{Serialize, Deserialize};
use actix::{Actor, Addr, Context};
use crate::websocket;
use crate::server;

#[derive(Serialize, Deserialize, Clone)]
pub enum GameState {
    Creating,
    Guessing(usize),
}

#[derive(Serialize, Deserialize, Clone)]
pub struct CreatingEx {
    pub question: String,
    pub letters: Vec<char>
}

#[derive(Serialize, Deserialize, Clone)]
pub struct Round {
    pub exercises: Vec<CreatingEx>
}

#[derive(Serialize, Clone)]
pub struct Player {
    nick: String,

    #[serde(skip_serializing)]
    actor: Addr<server::GameConnection>,

    submitted_word: Option<String>,
}

#[derive(Serialize, Clone)]
pub struct Game {
    players: Vec<Player>,
    round_number: i32,

    #[serde(skip_serializing)]
    round: Round,

    state: GameState,
}


impl Game {
    pub fn new() -> Self {
        Self {
            players: vec![],
            round_number: 0,
            round: Round{ exercises: vec![] },
            state: GameState::Creating
        }
    }

    fn get_player(&mut self, nick: &str) -> Option<&mut Player> {
        self.players.iter_mut().find(|x| x.nick == nick)
    }

    pub fn submit_creation(&mut self, player_nick: &str, word: &str) -> bool {
        match self.state {
            GameState::Creating => {
                if let Some(player) = self.get_player(player_nick) {
                    player.submitted_word = Some(word.to_owned());
                    true
                }
                else {
                    false
                }
            },
            _ => false
        }
    }

    pub fn next_state(&mut self) {
        match self.state {
            GameState::Creating => {
                self.state = GameState::Guessing(0);
            },
            GameState::Guessing(index) => {
                if index + 1 < self.players.len() {
                    self.state = GameState::Guessing(index + 1);
                }
                else {
                    self.state = GameState::Creating;
                }
            }
        }
    }

    pub fn player_join(&mut self, nick: &str, actor: Addr<server::GameConnection>) {
        self.players.push(Player{ nick: nick.to_owned(), actor, submitted_word: None });
    }
}