use rand::prelude::*;
use uuid::Uuid;

// timekeeping
use chrono::prelude::*;
use chrono::Duration;

// Db Commons
use serde_cbor::{from_slice, to_vec};
use postgres::transaction::Transaction;
use failure::Error;
use failure::err_msg;

use account::Account;
use rpc::{GameStateParams, GameSkillParams};
use construct::{Construct};
use skill::{Skill, Effect, Cast, Resolution, Event, resolution_steps};
use player::{Player};
use instance::{instance_game_finished, global_game_finished};

#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
pub enum Phase {
    Start,
    Skill,
    Resolve,
    Finish,
}

#[derive(Debug,Clone,Serialize,Deserialize)]
pub struct Game {
    pub id: Uuid,
    pub player_constructs: usize,
    pub player_num: usize,
    pub players: Vec<Player>,
    pub phase: Phase,
    pub stack: Vec<Cast>,
    pub resolved: Vec<Resolution>,
    pub log: Vec<String>,
    pub instance: Option<Uuid>,
    phase_end: DateTime<Utc>,
    phase_start: DateTime<Utc>,
}

impl Game {
    pub fn new() -> Game {
        return Game {
            id: Uuid::new_v4(),
            player_constructs: 0,
            player_num: 0,
            players: vec![],
            phase: Phase::Start,
            stack: vec![],
            resolved: vec![],
            log: vec![],
            instance: None,
            phase_end: Utc::now(),
            phase_start: Utc::now(),
        };
    }

    pub fn set_player_num(&mut self, size: usize) -> &mut Game {
        self.player_num = size;
        self
    }

    pub fn set_player_constructs(&mut self, size: usize) -> &mut Game {
        self.player_constructs = size;
        self
    }

    pub fn set_instance(&mut self, id: Uuid) -> &mut Game {
        self.instance = Some(id);
        self
    }

    pub fn joinable(&self) -> bool {
        self.can_start()
    }

    pub fn player_add(&mut self, mut player: Player) -> Result<&mut Game, Error> {
        if self.players.len() == self.player_num {
            return Err(err_msg("maximum number of players"));
        }

        if self.players.iter().any(|t| t.id == player.id) {
            return Err(err_msg("player already in game"));
        }

        if player.constructs.iter().all(|c| c.skills.len() == 0) {
            info!("WARNING: {:?} has no skills and has forfeited {:?}", player.name, self.id);
            player.forfeit();
        }

        let player_description = player.constructs.iter().map(|c| c.name.clone()).collect::<Vec<String>>().join(", ");
        self.log.push(format!("{:} has joined the game. [{:}]", player.name, player_description));

        player.constructs.sort_unstable_by_key(|c| c.id);
        self.players.push(player);

        Ok(self)
    }

    // handle missing player properly
    pub fn player_by_id(&mut self, id: Uuid) -> Result<&mut Player, Error> {
        self.players
            .iter_mut()
            .find(|t| t.id == id)
            .ok_or(format_err!("{:?} not in game", id))
    }

    pub fn construct_by_id(&mut self, id: Uuid) -> Option<&mut Construct> {
        match self.players.iter_mut().find(|t| t.constructs.iter().any(|c| c.id == id)) {
            Some(player) => player.constructs.iter_mut().find(|c| c.id == id),
            None => None,
        }
    }

    pub fn construct_by_id_take(&mut self, id: Uuid) -> Construct {
        match self.players.iter_mut().find(|t| t.constructs.iter().any(|c| c.id == id)) {
            Some(player) => {
                let i = player.constructs.iter().position(|c| c.id == id).unwrap();
                player.constructs.remove(i)
            }
            None => panic!("id not in game {:}", id),
        }
    }


    fn all_constructs(&self) -> Vec<Construct> {
        self.players.clone()
            .into_iter()
            .flat_map(
                |t| t.constructs
                    .into_iter())
                    .collect::<Vec<Construct>>()
    }

    pub fn update_construct(&mut self, construct: &mut Construct) -> &mut Game {
        match self.players.iter_mut().find(|t| t.constructs.iter().any(|c| c.id == construct.id)) {
            Some(player) => {
                let index = player.constructs.iter().position(|t| t.id == construct.id).unwrap();
                player.constructs.remove(index);
                player.constructs.push(construct.clone());
                player.constructs.sort_unstable_by_key(|c| c.id);
            },
            None => panic!("construct not in game"),
        };

        self
    }

    pub fn can_start(&self) -> bool {
        return self.players.len() == self.player_num
            && self.players.iter().all(|t| t.constructs.len() == self.player_constructs)
    }

    pub fn start(mut self) -> Game {
        self.log.push("Game starting...".to_string());

        // forfeit
        if self.finished() {
            return self.finish();
        }

        self.skill_phase_start(0)
    }

    fn skill_phase_start(mut self, num_resolutions: usize) -> Game {
        let resolution_animation_ms = num_resolutions * 2500;
        let phase_add_time_ms = 60000 + resolution_animation_ms;
        self.phase_start = Utc::now()
            .checked_add_signed(Duration::milliseconds(resolution_animation_ms as i64))
            .expect("could not set phase start");
        self.phase_end = Utc::now()
            .checked_add_signed(Duration::milliseconds(phase_add_time_ms as i64))
            .expect("could not set phase end");

        for player in self.players.iter_mut() {
            if player.skills_required() == 0 {
                continue;
            }

            player.set_ready(false);

            for construct in player.constructs.iter_mut() {
                for i in 0..construct.skills.len() {
                    if let Some(_d) = construct.disabled(construct.skills[i].skill) {
                        // info!("{:?} disabled {:?}", construct.skills[i].skill, d);
                        construct.skills[i].disabled = true;
                    } else {
                        construct.skills[i].disabled = false;
                    }
                }
            }
        }

        self.log.push("<Skill Phase>".to_string());

        if ![Phase::Start, Phase::Resolve].contains(&self.phase) {
            panic!("game not in Resolve or start phase");
        }

        self.phase = Phase::Skill;

        self.pve_add_skills();

        if self.skill_phase_finished() {
            return self.resolve_phase_start()
        }

        self
    }

    fn pve_add_skills(&mut self) -> &mut Game {
        let mut pve_skills = vec![];

        for mobs in self.players
            .iter()
            .filter(|t| t.bot) {
            let player_player = self.players.iter().find(|t| t.id != mobs.id).unwrap();

            for mob in mobs.constructs.iter() {
                let skill = mob.mob_select_skill();
                // info!("{:?} {:?}", mob.name, skill);
                match skill {
                    Some(s) => {
                        let mut rng = thread_rng();

                        // the mut marks it as being able to be called
                        // more than once
                        let mut find_target = || {
                            match s.defensive() {
                                true => &mobs.constructs[rng.gen_range(0, mobs.constructs.len())],
                                false => &player_player.constructs[rng.gen_range(0, player_player.constructs.len())],
                            }
                        };

                        let mut target = find_target();

                        while target.is_ko() {
                            target = find_target();
                        }

                        pve_skills.push((mobs.id, mob.id, Some(target.id), s));
                    },
                    None => continue,
                };
            }
        }

        for (player_id, mob_id, target_id, s) in pve_skills {
            match self.add_skill(player_id, mob_id, target_id, s) {
                Ok(_) => (),
                Err(e) => {
                    info!("{:?}", self.construct_by_id(mob_id));
                    panic!("{:?} unable to add pve mob skill {:?}", e, s);
                },
            }

            self.player_ready(player_id).unwrap();
        }

        self
    }

    fn add_skill(&mut self, player_id: Uuid, source_construct_id: Uuid, target_construct_id: Option<Uuid>, skill: Skill) -> Result<&mut Game, Error> {
        // check player in game
        self.player_by_id(player_id)?;

        if self.phase != Phase::Skill {
            return Err(err_msg("game not in skill phase"));
        }

        let final_target_id = match skill.self_targeting() {
            true => source_construct_id,
            false => match target_construct_id {
                Some(t) => t,
                None => return Err(err_msg("skill requires a target")),
            }
        };

        // target checks
        {
            let target = match self.construct_by_id(final_target_id) {
                Some(c) => c,
                None => return Err(err_msg("target construct not in game")),
            };

            // fixme for rez
            if target.is_ko() {
               return Err(err_msg("target construct is ko"));
            }
        }

        // construct checks
        {
            let construct = match self.construct_by_id(source_construct_id) {
                Some(c) => c,
                None => return Err(err_msg("construct not in game")),
            };

            if construct.is_ko() {
               return Err(err_msg("construct is ko"));
            }

            // check the construct has the skill
            if !construct.knows(skill) {
                return Err(err_msg("construct does not have that skill"));
            }

            if construct.skill_on_cd(skill).is_some() {
               return Err(err_msg("abiltity on cooldown"));
            }

            // check here as well so uncastable spells don't go on the stack
            if let Some(disable) = construct.disabled(skill) {
               return Err(format_err!("skill disabled {:?}", disable));
            }
        }

        // replace construct skill
        if let Some(s) = self.stack.iter_mut().position(|s| s.source_construct_id == source_construct_id) {
            self.stack.remove(s);
        }

        let skill = Cast::new(source_construct_id, player_id, final_target_id, skill);
        self.stack.push(skill);

        return Ok(self);
    }

    fn player_ready(&mut self, player_id: Uuid) -> Result<&mut Game, Error> {
        if self.phase != Phase::Skill {
            return Err(err_msg("game not in skill phase"));
        }

        self.player_by_id(player_id)?
            .set_ready(true);

        Ok(self)
    }

    fn skill_phase_finished(&self) -> bool {
        self.players.iter().all(|t| t.ready)
        // self.players.iter()
        //     // for every player
        //     .all(|t| self.stack.iter()
        //         // the number of skills they have cast
        //         .filter(|s| s.source_player_id == t.id).collect::<Vec<&Cast>>()
        //         // should equal the number required this turn
        //         .len() == t.skills_required()
        //     )
    }

    // requires no input
    // just do it
    fn resolve_phase_start(mut self) -> Game {
        if self.phase != Phase::Skill {
            panic!("game not in skill phase");
        }
        assert!(self.skill_phase_finished());

        self.phase = Phase::Resolve;
        self.log.push("<Resolve Phase>".to_string());

        self.resolve_skills()
    }

    fn stack_sort_speed(&mut self) -> &mut Game {
        let mut sorted = self.stack.clone();
        sorted.iter_mut()
            .for_each(|s| {
                let caster = self.construct_by_id(s.source_construct_id).unwrap();
                let speed = caster.skill_speed(s.skill);
                s.speed = speed;
            });

        sorted.sort_unstable_by_key(|s| s.speed);

        self.stack = sorted;

        self
    }

    fn construct_aoe_targets(&self, construct_id: Uuid) -> Vec<Uuid> {
        self.players.iter()
            .find(|t| t.constructs.iter().any(|c| c.id == construct_id))
            .unwrap()
            .constructs
            .iter()
            .map(|c| c.id)
            .collect()
    }

    pub fn get_targets(&self, skill: Skill, source: &Construct, target_construct_id: Uuid) -> Vec<Uuid> {
        let target_player = self.players.iter()
            .find(|t| t.constructs.iter().any(|c| c.id == target_construct_id))
            .unwrap();

        if let Some(t) = target_player.taunting() {
            return vec![t.id];
        }

        match source.skill_is_aoe(skill) {
            true => self.construct_aoe_targets(target_construct_id),
            false => vec![target_construct_id],
        }
    }

    fn resolve_skills(mut self) -> Game {
        if self.phase != Phase::Resolve {
            panic!("game not in Resolve phase");
        }

        // find their statuses with ticks
        let mut ticks = self.all_constructs()
            .iter()
            .flat_map(
                |c| c.effects
                    .iter()
                    .cloned()
                    .filter_map(|e| e.tick))
                    .collect::<Vec<Cast>>();

        // add them to the stack
        self.stack.append(&mut ticks);

        self.stack_sort_speed();

        // temp vec of this round's resolving skills
        // because need to check cooldown use before pushing them into the complete list
        let mut casts = vec![];
        let mut turn_events = 0;

        while let Some(cast) = self.stack.pop() {
            // info!("{:} casts ", cast);

            let mut resolutions = resolution_steps(&cast, &mut self);
            resolutions.reverse();
            turn_events += resolutions.len();
            while let Some(resolution) = resolutions.pop() {
                self.log_resolution(cast.speed, &resolution);
                // the results go into the resolutions
                self.resolved.push(resolution);
            }

            // the cast itself goes into this temp vec
            // to handle cooldowns
            casts.push(cast);

            // sort the stack again in case speeds have changed
            self.stack_sort_speed();
        };

        // info!("{:#?}", self.casts);

        // handle cooldowns and statuses
        self.progress_durations(&casts);

        if self.finished() {
            return self.finish()
        }

        self.skill_phase_start(turn_events)
    }

    fn progress_durations(&mut self, resolved: &Vec<Cast>) -> &mut Game {
        for mut construct in self.all_constructs() {
            // info!("progressing durations for {:}", construct.name);

            if construct.is_ko() {
                continue;
            }

            // only reduce cooldowns if no cd was used
            // have to borrow self for the skill check
            {
                if let Some(skill) = resolved.iter().find(|s| s.source_construct_id == construct.id) {
                    if skill.used_cooldown() {
                        construct.skill_set_cd(skill.skill);
                    } else {
                        construct.reduce_cooldowns();
                    }
                } else {
                   construct.reduce_cooldowns();
                }
            }

            // always reduce durations
            construct.reduce_effect_durations();
            self.update_construct(&mut construct);
        }

        self
    }

    fn log_resolution(&mut self, speed: u64, resolution: &Resolution) -> &mut Game {
        let Resolution { source, target, event, stages } = resolution;
        match event {
            Event::Ko { skill: _ }=>
                self.log.push(format!("{:} KO!", target.name)),

            Event::Disable { skill, disable } =>
                self.log.push(format!("{:} {:?} {:} disabled {:?}",
                    source.name, skill, target.name, disable)),

            Event::Immunity { skill, immunity } =>
                self.log.push(format!("[{:}] {:} {:?} {:} immune {:?}",
                    speed, source.name, skill, target.name, immunity)),

            Event::TargetKo { skill } =>
                self.log.push(format!("[{:}] {:} {:?} {:} - target is KO",
                    speed, source.name, skill, target.name)),

            Event::Damage { skill, amount, mitigation, colour: _ } =>
                self.log.push(format!("[{:}] {:} {:?} {:} {:} ({:} mitigated)",
                    speed, source.name, skill, target.name, amount, mitigation)),

            Event::Healing { skill, amount, overhealing } =>
                self.log.push(format!("[{:}] {:} {:?} {:} {:} healing ({:}OH)",
                    speed, source.name, skill, target.name, amount, overhealing)),

            Event::Inversion { skill } =>
                self.log.push(format!("[{:}] {:} {:?} {:} INVERTED",
                    speed, source.name, skill, target.name)),

            Event::Reflection { skill } =>
                self.log.push(format!("[{:}] {:} {:?} {:} REFLECTED",
                    speed, source.name, skill, target.name)),

            Event::Effect { skill, effect, duration, construct_effects: _ } =>
                self.log.push(format!("[{:}] {:} {:?} {:} {:?} {:}T",
                    speed, source.name, skill, target.name, effect, duration)),

            Event::Skill { skill } =>
                self.log.push(format!("[{:}] {:} {:?} {:}",
                    speed, source.name, skill, target.name)),

            Event::Removal { effect, construct_effects: _ } =>
                self.log.push(format!("[{:}] {:?} removed {:} {:?}",
                    speed, source.name, target.name, effect)),

            Event::Recharge { skill, red, blue } =>
                self.log.push(format!("[{:}] {:} {:?} {:} {:}R {:}B",
                    speed, source.name, skill, target.name, red, blue)),

            Event::Evasion { skill, evasion_rating } =>
                self.log.push(format!("[{:}] {:} {:?} {:} evaded ({:}%)",
                    speed, source.name, skill, target.name, evasion_rating)),

            Event::Incomplete => panic!("incomplete resolution {:?}", resolution),
        }

        self
    }

    pub fn finished(&self) -> bool {
        self.players.iter().any(|t| t.constructs.iter().all(|c| c.is_ko()))
    }

    pub fn winner(&self) -> Option<&Player> {
        self.players.iter().find(|t| t.constructs.iter().any(|c| !c.is_ko()))
    }

    fn finish(mut self) -> Game {
        self.phase = Phase::Finish;
        self.log.push(format!("Game finished."));

        {
            let winner = self.players.iter().find(|t| t.constructs.iter().any(|c| !c.is_ko()));
            match winner {
                Some(w) => self.log.push(format!("Winner: {:}", w.name)),
                None => self.log.push(format!("Game was drawn.")),
            };
        }

        self
    }

    fn phase_timed_out(&self) -> bool {
        Utc::now().signed_duration_since(self.phase_end).num_milliseconds() > 0
    }

    pub fn upkeep(mut self) -> Game {
        if self.phase == Phase::Finish {
            return self;
        }

        if !self.phase_timed_out() {
            return self;
        }

        info!("upkeep game: {:} vs {:}", self.players[0].name, self.players[1].name);

        for player in self.players.iter_mut() {
            if !player.ready {
                player.set_ready(true);
                player.add_warning();
                info!("upkeep: {:} warned", player.name);
                if player.warnings >= 3 {
                    player.forfeit();
                    info!("upkeep: {:} forfeited", player.name);
                    self.log.push(format!("{:} forfeited.", player.name));
                }
            }
        }

        self = self.resolve_phase_start();
        self
    }
}

pub fn game_write(tx: &mut Transaction, game: &Game) -> Result<(), Error> {
    let game_bytes = to_vec(&game)?;

    let query = "
        INSERT INTO games (id, data, upkeep)
        VALUES ($1, $2, $3)
        RETURNING id;
    ";

    // no games should be sent to db that are not in progress
    let result = tx
        .query(query, &[&game.id, &game_bytes, &game.phase_end])?;

    result.iter().next().ok_or(format_err!("no game written"))?;

    // info!("{:} wrote game", game.id);

    return Ok(());
}

pub fn game_state(params: GameStateParams, tx: &mut Transaction, _account: &Account) -> Result<Game, Error> {
    return game_get(tx, params.id)
}

pub fn game_get(tx: &mut Transaction, id: Uuid) -> Result<Game, Error> {
    let query = "
        SELECT *
        FROM games
        WHERE id = $1
        FOR UPDATE;
    ";

    let result = tx
        .query(query, &[&id])?;

    let returned = match result.iter().next() {
        Some(row) => row,
        None => return Err(err_msg("game not found")),
    };

    // tells from_slice to cast into a construct
    let game_bytes: Vec<u8> = returned.get("data");
    let game = from_slice::<Game>(&game_bytes)?;

    return Ok(game);
}

pub fn games_need_upkeep(tx: &mut Transaction) -> Result<Vec<Game>, Error> {
    let query = "
        SELECT data, id
        FROM games
        WHERE finished = false
        AND upkeep < now()
        FOR UPDATE;
    ";
    let result = tx
        .query(query, &[])?;

    let mut list = vec![];

    for row in result.into_iter() {
        let bytes: Vec<u8> = row.get(0);
        let id = row.get(1);

        match from_slice::<Game>(&bytes) {
            Ok(i) => list.push(i),
            Err(_e) => {
                game_delete(tx, id)?;
            }
        };
    }

    return Ok(list);
}

pub fn game_delete(tx: &mut Transaction, id: Uuid) -> Result<(), Error> {
    let query = "
        DELETE
        FROM games
        WHERE id = $1;
    ";

    let result = tx
        .execute(query, &[&id])?;

    if result != 1 {
        return Err(format_err!("unable to delete player {:?}", id));
    }

    info!("game deleted {:?}", id);

    return Ok(());
}

// pub fn game_global_startup(tx: &mut Transaction) -> Result<(), Error> {
//     if game_global_get(tx).is_ok() {
//         info!("global mm game exists");
//         return Ok(());
//     }

//     let mut game = Game::new();

//     game
//         .set_player_num(2)
//         .set_player_constructs(3)
//         .set_mode(GameMode::Pvp);

//     game_write(tx, &game)?;

//     let query = "
//         INSERT INTO matchmaking (id, game)
//         VALUES ($1, $2)
//         RETURNING id;
//     ";

//     let result = tx
//         .query(query, &[&Uuid::nil(), &game.id])?;

//     result.iter().next().ok_or(format_err!("no game written"))?;

//     info!("{:} wrote global mm startup", game.id);

//     return Ok(());
// }

// pub fn game_global_set(tx: &mut Transaction, game: &Game) -> Result<(), Error> {
//     let query = "
//         UPDATE matchmaking
//         SET game = $1
//         WHERE id = $2
//         RETURNING id, game;
//     ";

//     let result = tx
//         .query(query, &[&game.id, &Uuid::nil()])?;

//     result.iter()
//         .next()
//         .ok_or(err_msg("could not set global game mm"))?;

//     return Ok(());
// }

// pub fn game_global_get(tx: &mut Transaction) -> Result<Game, Error> {
//     let query = "
//         SELECT * from games
//         WHERE id = (
//             SELECT game
//             FROM matchmaking
//             WHERE id = $1
//         );
//     ";

//     let delete_query = "
//         DELETE from matchmaking;
//     ";

//     let result = tx
//         .query(query, &[&Uuid::nil()])?;

//     let returned = match result.iter().next() {
//         Some(row) => row,
//         None => return Err(err_msg("game not found")),
//     };

//     // tells from_slice to cast into a construct
//     let game_bytes: Vec<u8> = returned.get("data");
//     let game = match from_slice::<Game>(&game_bytes) {
//         Ok(g) => g,
//         Err(_) => {
//             tx.query(delete_query, &[])?;
//             return Err(err_msg("matchmaking game was invalid"))
//         }
//     };

//     return Ok(game);
// }


pub fn game_update(tx: &mut Transaction, game: &Game) -> Result<(), Error> {
    let game_bytes = to_vec(&game)?;

    let query = "
        UPDATE games
        SET data = $1, finished = $2, upkeep = $3, updated_at = now()
        WHERE id = $4
        RETURNING id, data;
    ";

    let result = tx
        .query(query, &[&game_bytes, &game.finished(), &game.phase_end, &game.id])?;

    result.iter().next().ok_or(format_err!("game {:?} could not be written", game))?;

    if game.finished() {
        if let Some(i) = game.instance {
            match i == Uuid::nil() {
                true => global_game_finished(tx, &game)?,
                false => instance_game_finished(tx, &game, i)?,
            }
        }
    }

    return Ok(());
}

pub fn game_skill(params: GameSkillParams, tx: &mut Transaction, account: &Account) -> Result<Game, Error> {
    let mut game = game_get(tx, params.game_id)?;

    game.add_skill(account.id, params.construct_id, params.target_construct_id, params.skill)?;

    if game.skill_phase_finished() {
        game = game.resolve_phase_start();
    }

    game_update(tx, &game)?;

    Ok(game)
}

pub fn game_ready(params: GameStateParams, tx: &mut Transaction, account: &Account) -> Result<Game, Error> {
    let mut game = game_get(tx, params.id)?;

    game.player_ready(account.id)?;

    if game.skill_phase_finished() {
        game = game.resolve_phase_start();
    }

    game_update(tx, &game)?;

    Ok(game)
}

// pub fn game_pve_new(construct_ids: Vec<Uuid>, mode: GameMode, tx: &mut Transaction, account: &Account) -> Result<Game, Error> {
//     if construct_ids.len() == 0 {
//         return Err(err_msg("no constructs selected"));
//     }

//     let constructs = construct_ids
//         .iter()
//         .map(|id| construct_get(tx, *id, account.id))
//         .collect::<Result<Vec<Construct>, Error>>()?;

//     if constructs.len() > 3 {
//         return Err(err_msg("player size too large (3 max)"));
//     }

//     // create the game
//     let mut game = Game::new();
//     // let game_id = game.id;

//     game;
//         .set_player_num(2)
//         .set_player_constructs(constructs.len())
//         .set_mode(mode);

//     // create the mob player
//     let mob_player = generate_mob_player(mode, &constructs);

//     // add the players
//     let mut plr_player = Player::new(account.id);
//     plr_player
//         .set_constructs(constructs);


//     game
//         .player_add(plr_player)?
//         .player_add(mob_player)?;

//     game.start();

//     return Ok(game);
// }

// pub fn game_pve(params: GamePveParams, tx: &mut Transaction, account: &Account) -> Result<Game, Error> {
//     let game = game_pve_new(params.construct_ids, GameMode::Normal, tx, account)?;

//     // persist
//     game_write(tx, &game)?;

//     Ok(game)
// }

pub fn game_instance_new(tx: &mut Transaction, players: Vec<Player>, game_id: Uuid, instance_id: Uuid) -> Result<Game, Error> {
    // create the game
    let mut game = Game::new();
    game.id = game_id;

    game
        .set_player_num(2)
        .set_player_constructs(3)
        .set_instance(instance_id);

    // create the initiators player
    for player in players {
        game.player_add(player)?;
    }

    if game.can_start() {
        game = game.start();
    }

    // persist
    game_write(tx, &game)?;

    Ok(game)
}

// pub fn game_instance_join(tx: &mut Transaction, player: Player, game_id: Uuid) -> Result<Game, Error> {
//     let mut game = game_get(tx, game_id)?;

//     game.player_add(player)?;

//     if game.can_start() {
//         game = game.start();
//     }

//     info!("{:?} game joined", game.id);

//     game_update(tx, &game)?;

//     Ok(game)
// }

#[cfg(test)]
mod tests {
    use game::*;
    use construct::*;
    use util::IntPct;

    fn create_test_game() -> Game {
        let mut x = Construct::new()
            .named(&"pronounced \"creeep\"".to_string())
            .learn(Skill::Attack)
            .learn(Skill::Stun)
            .learn(Skill::Attack)
            .learn(Skill::Block)
            .learn(Skill::ParryI)
            .learn(Skill::SiphonI)
            .learn(Skill::AmplifyI)
            .learn(Skill::Stun)
            .learn(Skill::Block);

        let mut y = Construct::new()
            .named(&"lemongrass tea".to_string())
            .learn(Skill::Attack)
            .learn(Skill::Stun)
            .learn(Skill::Attack)
            .learn(Skill::Block)
            .learn(Skill::ParryI)
            .learn(Skill::SiphonI)
            .learn(Skill::AmplifyI)
            .learn(Skill::Stun)
            .learn(Skill::Block);

        let mut game = Game::new();

        game
            .set_player_num(2)
            .set_player_constructs(1);

        let x_player_id = Uuid::new_v4();
        x.account = x_player_id;
        let mut x_player = Player::new(x_player_id, &"ntr".to_string(), vec![x]);

        let y_player_id = Uuid::new_v4();
        y.account = y_player_id;
        let mut y_player = Player::new(y_player_id, &"mash".to_string(), vec![y]);

        game
            .player_add(x_player).unwrap()
            .player_add(y_player).unwrap();

        assert!(game.can_start());

        return game.start();
    }

    fn create_2v2_test_game() -> Game {
        let mut i = Construct::new()
            .named(&"pretaliate".to_string())
            .learn(Skill::Attack)
            .learn(Skill::Attack);

        let mut j = Construct::new()
            .named(&"poy sian".to_string())
            .learn(Skill::Attack)
            .learn(Skill::Attack);

        let mut x = Construct::new()
            .named(&"pronounced \"creeep\"".to_string())
            .learn(Skill::Attack)
            .learn(Skill::Attack);

        let mut y = Construct::new()
            .named(&"lemongrass tea".to_string())
            .learn(Skill::Attack)
            .learn(Skill::Attack);

        let mut game = Game::new();

        game
            .set_player_num(2)
            .set_player_constructs(2);

        let i_player_id = Uuid::new_v4();
        i.account = i_player_id;
        j.account = i_player_id;
        let i_player = Player::new(i_player_id, &"ntr".to_string(), vec![i, j]);

        let x_player_id = Uuid::new_v4();
        x.account = x_player_id;
        y.account = x_player_id;
        let x_player = Player::new(x_player_id, &"mashy".to_string(), vec![x, y]);

        game
            .player_add(i_player).unwrap()
            .player_add(x_player).unwrap();

        assert!(game.can_start());

        return game.start();
    }

    #[test]
    fn phase_test() {
        let mut game = create_test_game();

        let x_player = game.players[0].clone();
        let y_player = game.players[1].clone();

        let x_construct = x_player.constructs[0].clone();
        let y_construct = y_player.constructs[0].clone();

        game.add_skill(x_player.id, x_construct.id, Some(y_construct.id), Skill::Attack).unwrap();
        game.add_skill(y_player.id, y_construct.id, Some(x_construct.id), Skill::Attack).unwrap();

        game.player_ready(x_player.id).unwrap();
        game.player_ready(y_player.id).unwrap();

        assert!(game.skill_phase_finished());

        game = game.resolve_phase_start();

        assert!([Phase::Skill, Phase::Finish].contains(&game.phase));

        return;
    }

    #[test]
    fn stun_test() {
        let mut game = create_test_game();

        let x_player = game.players[0].clone();
        let y_player = game.players[1].clone();

        let x_construct = x_player.constructs[0].clone();
        let y_construct = y_player.constructs[0].clone();

        while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::Stun).is_some() {
            game.construct_by_id(x_construct.id).unwrap().reduce_cooldowns();
        }

        game.add_skill(x_player.id, x_construct.id, Some(y_construct.id), Skill::Stun).unwrap();
        game.add_skill(y_player.id, y_construct.id, Some(x_construct.id), Skill::Attack).unwrap();

        game.player_ready(x_player.id).unwrap();
        game.player_ready(y_player.id).unwrap();

        assert!(game.skill_phase_finished());
        game = game.resolve_phase_start();

        // should auto progress back to skill phase
        assert!(game.phase == Phase::Skill);

        // assert!(game.player_by_id(y_player.id).constructs[0].is_stunned());
        // assert!(game.player_by_id(y_player.id).skills_required() == 0);
    }

    #[test]
    fn ko_resolution_test() {
        let mut game = create_test_game();

        let x_player = game.players[0].clone();
        let y_player = game.players[1].clone();

        let x_construct = x_player.constructs[0].clone();
        let y_construct = y_player.constructs[0].clone();

        game.player_by_id(y_player.id).unwrap().construct_by_id(y_construct.id).unwrap().red_power.force(1000000000);
        game.player_by_id(y_player.id).unwrap().construct_by_id(y_construct.id).unwrap().speed.force(1000000000);

        while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::Stun).is_some() {
            game.construct_by_id(x_construct.id).unwrap().reduce_cooldowns();
        }

        // just in case
        // remove all mitigation
        game.player_by_id(x_player.id).unwrap().construct_by_id(x_construct.id).unwrap().red_life.force(0);

        game.add_skill(x_player.id, x_construct.id, Some(y_construct.id), Skill::Stun).unwrap();
        game.add_skill(y_player.id, y_construct.id, Some(x_construct.id), Skill::Attack).unwrap();

        game.player_ready(x_player.id).unwrap();
        game.player_ready(y_player.id).unwrap();

        assert!(game.skill_phase_finished());
        game = game.resolve_phase_start();

        assert!(!game.player_by_id(y_player.id).unwrap().constructs[0].is_stunned());
        assert!(game.phase == Phase::Finish);
    }

    #[test]
    fn cooldown_test() {
        let mut game = create_test_game();

        let x_player = game.players[0].clone();
        let y_player = game.players[1].clone();

        let x_construct = x_player.constructs[0].clone();
        let y_construct = y_player.constructs[0].clone();

        // should auto progress back to skill phase
        assert!(game.phase == Phase::Skill);

        assert!(game.player_by_id(y_player.id).unwrap().constructs[0].skill_on_cd(Skill::Block).is_none());
        assert!(game.player_by_id(y_player.id).unwrap().constructs[0].skill_on_cd(Skill::Stun).is_some());
        assert!(game.player_by_id(x_player.id).unwrap().constructs[0].skill_on_cd(Skill::Block).is_none());

        game.add_skill(x_player.id, x_construct.id, Some(y_construct.id), Skill::Attack).unwrap();
        game.add_skill(y_player.id, y_construct.id, Some(x_construct.id), Skill::Attack).unwrap();

        game.player_ready(x_player.id).unwrap();
        game.player_ready(y_player.id).unwrap();

        game = game.resolve_phase_start();

        // should auto progress back to skill phase
        assert!(game.phase == Phase::Skill);
        assert!(game.player_by_id(y_player.id).unwrap().constructs[0].skill_on_cd(Skill::Stun).is_some());

        // second round
        // now we block and it should go back on cd
        // game.add_skill(x_player.id, x_construct.id, Some(y_construct.id), Skill::Stun).unwrap();
        game.add_skill(y_player.id, y_construct.id, Some(x_construct.id), Skill::Attack).unwrap();

        game.player_ready(x_player.id).unwrap();
        game.player_ready(y_player.id).unwrap();

        game = game.resolve_phase_start();

        assert!(game.player_by_id(x_player.id).unwrap().constructs[0].skill_on_cd(Skill::Stun).is_none());
        assert!(game.player_by_id(y_player.id).unwrap().constructs[0].skill_on_cd(Skill::Block).is_none());
    }

    #[test]
    fn parry_test() {
        let mut game = create_test_game();

        let x_player = game.players[0].clone();
        let y_player = game.players[1].clone();

        let x_construct = x_player.constructs[0].clone();
        let y_construct = y_player.constructs[0].clone();

        while game.construct_by_id(y_construct.id).unwrap().skill_on_cd(Skill::Stun).is_some() {
            game.construct_by_id(y_construct.id).unwrap().reduce_cooldowns();
        }

        while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::ParryI).is_some() {
            game.construct_by_id(x_construct.id).unwrap().reduce_cooldowns();
        }

        game.add_skill(x_player.id, x_construct.id, None, Skill::ParryI).unwrap();
        game.add_skill(y_player.id, y_construct.id, Some(x_construct.id), Skill::Stun).unwrap();

        game.player_ready(x_player.id).unwrap();
        game.player_ready(y_player.id).unwrap();

        game = game.resolve_phase_start();

        // should not be stunned because of parry
        assert!(game.player_by_id(x_player.id).unwrap().constructs[0].is_stunned() == false);
        // riposte
        assert_eq!(game.player_by_id(y_player.id).unwrap().constructs[0].green_life(), (1024 - x_construct.red_power().pct(Skill::RiposteI.multiplier())));
    }

    #[test]
    fn corrupt_test() {
        let mut game = create_test_game();

        let x_player = game.players[0].clone();
        let y_player = game.players[1].clone();

        let x_construct = x_player.constructs[0].clone();
        let y_construct = y_player.constructs[0].clone();

        game.construct_by_id(x_construct.id).unwrap().learn_mut(Skill::CorruptI);

        while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::CorruptI).is_some() {
            game.construct_by_id(x_construct.id).unwrap().reduce_cooldowns();
        }

        // apply buff
        game.add_skill(x_player.id, x_construct.id, None, Skill::CorruptI).unwrap();
        game.player_ready(x_player.id).unwrap();
        game.player_ready(y_player.id).unwrap();
        game = game.resolve_phase_start();
        assert!(game.construct_by_id(x_construct.id).unwrap().affected(Effect::Corrupt));

        // attack and receive debuff
        game.add_skill(y_player.id, y_construct.id, Some(x_construct.id), Skill::Attack).unwrap();
        game.player_ready(x_player.id).unwrap();
        game.player_ready(y_player.id).unwrap();
        game = game.resolve_phase_start();

        assert!(game.construct_by_id(y_construct.id).unwrap().affected(Effect::Corruption));
    }

    #[test]
    fn scatter_test() {
        let mut game = create_test_game();

        let x_player = game.players[0].clone();
        let y_player = game.players[1].clone();

        let x_construct = x_player.constructs[0].clone();
        let y_construct = y_player.constructs[0].clone();

        game.construct_by_id(x_construct.id).unwrap().learn_mut(Skill::ScatterI);

        while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::ScatterI).is_some() {
            game.construct_by_id(x_construct.id).unwrap().reduce_cooldowns();
        }

        // apply buff
        game.add_skill(x_player.id, x_construct.id, Some(y_construct.id), Skill::ScatterI).unwrap();
        game.player_ready(x_player.id).unwrap();
        game.player_ready(y_player.id).unwrap();
        game = game.resolve_phase_start();
        assert!(game.construct_by_id(x_construct.id).unwrap().affected(Effect::Scatter));

        let Resolution { source: _, target: _, event, stages: _ } = game.resolved.pop().unwrap();
        match event {
            Event::Effect { effect, skill: _, duration: _, construct_effects: _ } => assert_eq!(effect, Effect::Scatter),
            _ => panic!("not siphon"),
        };

        let Resolution { source: _, target: _, event, stages: _ } = game.resolved.pop().unwrap();
        match event {
            Event::Recharge { red: _, blue: _, skill: _ } => (),
            _ => panic!("scatter result was not recharge"),
        }

        // attack and receive scatter hit
        game.add_skill(y_player.id, y_construct.id, Some(x_construct.id), Skill::Attack).unwrap();
        game.player_ready(x_player.id).unwrap();
        game.player_ready(y_player.id).unwrap();
        game = game.resolve_phase_start();

        let Resolution { source: _, target, event, stages: _ } = game.resolved.pop().unwrap();
        assert_eq!(target.id, y_construct.id);
        match event {
            Event::Damage { amount, skill: _, mitigation: _, colour: _} =>
                assert_eq!(amount, 256.pct(Skill::Attack.multiplier()) >> 1),
            _ => panic!("not damage scatter"),
        };
    }

    // #[test]
    // fn hatred_test() {
    //     let mut game = create_test_game();

    //     let x_player = game.players[0].clone();
    //     let y_player = game.players[1].clone();

    //     let x_construct = x_player.constructs[0].clone();
    //     let y_construct = y_player.constructs[0].clone();

    //     game.construct_by_id(x_construct.id).unwrap().learn_mut(Skill::Hostility);

    //     while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::Hostility).is_some() {
    //         game.construct_by_id(x_construct.id).unwrap().reduce_cooldowns();
    //     }

    //     // apply buff
    //     game.add_skill(x_player.id, x_construct.id, Some(x_construct.id), Skill::Hostility).unwrap();
    //     game.player_ready(x_player.id).unwrap();
    //     game.player_ready(y_player.id).unwrap();
    //     game = game.resolve_phase_start();
    //     assert!(game.construct_by_id(x_construct.id).unwrap().affected(Effect::Hostility));

    //     // attack and receive debuff
    //     game.add_skill(y_player.id, y_construct.id, Some(x_construct.id), Skill::TestAttack).unwrap();
    //     game.player_ready(x_player.id).unwrap();
    //     game.player_ready(y_player.id).unwrap();
    //     game = game.resolve_phase_start();

    //     info!("{:#?}", game);
    //     assert!(game.construct_by_id(y_construct.id).unwrap().affected(Effect::Hatred));
    // }

    #[test]
    fn aoe_test() {
        let mut game = create_2v2_test_game();

        let i_player = game.players[0].clone();
        let x_player = game.players[1].clone();

        let i_construct = i_player.constructs[0].clone();
        let j_construct = i_player.constructs[1].clone();
        let x_construct = x_player.constructs[0].clone();
        let y_construct = x_player.constructs[1].clone();

        game.construct_by_id(x_construct.id).unwrap().learn_mut(Skill::RuinI);

        while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::RuinI).is_some() {
            game.construct_by_id(x_construct.id).unwrap().reduce_cooldowns();
        }

        game.add_skill(i_player.id, i_construct.id, Some(x_construct.id), Skill::Attack).unwrap();
        game.add_skill(i_player.id, j_construct.id, Some(x_construct.id), Skill::Attack).unwrap();
        game.add_skill(x_player.id, x_construct.id, Some(i_construct.id), Skill::RuinI).unwrap();
        game.add_skill(x_player.id, y_construct.id, Some(i_construct.id), Skill::Attack).unwrap();

        game.player_ready(i_player.id).unwrap();
        game.player_ready(x_player.id).unwrap();

        assert!(game.skill_phase_finished());
        game = game.resolve_phase_start();
        let ruins = game.resolved
            .into_iter()
            .filter(|r| {
                let Resolution { source, target: _, event, stages: _ } = r;
                match source.id == x_construct.id {
                    true => match event {
                        Event::Effect { effect, duration, skill: _, construct_effects: _ } => {
                            assert!(*effect == Effect::Stun);
                            assert!(*duration == 1);
                            true
                        },
                        Event::Skill { skill: _ } => false,
                        _ => panic!("ruin result not effect {:?}", event),
                    }
                    false => false,
                }
            })
            .count();

        assert!(ruins == 2);
    }

    #[test]
    fn taunt_test() {
        let mut game = create_2v2_test_game();

        let i_player = game.players[0].clone();
        let x_player = game.players[1].clone();

        let i_construct = i_player.constructs[0].clone();
        let j_construct = i_player.constructs[1].clone();
        let x_construct = x_player.constructs[0].clone();
        let y_construct = x_player.constructs[1].clone();

        game.construct_by_id(x_construct.id).unwrap().learn_mut(Skill::TauntI);

        while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::TauntI).is_some() {
            game.construct_by_id(x_construct.id).unwrap().reduce_cooldowns();
        }

        game.add_skill(i_player.id, i_construct.id, Some(x_construct.id), Skill::Attack).unwrap();
        game.add_skill(i_player.id, j_construct.id, Some(x_construct.id), Skill::Attack).unwrap();
        game.add_skill(x_player.id, x_construct.id, Some(i_construct.id), Skill::TauntI).unwrap();
        game.add_skill(x_player.id, y_construct.id, Some(i_construct.id), Skill::Attack).unwrap();

        game.player_ready(i_player.id).unwrap();
        game.player_ready(x_player.id).unwrap();

        game = game.resolve_phase_start();

        assert!(game.resolved.len() == 5);
        while let Some(r) = game.resolved.pop() {
            let Resolution { source , target, event: _,  stages: _ } = r;
            if [i_construct.id, j_construct.id].contains(&source.id) {
                assert!(target.id == x_construct.id);
            }
        }
    }

    #[test]
    fn ko_pve_test() {
        let mut game = create_2v2_test_game();

        let i_player = game.players[0].clone();
        let x_player = game.players[1].clone();

        let i_construct = i_player.constructs[0].clone();
        let j_construct = i_player.constructs[1].clone();
        let x_construct = x_player.constructs[0].clone();
        let y_construct = x_player.constructs[1].clone();

        game.add_skill(i_player.id, i_construct.id, Some(x_construct.id), Skill::Attack).unwrap();
        game.add_skill(i_player.id, j_construct.id, Some(x_construct.id), Skill::Attack).unwrap();
        game.add_skill(x_player.id, x_construct.id, Some(i_construct.id), Skill::Attack).unwrap();
        game.add_skill(x_player.id, y_construct.id, Some(i_construct.id), Skill::Attack).unwrap();

        game.player_ready(i_player.id).unwrap();
        game.player_ready(x_player.id).unwrap();

        assert!(game.skill_phase_finished());
        game = game.resolve_phase_start();

        assert!([Phase::Skill, Phase::Finish].contains(&game.phase));

        // kill a construct
        game.player_by_id(i_player.id).unwrap().construct_by_id(i_construct.id).unwrap().green_life.reduce(u64::max_value());

        assert!(game.player_by_id(i_player.id).unwrap().skills_required() == 1);
        assert!(game.player_by_id(x_player.id).unwrap().skills_required() == 2);

        // add some more skills
        game.add_skill(i_player.id, j_construct.id, Some(x_construct.id), Skill::Attack).unwrap();
        game.add_skill(x_player.id, x_construct.id, Some(j_construct.id), Skill::Attack).unwrap();
        game.add_skill(x_player.id, y_construct.id, Some(j_construct.id), Skill::Attack).unwrap();
        assert!(game.add_skill(x_player.id, x_construct.id, Some(i_construct.id), Skill::Attack).is_err());

        game.player_ready(i_player.id).unwrap();
        game.player_ready(x_player.id).unwrap();

        assert!(game.skill_phase_finished());
        game = game.resolve_phase_start();

        assert!(game.player_by_id(i_player.id).unwrap().skills_required() == 1);
        assert!(game.player_by_id(x_player.id).unwrap().skills_required() == 2);
        return;
    }

    #[test]
    fn tick_removal_test() {
        let mut game = create_test_game();

        let x_player = game.players[0].clone();
        let y_player = game.players[1].clone();

        let x_construct = x_player.constructs[0].clone();
        let y_construct = y_player.constructs[0].clone();

        // make the purify construct super fast so it beats out decay
        game.construct_by_id(y_construct.id).unwrap().speed.force(10000000);

        game.construct_by_id(x_construct.id).unwrap().learn_mut(Skill::DecayI);
        while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::DecayI).is_some() {
            game.construct_by_id(x_construct.id).unwrap().reduce_cooldowns();
        }

        game.construct_by_id(x_construct.id).unwrap().learn_mut(Skill::SiphonI);
        while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::SiphonI).is_some() {
            game.construct_by_id(x_construct.id).unwrap().reduce_cooldowns();
        }

        game.construct_by_id(y_construct.id).unwrap().learn_mut(Skill::PurifyI);
        while game.construct_by_id(y_construct.id).unwrap().skill_on_cd(Skill::PurifyI).is_some() {
            game.construct_by_id(y_construct.id).unwrap().reduce_cooldowns();
        }

        // apply buff
        game.add_skill(x_player.id, x_construct.id, Some(y_construct.id), Skill::DecayI).unwrap();
        game.player_ready(x_player.id).unwrap();
        game.player_ready(y_player.id).unwrap();
        game = game.resolve_phase_start();
        assert!(game.construct_by_id(y_construct.id).unwrap().affected(Effect::Decay));

        let Resolution { source: _, target: _, event, stages: _ } = game.resolved.pop().unwrap();
        match event {
            Event::Damage { amount: _, skill, mitigation: _, colour: _ } => assert_eq!(skill, Skill::DecayTickI),
            _ => panic!("not decay"),
        };

        game.resolved.clear();

        // remove
        game.add_skill(y_player.id, y_construct.id, Some(y_construct.id), Skill::PurifyI).unwrap();
        game.player_ready(x_player.id).unwrap();
        game.player_ready(y_player.id).unwrap();
        game = game.resolve_phase_start();

        while let Some(Resolution { source: _, target: _, event, stages: _ }) = game.resolved.pop() {
            match event {
                Event::Damage { amount: _, skill: _, mitigation: _, colour: _ } =>
                    panic!("{:?} damage event", event),
                _ => (),
            }
        };

        game.add_skill(y_player.id, x_construct.id, Some(y_construct.id), Skill::SiphonI).unwrap();
        game.player_ready(x_player.id).unwrap();
        game.player_ready(y_player.id).unwrap();
        game = game.resolve_phase_start();

        game.resolved.clear();

        game.add_skill(y_player.id, y_construct.id, Some(y_construct.id), Skill::PurifyI).unwrap();
        game.player_ready(x_player.id).unwrap();
        game.player_ready(y_player.id).unwrap();
        game = game.resolve_phase_start();

        while let Some(Resolution { source: _, target: _, event, stages: _ }) = game.resolved.pop() {
            match event {
                Event::Damage { amount: _, skill: _, mitigation: _, colour: _ } =>
                    panic!("{:#?} {:#?} damage event", game.resolved, event),
                _ => (),
            }
        };

    }

    #[test]
    fn upkeep_test() {
        let mut game = create_2v2_test_game();
        game.players[0].set_ready(true);
        game.phase_end = Utc::now().checked_sub_signed(Duration::seconds(61)).unwrap();
        game = game.upkeep();
        assert!(game.players[1].warnings == 1);
    }
}