jong/jong-line/src/reducers.rs

use std::time::Duration;

use log::{debug, trace};
use spacetimedb::{
    ReducerContext, ScheduleAt::Interval, Table as _, rand::seq::SliceRandom, reducer,
};

use crate::{
    reducers::hand::{discard_tile, discard_tile_private},
    tables::{
        DbTile, Lobby, LobbyTimer, PlayerClock, PlayerHand, Wall, bot, game_timer, lobby as _,
        player_clock, player_config, player_hand, tile, user, wall,
    },
};
use jong_types::{GameState, TurnState};

mod hand;
mod lobby;

#[reducer]
pub fn advance_game(ctx: &ReducerContext) -> Result<(), String> {
    let game_timer = ctx
        .db
        .game_timer()
        .lobby_id()
        .find(
            ctx.db
                .user()
                .identity()
                .find(ctx.sender())
                .ok_or("player not in lobby")?
                .lobby_id,
        )
        .ok_or("no such lobby")?;

    advance_game_private(ctx, game_timer)
}

fn shuffle_wall(ctx: &ReducerContext, lobby: &mut Lobby) {
    let tiles = {
        let mut rng = ctx.rng();
        let mut wall: Vec<_> = jong_types::tiles::tiles()
            .into_iter()
            .map(|tile| ctx.db.tile().insert(DbTile { id: 0, tile }))
            .collect();
        wall.shuffle(&mut rng);
        wall
    };
    ctx.db.wall().insert(Wall {
        lobby_id: lobby.id,
        tiles,
    });
    lobby.game_state = GameState::Deal;
}

fn deal_hands(ctx: &ReducerContext, lobby: &mut Lobby) -> Result<(), String> {
    let mut wall = ctx.db.wall().lobby_id().find(lobby.id).unwrap();
    for player in &lobby.players {
        let mut tiles = wall.tiles.split_off(wall.tiles.len() - 13);
        wall = ctx.db.wall().lobby_id().update(wall);
        tiles.sort_by_key(|t| t.tile);
        ctx.db.player_hand().insert(PlayerHand {
            player_id: *player,
            turn_state: TurnState::None,
            hand: tiles,
            pond: vec![],
            working_tile: None,
        });
    }
    lobby.game_state = jong_types::states::GameState::Play;

    Ok(())
}

#[reducer]
pub fn advance_game_private(
    ctx: &ReducerContext,
    mut game_timer: LobbyTimer,
) -> Result<(), String> {
    // checks every second (or more? when users make moves) on whether to advance the game's various states
    // TODO this, or allow player/debug to call this?

    if let Some(mut lobby) = ctx.db.lobby().id().find(game_timer.lobby_id) {
        // trace!("running schedule for lobby {}", lobby.id);
        match lobby.game_state {
            GameState::Setup => {
                // TODO reduce interval beforehand so we don't wait a second?
                // TODO keep a count to clear stale lobbies
                // trace!("shuffle wall");
                shuffle_wall(ctx, &mut lobby);

                lobby.players.shuffle(&mut ctx.rng());

                for player_id in lobby
                    .players
                    .iter()
                    .filter(|id| ctx.db.user().config_id().find(*id).is_some())
                {
                    ctx.db.player_clock().insert(PlayerClock {
                        player_id: *player_id,
                        renewable: 5,
                        total: 20,
                    });
                }

                ctx.db.lobby().id().update(lobby);
                advance_game_private(ctx, game_timer)?;
                return Ok(());
            }
            GameState::Deal => {
                // TODO reduce interval beforehand so this can animate?
                // TODO change loop to be per interval somehow?
                deal_hands(ctx, &mut lobby)?;
                ctx.db.lobby().id().update(lobby);
                advance_game_private(ctx, game_timer)?;
                return Ok(());
            }
            GameState::Play => {
                // trace!("in play");
                let curr_player = lobby.players.get(lobby.current_idx as usize).unwrap();
                let mut hand = ctx.db.player_hand().player_id().find(curr_player).unwrap();
                match hand.turn_state {
                    TurnState::None => {
                        // trace!("draw a tile");
                        if let Some(mut wall) = ctx.db.wall().lobby_id().find(lobby.id)
                            && let Some(tile) = wall.tiles.pop()
                        {
                            hand.working_tile = Some(tile);
                            hand.turn_state = TurnState::Tsumo;
                            ctx.db.wall().lobby_id().update(wall);
                            ctx.db.player_hand().player_id().update(hand);
                        } else {
                            // TODO out of tiles
                            todo!()
                        }
                    }
                    TurnState::Tsumo => {
                        // only real players have clocks?
                        if let Some(mut clock) = ctx.db.player_clock().player_id().find(curr_player)
                            && clock.tick()
                        {
                            ctx.db.player_clock().player_id().update(clock);
                        } else {
                            // TODO bot / auto discard
                            discard_tile_private(
                                ctx,
                                lobby.id,
                                ctx.db.player_config().id().find(curr_player).unwrap(),
                                hand.working_tile.unwrap().id,
                            )
                            .unwrap();
                            return Ok(());
                        }
                    }
                    TurnState::Menzen => {}
                    TurnState::RiichiKan => {}
                    TurnState::RonChiiPonKan => {}
                    TurnState::End => {}
                }
            }
            GameState::Exit => {
                // ctx.db.game_timer().id().delete(game_timer.id);
                // ctx.db.lobby().id().delete(lobby.id);
                // TODO reset all player lobbies, delete bots, etc?
                // is there a way to do this automatically, or rely on elsewhere's checks clearing the state?
                todo!("lobby exit cleanup")
            }

            // TODO handle stale lobbies
            // TODO should this delete the timer?
            _ => Err(format!("lobby {} in impossible state", lobby.id))?,
        }

        // ctx.db.game_timer().id().update(game_timer);
        ctx.db.lobby().id().update(lobby);
    } else {
        // ctx.db.game_timer().id().delete(game_timer.id);
        Err(format!(
            "ran schedule {} for empty lobby {}",
            game_timer.scheduled_id, game_timer.lobby_id
        ))?;
    }

    Ok(())
}

impl PlayerClock {
    fn tick(&mut self) -> bool {
        if self.renewable > 0 {
            self.renewable -= 1;
            true
        } else if self.total > 0 {
            self.total -= 1;
            true
        } else {
            false
        }
    }

    fn renew(&mut self) {
        self.renewable = 5;
    }
}

impl Lobby {
    fn next_player(&mut self) {
        if self.current_idx + 1 >= 4 {
            self.current_idx = 0
        } else {
            self.current_idx += 1;
        }
    }
}