net.rs

use serde::{Deserialize, Serialize};

use crate::{Action, GameOutcome, GameState, Team};

pub type UserId = u32;
pub type ChallengeId = u32;
pub type GameId = u32;

#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct User {
    pub id: UserId,
    pub name: String,
}

#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Challenge {
    pub id: ChallengeId,
    pub source: User,
    pub target: User,
}

#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase", tag = "kind")]
pub enum Player {
    Human { id: UserId, name: String },
    Bot { name: String },
}

impl Player {
    #[must_use]
    pub fn human(user: User) -> Self {
        Self::Human {
            id: user.id,
            name: user.name,
        }
    }

    #[must_use]
    pub fn bot(name: impl Into<String>) -> Self {
        Self::Bot { name: name.into() }
    }

    #[must_use]
    pub fn name(&self) -> &str {
        match self {
            Self::Human { name, .. } | Self::Bot { name } => name,
        }
    }

    #[must_use]
    pub const fn user_id(&self) -> Option<UserId> {
        match self {
            Self::Human { id, .. } => Some(*id),
            Self::Bot { .. } => None,
        }
    }

    #[must_use]
    pub const fn is_bot(&self) -> bool {
        matches!(self, Self::Bot { .. })
    }
}

#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BotEvaluation {
    /// Score in centibots from White's perspective: +100 is about one bot for White.
    pub white_score: i32,
    /// Forced mate distance in moves by the winning side, positive for White and negative for Black.
    #[serde(default)]
    pub mate_in: Option<i16>,
}

#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BotEvaluations {
    pub white: Option<BotEvaluation>,
    pub black: Option<BotEvaluation>,
}

impl BotEvaluations {
    #[must_use]
    pub const fn get(&self, team: Team) -> Option<BotEvaluation> {
        match team {
            Team::White => self.white,
            Team::Black => self.black,
        }
    }

    pub fn set(&mut self, team: Team, evaluation: BotEvaluation) {
        match team {
            Team::White => self.white = Some(evaluation),
            Team::Black => self.black = Some(evaluation),
        }
    }
}

#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Game {
    pub id: GameId,
    pub revision: u32,
    pub white: Player,
    pub black: Player,
    pub bot_evaluations: BotEvaluations,
    pub state: GameState,
    pub outcome: Option<GameOutcome>,
}

#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase", tag = "type")]
pub enum ClientMessage {
    Handshake { name: String },
    SendChallenge { target_id: UserId },
    AcceptChallenge { challenge_id: ChallengeId },
    StartBotMatch,
    LeaveGame { game_id: GameId },
    GameAction { action: Action },
    Quit,
}

#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase", tag = "type")]
pub enum ServerMessage {
    Welcome {
        user_id: UserId,
    },
    Lobby {
        users: Vec<User>,
        challenges: Vec<Challenge>,
    },
    Game {
        game: Game,
    },
    BotThinking {
        game_id: GameId,
        team: crate::Team,
        budget_ms: u64,
    },
    Error {
        message: String,
    },
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::Pos;

    #[test]
    fn client_messages_are_readable_tagged_json() {
        let message = ClientMessage::GameAction {
            action: Action::move_bots(Pos::new(0, 1), Pos::new(0, 2), 1),
        };

        let json = serde_json::to_value(&message).unwrap();

        assert_eq!(json["type"], "gameAction");
        assert_eq!(json["action"]["source"]["x"], 0);
        assert_eq!(json["action"]["target"]["y"], 2);
        assert_eq!(json["action"]["count"], 1);
        assert_eq!(
            serde_json::from_value::<ClientMessage>(json).unwrap(),
            message
        );
    }

    #[test]
    fn lobby_messages_use_named_fields_instead_of_tuple_data() {
        let message = ServerMessage::Lobby {
            users: vec![User {
                id: 7,
                name: "Ada".into(),
            }],
            challenges: Vec::new(),
        };

        let json = serde_json::to_value(&message).unwrap();

        assert_eq!(json["type"], "lobby");
        assert_eq!(json["users"][0]["name"], "Ada");
        assert!(json.get("data").is_none());
    }

    #[test]
    fn bot_match_messages_and_players_have_explicit_types() {
        let start = serde_json::to_value(ClientMessage::StartBotMatch).unwrap();
        assert_eq!(start, serde_json::json!({ "type": "startBotMatch" }));

        let player = Player::bot("Atlas");
        let json = serde_json::to_value(&player).unwrap();
        assert_eq!(json, serde_json::json!({ "kind": "bot", "name": "Atlas" }));
        assert!(player.is_bot());
        assert_eq!(player.user_id(), None);

        let evaluation = BotEvaluations {
            white: Some(BotEvaluation {
                white_score: 100,
                mate_in: None,
            }),
            black: Some(BotEvaluation {
                white_score: -999_985,
                mate_in: Some(-8),
            }),
        };
        assert_eq!(
            serde_json::to_value(evaluation).unwrap(),
            serde_json::json!({
                "white": { "whiteScore": 100, "mateIn": null },
                "black": { "whiteScore": -999985, "mateIn": -8 }
            })
        );
    }
}