# Repository Guidelines

## Project Structure & Module Organization
- Root cargo workspace lives at `Cargo.toml`; shared library code sits in `src/`.
- Game logic is split per module (`src/rps.rs`, `src/spoof.rs`, `src/soviet.rs`, etc.) and all implement the `Game` trait in `src/game.rs`.
- Binary entry points reside in `src/main.rs` (production bot) and `src/bin/game_cli.rs` (CLI harness).
- Inline unit tests live next to their modules under `#[cfg(test)]`; no standalone `tests/` directory is used currently.
- Persistence data (`game_state.toml`) is emitted at runtime beside the binary; keep it out of version control.

## Build, Test, and Development Commands
- `cargo check` — Fast validation of current changes without generating binaries.
- `cargo test` — Execute all unit and integration tests; run before every commit.
- `cargo run --bin pravda` — Launch the async bot (requires network credentials and Mastodon config).
- `cargo run --bin game_cli` — Start the offline game CLI for rapid manual experimentation.
- `cargo fmt` / `cargo clippy` — Apply Rustfmt formatting and run static analysis; fix or suppress warnings before review.

## Coding Style & Naming Conventions
- Follow idiomatic Rust: four-space indentation, `snake_case` for functions/variables, `CamelCase` for types.
- Derive serde traits when persisting state; favor `Value::try_from` over deprecated helpers.
- Keep modules focused on one game; common utilities belong in `src/game.rs` or shared helpers.
- Document surprising control flow with short comments; avoid redundant commentary on obvious code paths.

## Testing Guidelines
- Tests use Rust’s built-in framework via `#[test]` and `tokio::test`; mirror existing naming (`test_*` or descriptive phrases).
- When adding async behaviour, prefer deterministic unit tests over integration tests.
- Reproduce concurrency scenarios with helper functions already present in the module (for example `command()` in `rps::test`).
- Ensure persisted state types implement `Serialize`/`Deserialize` and are covered by round-trip tests when changed.

## Commit & Pull Request Guidelines
- Keep commits atomic; reference the affected game in the message (e.g. `Update soviet persistence handling`).
- Use Fossil for version control: `FOSSIL_HOME=.fossil-home fossil commit --nosync --nosign -m "<imperative summary>"`.
- Include test evidence in PR descriptions (`cargo test`, manual CLI run). Attach reproduction steps for bug fixes.
- Link related issues or tickets, and call out configuration changes (OAuth keys, state-file schema) explicitly to alert deployers.

futures-util = { default-features = false, version = "0.3" }
nanohtml2text = "0.1.4"
regex = { default-features = false, version = "1.10.0" }
tokio-util = "0.7.9"

mastodon-async = { version = "1.3.1", features = ["toml", "mt", "rustls-tls"], default-features = false }
once_cell = "1.18.0"
reqwest = { version = "0.11.22", default_features = false, features = ["rustls-tls"]}
reqwest = { version = "0.11.22", default-features = false, features = ["rustls-tls"]}
rand = "0.8.5"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
toml = "0.8"
tokio-tungstenite = { version = "0.21", default-features = false, features = ["rustls-tls-webpki-roots", "connect"] }
url = "2.5"

# The following lines are optimising for a small binary, given a bot spends most of its time idling in RAM.
[profile.release]
strip = true
opt-level = "z"
lto = true
codegen-units = 1

## Pravda: social games for a social network.

This crate is a functional bot that you can use to connect to a mastodon server (or one providing a similar API) in order to run social games. For now it can be used to play *Rock, Paper, Scissors*, or roll dice. The code is written modularly so that it is relatively easy to add new games.
Pravda is a Mastodon bot that runs social deduction and party games. It
connects to any Mastodon-compatible instance, listens for mentions, and routes
commands to a catalogue of games implemented as pluggable state machines.

The Game trait defines the behaviour for a game, involving an associated method *new* for setup, and a method *next* which receives user toots and is responsible to advance the state of the game. Every game receives every message and must be able to discard anything that is irrelevant to it.
Out of the box the bot supports:

There are some constants to shut down the bot remotely with a toot. *ADMIN* contains the administrative account, *QUIT* contains the quit message which must be sent as a mention to the bot, and *INSTANCE* contains the URL of the instance to connect to. At the moment, it uses my own fedi account by default, and the message *!QUIT!* but you should customise this if you deploy. The default instance is botsin.space, an appropriate instance for bots, but you should change this if you want to run it somewhere else.
- **Rock, Paper, Scissors** – quick duels with private moves and public results.
- **Spoof** – hidden-coin guessing with timed reminders.
- **Dice** – flexible NdM style dice rolling (`dice`, `dice 3`, `dice 2d12`).
- **Unique Lowest Bid** – sealed-bid auction where the lowest unique bid wins.
- **Two Thirds Average** – players try to guess two-thirds of the group average.
- **Soviet Mafia** – a fully themed social deduction game with roles such as
  workers, saboteurs, commissars, spies, and more.

Bear in mind you must have a valid account on the instance before you attempt to authorise the bot.
All games implement the shared `Game` trait (`src/game.rs`), receiving every
incoming command and returning a `Reply` that includes text plus visibility
(a.k.a. public vs. DM). The runtime fans out commands to each game, and the
game decides whether to react or ignore the input. This makes it easy to add
new games without touching the bot core; just register them in
`src/catalog.rs` so they are constructed at startup.

### First run.
### Getting Started

Decide where you want to execute the game, and make sure you have write permissions. The game will connect to an instance and attempt to establish an OAuth flow, asking you to visit a link and authorise the application with your mastodon/fedi account.

1. Install Rust and clone this repository.
Once this is done, the information is written into a toml file, which *should* remain private, as it contains a token that allows for almost full control of the account it's authorised under.

2. Run `cargo run --bin game_cli` to exercise the games locally via stdin.
On subsequent runs, if this file is encountered, the information will be read from it and the connection will be realised without human intervention.
   The CLI harness accepts input in the form `acct@example.com: command` and
   prints bot responses, which is helpful for development.
3. To connect to Mastodon, ensure you have an account on your target instance
   and execute `cargo run --bin pravda`. The first run walks you through the
   OAuth flow and stores credentials in `mastodon-data.toml` (keep it private).
4. Update `ADMIN`, `QUIT`, and `INSTANCE` in `src/main.rs` to match your desired
   deployment values before going live.

### Limitations.
### Development Workflow

It is not possible to connect this client to GoTosocial for now. mastodon-async does not use the websocket endpoint to stream from the fedi, but the SSE endpoint instead. GoToSocial only implements the websocket endpoint for streaming operations.

- Run `cargo fmt` and `cargo clippy --all-targets` to keep formatting and
Naturally, it supports both HTTP and HTTPS, through the use of rustls-tls by default. You can change to OpenSSL by modifying the features in Cargo.toml.
  lints tidy.
- Execute `cargo test` before committing. Unit tests sit next to the modules
  they exercise.
- Use `cargo run --bin game_cli` for fast manual testing; most command flows can
  be simulated locally without touching the network.

### Future ambitions.
### Security & Operational Notes

I'm interested in implementing any sort of social game, by which I understand games which involve social interaction, deception, prediction, or the like. In particular, I am interested in implementing the following games:
- Outbound statuses are normalised and truncated before posting; nevertheless,
  run the bot from a dedicated account with scoped tokens (read:notifications,
  write:statuses, follow).
- The bot ignores mentions originating from itself to avoid event loops.
- When adding new games, sanitise any user-controlled text before including it
  in replies.

### Extending Pravda
* [Spoof](https://en.wikipedia.org/wiki/Spoof_(game\)) (in progress on the spoof branch).

* [Prisoner's dilemma](https://en.wikipedia.org/wiki/Prisoner%27s_dilemma).
* [Centipede game](https://en.wikipedia.org/wiki/Centipede_game).
* [Public goods game](https://en.wikipedia.org/wiki/Public_goods_game).
* [Traveller's dilemma](https://en.wikipedia.org/wiki/Traveler%27s_dilemma).
* [Ultimatum game](https://en.wikipedia.org/wiki/Ultimatum_game).
* [Dictator game](https://en.wikipedia.org/wiki/Dictator_game)
* [Mafia](https://en.wikipedia.org/wiki/Mafia_(party_game\)).
* Unique lowest bid.
To create a new game:

1. Add a module under `src/` that implements `Game`.
2. Register it in `src/catalog.rs::default_games` so both the bot and CLI know
   about it.
* Guess 2/3 the average.
* Predict the judgement.
3. Emit appropriate replies via the provided `Reply` type. If you need timers,
   schedule your own tasks and cancel them when the game ends (see
   `src/soviet.rs` for an example).
4. Document the commands in this README so players know how to interact.

Some of these games need more interesting names.
Unit tests live alongside their games. Existing tests illustrate how to drive
command sequences without Mastodon.

It would be nice to run a nomic on the fedi, but that is a lot more than a bot can do by itself.
### Planned Work

## Bug reports, feature requests, code contributions and other feedback.
- Balance tuning for the Soviet Mafia roles and better test coverage for
  probabilistic flows.
- Additional social experiments such as Prisoner's Dilemma, Centipede, and
  Nomic-style rule systems.

If you want to tell me something about the crate, the best ways are:
### Support & Feedback

* My fedi account, [@modulux@node.isonomia.net](https://node.isonomia.net/@modulux).
* The [fossil repository](https://modulus.isonomia.net/pravda.cgi) for the project.
* If you must, email me at modulus at isonomia dot net.
- Mastodon: [@modulux@node.isonomia.net](https://node.isonomia.net/@modulux)
- Fossil repo: <https://modulus.isonomia.net/pravda.cgi>
- Email: modulus at isonomia dot net

## Change log.
### Changelog

* Unreleased
  * Added Unique Lowest Bid, Two Thirds Average, and Soviet Mafia games.
  * Hardened outbound post handling and added a shared game manager.
* V 0.2.0: Spoof is implemented.
* V0.2.0 – Spoof
* V 0.1.3: dice can be rolled with the dice command, accepting an ndm optional parameter.
* V 0.1.2: exponential backoff system for cases where the streaming API fails. Assorted typographical corrections.
* V 0.1.1: set a loop around the toot streaming in case it errors out.
* V 0.1.0: initial release.
* V0.1.3 – Dice roll command (`dice`, `dice NdM`)
* V0.1.2 – Streaming backoff and assorted fixes
* V0.1.1 – Wrapped streaming in retry loop
* V0.1.0 – Initial release

use mastodon_async::Visibility;
use pravda::game::{Command, Game, GameEvent, PlayerCommand, Reply};
use pravda::{catalog, CancellationToken};
use std::error::Error;
use std::io::{self, BufRead};
use std::thread;
use tokio::sync::mpsc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let token = CancellationToken::new();
    let (sender, mut receiver) = mpsc::unbounded_channel();
    let (input_tx, mut input_rx) = mpsc::unbounded_channel();
    thread::spawn(move || {
        let stdin = io::stdin();
        let mut handle = stdin.lock();
        let mut buffer = String::new();
        loop {
            buffer.clear();
            match handle.read_line(&mut buffer) {
                Ok(0) => break,
                Ok(_) => {
                    let line = buffer.trim_end_matches(['\n', '\r']).to_string();
                    if input_tx.send(line).is_err() {
                        break;
                    }
                }
                Err(_) => break,
            }
        }
    });
    let mut games: Vec<Box<dyn Game>> = catalog::default_games(&sender, &token);

    println!("Pravda CLI test harness");
    println!("Enter '<acct>: <command>'. Commands: rps, spoof, ulb, twothirds, dice, etc. Type 'quit' to exit.");

    loop {
        tokio::select! {
            event = receiver.recv() => {
                if let Some(event) = event {
                    handle_event(event, &mut games);
                } else {
                    break;
                }
            }
            input = input_rx.recv() => {
                if let Some(input) = input {
                    if input.trim().eq_ignore_ascii_case("quit") {
                        break;
                    }
                    if let Some((sender_id, content)) = input.split_once(':') {
                        let sender = sender_id.trim().to_string();
                        if sender.is_empty() {
                            println!("Please provide a sender before the colon.");
                            continue;
                        }
                        let content = content.trim().to_lowercase();
                        if content.is_empty() {
                            println!("Please provide a command after the colon.");
                            continue;
                        }
                        if content == "help" {
                            let mut reply = Reply::new();
                            reply.push(
                                "Available games: rps, spoof, dice, unique lowest bid (ulb), two-thirds average, soviet.".
                                    to_string(),
                            );
                            reply.push(
                                "Join with commands like 'spoof', 'rps', 'ulb', 'twothirds', 'dice', or 'soviet'.".
                                    to_string(),
                            );
                            reply.push(
                                "For detailed rules, ask '<game> help' (for example 'soviet help').".to_string(),
                            );
                            display_reply(&sender, reply);
                            continue;
                        }
                        let player_command = PlayerCommand { sender: sender.clone(), content };
                        for game in games.iter_mut() {
                            let reply = game.next(&Command::PlayerCommand(&player_command));
                            display_reply(&sender, reply);
                        }
                    } else {
                        println!("Invalid input. Use '<acct>: <command>'.");
                    }
                } else {
                    break;
                }
            }
        }
    }

    println!("Goodbye");
    Ok(())
}

fn handle_event(event: GameEvent, games: &mut [Box<dyn Game>]) {
    match event {
        GameEvent::Reply(reply) => display_reply("system", reply),
        GameEvent::Step(internal) => {
            for game in games.iter_mut() {
                let reply = game.next(&Command::InternalCommand(internal.clone()));
                display_reply("system", reply);
            }
        }
        GameEvent::Persist => {}
        GameEvent::Notification(_) => {}
    }
}

fn display_reply(source: &str, reply: Reply) {
    if reply.0.is_empty() {
        return;
    }
    let visibility = reply.1;
    for message in reply.0 {
        match visibility {
            Visibility::Direct => println!("[DM][{}] {}", source, message),
            _ => println!("[{}] {}", source, message),
        }
    }
}

use crate::game::{Game, GameEvent};
use crate::{dice, rps, soviet, spoof, twothirds, unique};
use tokio::sync::mpsc;
use tokio_util::sync::CancellationToken;

/// Construct the default catalogue of games wired into the bot.
///
/// Every game receives a cloned sender and cancellation token so they can
/// schedule internal events and react to shutdown signals without touching the
/// caller's resources.
pub fn default_games(
    sender: &mpsc::UnboundedSender<GameEvent>,
    token: &CancellationToken,
) -> Vec<Box<dyn Game>> {
    vec![
        Box::new(rps::Rps::new(sender.clone(), token.clone())),
        Box::new(spoof::Spoof::new(sender.clone(), token.clone())),
        Box::new(dice::Dice::new(sender.clone(), token.clone())),
        Box::new(unique::UniqueLowestBid::new(sender.clone(), token.clone())),
        Box::new(twothirds::TwoThirdsAverage::new(
            sender.clone(),
            token.clone(),
        )),
        Box::new(soviet::SovietMafia::new(sender.clone(), token.clone())),
    ]
}

#[cfg(test)]
mod tests {
    use super::default_games;
    use crate::game::{Command, GameEvent, PlayerCommand};
    use tokio::sync::mpsc;
    use tokio_util::sync::CancellationToken;

    fn dispatch(
        games: &mut [Box<dyn crate::game::Game>],
        sender: &str,
        content: &str,
    ) -> Vec<(String, crate::game::Reply)> {
        let player_command = PlayerCommand {
            sender: sender.to_string(),
            content: content.to_string(),
        };
        let command = Command::PlayerCommand(&player_command);
        games
            .iter_mut()
            .map(|game| {
                let name = game.name().to_string();
                let reply = game.next(&command);
                (name, reply)
            })
            .collect()
    }

    fn test_catalog() -> Vec<Box<dyn super::Game>> {
        let (sender, _receiver) = mpsc::unbounded_channel::<GameEvent>();
        let token = CancellationToken::new();
        default_games(&sender, &token)
    }

    #[test]
    fn rps_flow_via_catalog() {
        let mut games = test_catalog();

        let first = dispatch(&mut games, "alice@example.org", "rps");
        let active: Vec<_> = first
            .iter()
            .filter(|(_, reply)| !reply.0.is_empty())
            .collect();
        assert_eq!(
            active.len(),
            1,
            "Only RPS should respond to an rps join command"
        );
        let (_, join_reply) = active[0];
        assert!(join_reply
            .0
            .iter()
            .any(|line| line.contains("You've asked to join a game of Rock, Paper, Scissors")));

        let second = dispatch(&mut games, "bob@example.org", "rps");
        let active: Vec<_> = second
            .iter()
            .filter(|(_, reply)| !reply.0.is_empty())
            .collect();
        assert_eq!(
            active.len(),
            1,
            "Only RPS should respond when the second player joins"
        );
        let (_, start_reply) = active[0];
        assert!(start_reply
            .0
            .iter()
            .any(|line| line.contains("Got a partner!")));
    }

    #[test]
    fn dice_validation_via_catalog() {
        let mut games = test_catalog();
        let responses = dispatch(&mut games, "alice@example.org", "dice 0");
        let dice_reply = responses
            .iter()
            .find(|(name, _)| name == "dice")
            .expect("Dice game should be present");
        assert!(dice_reply
            .1
             .0
            .iter()
            .any(|line| line.contains("number of dice to throw must be at least 1")));
        assert!(
            responses
                .iter()
                .filter(|(_, reply)| !reply.0.is_empty())
                .all(|(name, _)| name == "dice"),
            "Only Dice should answer the invalid dice command"
        );
    }

    #[test]
    fn spoof_join_via_catalog() {
        let mut games = test_catalog();
        let responses = dispatch(&mut games, "carol@example.org", "spoof");
        let active: Vec<_> = responses
            .iter()
            .filter(|(_, reply)| !reply.0.is_empty())
            .collect();
        assert_eq!(
            active.len(),
            1,
            "Only Spoof should react to the spoof lobby command"
        );
        assert_eq!(active[0].0, "spoof");
        assert!(active[0]
            .1
             .0
            .iter()
            .any(|line| line.contains("waiting for a game of spoof")));
    }

    #[test]
    fn twothirds_join_via_catalog() {
        let mut games = test_catalog();
        let responses = dispatch(&mut games, "dave@example.org", "twothirds");
        let active: Vec<_> = responses
            .iter()
            .filter(|(_, reply)| !reply.0.is_empty())
            .collect();
        assert_eq!(
            active.len(),
            1,
            "Only Two Thirds should react to a twothirds join command"
        );
        assert_eq!(active[0].0, "twothirds");
        assert!(active[0]
            .1
             .0
            .iter()
            .any(|line| line.contains("waiting for a two-thirds game")));
    }

    #[test]
    fn unique_join_via_catalog() {
        let mut games = test_catalog();
        let responses = dispatch(&mut games, "erin@example.org", "ulb");
        let active: Vec<_> = responses
            .iter()
            .filter(|(_, reply)| !reply.0.is_empty())
            .collect();
        assert_eq!(
            active.len(),
            1,
            "Only Unique Lowest Bid should react to ulb"
        );
        assert_eq!(active[0].0, "unique");
        assert!(active[0]
            .1
             .0
            .iter()
            .any(|line| line.contains("waiting for a unique lowest bid")));
    }

    #[test]
    fn soviet_join_via_catalog() {
        let mut games = test_catalog();
        let responses = dispatch(&mut games, "frank@example.org", "soviet");
        let active: Vec<_> = responses
            .iter()
            .filter(|(_, reply)| !reply.0.is_empty())
            .collect();
        assert_eq!(
            active.len(),
            1,
            "Only Soviet should react to the soviet lobby command"
        );
        assert_eq!(active[0].0, "soviet");
        let body = &active[0].1 .0;
        assert!(body
            .iter()
            .any(|line| line.contains("You enlist to defend the revolution")));
        assert!(body.iter().any(|line| line.contains("comrades waiting")));
    }
}

use crate::game::{Command, Game, GameEvent, Reply};
use crate::{Lazy, Regex};
use rand::Rng;

pub struct Dice;

impl Game for Dice {
    fn new(
        _: tokio::sync::mpsc::UnboundedSender<GameEvent>,
        _: tokio_util::sync::CancellationToken,
    ) -> Self {
    Dice
        Dice
    }
    fn next(&mut self, m: &Command) -> Reply {
        let mut r = Reply::new();
        static DICE: Lazy<Regex> = Lazy::new(|| {
            Regex::new(r"^(?:dice|dado)(?: (\d+)(?:d(\d+))?)?$")
                .expect("Problem building dice regexp.")
        });

                    }
                }
                _ => {}
            }
        }
        r
    }
}

    fn name(&self) -> &'static str {
        "dice"
    }
}

use mastodon_async::Visibility;
/// This module contains the basic data structure of a game.
/// It's a trait that you can implement and create new games from.
/// Games are represented as state machines.

/// The game trait.
use toml::Value;
/// Core abstraction shared by every game implementation.
///
/// Games behave as state machines that consume commands and emit replies. The
/// trait keeps construction, stateless dispatch, and optional persistence in
/// one place so new games only need to worry about their own rules.
pub trait Game: Send {
    /// A static method to create a new game.
    fn new(
        c: tokio::sync::mpsc::UnboundedSender<GameEvent>,
        token: tokio_util::sync::CancellationToken,
    ) -> Self
    where
        Self: Sized;
    /// next is the state machine. It receives a Command  and gives back a Reply.
    /// Advance the state machine by feeding it a command and capturing the reply.
    fn next(&mut self, m: &Command) -> Reply;
    /// Name of the game, used for persistence.
    fn name(&self) -> &'static str;
    /// Serialize state to be persisted. Return None if the game is stateless.
    fn save_state(&self) -> Option<Value> {
        None
    }
    /// Restore state from persisted data.
    fn load_state(&mut self, _value: &Value) -> Result<(), String> {
        Ok(())
    }
}

/// A game response. For now just a vector of strings that must be tooted.
/// In order to allow private replies, it also contains a visibility.
#[derive(Debug)]
pub struct Reply(pub Vec<String>, pub Visibility);
impl Reply {
    pub fn new() -> Self {
        // By default, replies are sent as unlisted.
        Reply(Vec::new(), Visibility::Unlisted)
    }
    /// Append a new message to the reply payload.
    pub fn push(&mut self, s: String) {
        self.0.push(s);
    }
    /// Set visibility to direct messages.
    pub fn quiet(&mut self) {
        self.1 = Visibility::Direct;
    }
}

/// A command from a player: sender and content.
pub struct PlayerCommand {
    pub sender: String,
    pub content: String,
}

/// An internal command: contains the match it is for, and a string.
#[derive(Clone)]
pub struct InternalCommand {
    pub name: String,
    pub match_index: usize,
    pub command: String,
}

/// A game command.
pub enum Command<'a> {
    /// It may be a PlayerCommand.
    PlayerCommand(&'a PlayerCommand),
    /// Or an internal command to a specific match.
    InternalCommand(InternalCommand),
}

/// An event.
pub enum GameEvent {
    /// A response to send.
    Reply(Reply),
    /// Or an Internal Command..
    /// An internal command queued by a game itself to continue processing later.
    Step(InternalCommand),
    /// Or a fedi notification.
    Notification(crate::Notification),
    /// Request to persist the game state.
    Persist,
}

pub use mastodon_async::prelude::Notification;
pub use once_cell::sync::Lazy;
pub use regex::Regex;
pub use tokio_util::sync::CancellationToken;

pub mod catalog;
pub mod dice;
pub mod game;
pub mod rps;
pub mod soviet;
pub mod spoof;
pub mod twothirds;
pub mod unique;

use futures_util::TryStreamExt;
use game::{Command, Game, GameEvent, PlayerCommand};
use futures_util::{pin_mut, StreamExt, TryStreamExt};
use mastodon_async::entities::notification::Notification;
use mastodon_async::{
    entities::notification::NotificationType,
    helpers::{cli, toml},
    helpers::{cli, toml as mastodon_toml},
    prelude::*,
    Language, Result, StatusBuilder,
};
use once_cell::sync::Lazy;
use regex::Regex;
use reqwest::ClientBuilder;
use serde::{Deserialize, Serialize};
use std::cmp::min;
use std::{cmp::min, collections::HashMap, fs, path::Path};
use tokio::{
    select,
    sync::mpsc,
    time::{sleep, Duration},
};
use tokio_tungstenite::{connect_async, tungstenite::protocol::Message};
use tokio_util::sync::CancellationToken;
use url::{ParseError, Url};

mod dice;
mod game;
mod rps;
//mod spoof;
use pravda::catalog;
use pravda::game::{Command, Game, GameEvent, InternalCommand, PlayerCommand, Reply};
use pravda::{Lazy, Regex};
use toml::{self, Value};

/// Admin account. It can send administrative commands.
const ADMIN: &str = "modulux@node.isonomia.net";

/// Quit command.
const QUIT: &str = "!QUIT!";

/// Instance to connect to.
const INSTANCE: &str = "https://botsin.space";

const STATE_FILE: &str = "game_state.toml";

// Maximum backing off level in powers of 2 of seconds (default: 8 = 256 sec = about 4 min).
const MAX_BL: u8 = 8;

/// Clean a toot.
async fn clean(s: &str) -> String {
fn clean(s: &str) -> String {
    static CLEAN: Lazy<Regex> =
        Lazy::new(|| Regex::new(r"<a.*?</a>").expect("Problem compiling cleanup regexp."));
    nanohtml2text::html2text(&CLEAN.replace_all(s, ""))
        .trim()
        .to_string()
        .to_lowercase()
}

/// Print out the text of a toot as plain text.
async fn print_status(s: &Status) {
fn print_status(sender: &str, content: &str) {
    println!(
        "Received from {}: {}",
    println!("Received from {}: {}", sender, content);
        s.account.acct,
        clean(&s.content).await
    );
}

#[tokio::main]
async fn main() -> Result<()> {
    let token = CancellationToken::new();
    let token2 = token.clone();

    // This channel sends events from the fedi API and game events to the main event loop.
    let (cs, mut cr) = mpsc::unbounded_channel();
    // let spoof = spoof::Spoof::new(cs.clone(), token.clone());
    let dice = dice::Dice::new(cs.clone(), token.clone());

    // g is a vector of games.
    let mut game_manager = GameManager::new(&cs, &token);
    if let Some(state) = load_persisted_state() {
        game_manager.load_states(&state.games);
    }

    let mut g: Vec<Box<dyn Game>> = vec![Box::new(rps::Rps::new(cs.clone(), token.clone()))];

    // We add Rock Paper Scissors..
    // If you write another game you need to create a file, use mod, and add it like this.
    // g.push(Box::new(spoof));
    g.push(Box::new(dice));
    {
        let sender = cs.clone();
        let cancel = token.clone();
        tokio::spawn(async move {
            loop {
                tokio::select! {
                    _ = cancel.cancelled() => break,
                    _ = sleep(Duration::from_secs(60)) => {
                        if sender.send(GameEvent::Persist).is_err() {
                            break;
                        }
                    }
                }
            }
        });
    }

    let web_client = ClientBuilder::new()
        .user_agent("Werewolf 0.1")
        .build()
        .expect("Problem building Reqwest client.");

    let mastodon = if let Ok(data) = toml::from_file("mastodon-data.toml") {
    let mastodon = if let Ok(data) = mastodon_toml::from_file("mastodon-data.toml") {
        Mastodon::new(web_client, data)
    } else {
        register().await?
    };

    // We need one mastodon object for the stream and another to post statuses through.
    let m = mastodon.clone();
    let posting_client = mastodon.clone();
    let bot_account = mastodon
        .verify_credentials()
        .await
        .map(|account| account.acct)
        .unwrap_or_default();

    // Event loop, runs on another thread.
    tokio::spawn(async move {
        println!("Initiating main event loop.");
        while let Some(event) = cr.recv().await {
            match event {
                GameEvent::Notification(n) if n.notification_type == NotificationType::Mention => {
                    let sender = n.account.acct;
                    if sender == bot_account {
                        continue;
                    }
                    // Time to check if we got a quit message.
                    let s = n
                        .status
                    let Some(status) = n.status else {
                        .expect("Event is a notification but does not have a status.");
                    let content = clean(&s.content).await;
                    if sender == ADMIN && s.content.contains(QUIT) {
                        continue;
                    };
                    let content = clean(&status.content);
                    if sender == ADMIN && status.content.contains(QUIT) {
                        println!("Admin sent us the shut down command.");
                        token.cancel();
                        break;
                    }
                    print_status(&s).await;
                    // Treat the toot  like a command.
                    print_status(&sender, &content);
                    // Treat the toot like a command.
                    if content.is_empty() {
                        continue;
                    }
                    let comm = PlayerCommand { sender, content };
                    // We iterate on each game.
                    for i in g.iter_mut() {
                        // Asking it if we must reply.
                        let r = i.next(&Command::PlayerCommand(&comm));
                        // And for each reply.
                    game_manager.dispatch_player(&posting_client, &comm).await;
                }
                GameEvent::Reply(reply) => {
                        // Take the visibility.
                        let v = r.1;
                        for j in r.0 {
                            // We send it.
                            println!("Sent: {}", j);
                            let status = StatusBuilder::new()
                                .status(j.to_string())
                                .language(Language::Eng)
                                .visibility(v)
                                .build();
                            let _ =
                                post_status(&m, status.expect("Problem posting a status.")).await;
                        }
                    }
                    process_reply(&posting_client, reply).await;
                }
                GameEvent::Step(internal) => {
                    game_manager
                        .dispatch_internal(&posting_client, internal)
                        .await;
                }
                GameEvent::Persist => {
                    game_manager.persist().await;
                }
                _ => (),
            }
        }
    });

    let mut l = 0;
    let mut bl = 0;
    'stream: loop {
    let mut attempt: u32 = 0;
    let mut backoff: u8 = 0;
    loop {
        println!(
            "Initiating streaming API... Loop: {}. Backing off level: {}.",
            l, bl
            "Initiating streaming API... Attempt: {}. Backing off level: {}.",
            attempt, backoff
        );
        let stream = match mastodon.stream_notifications().await {
            Ok(stream) => {
                if bl > 0 {
                    bl -= 1;
                }

                stream
            }
            _ => {
                sleep(Duration::from_secs(2u64.pow(min(MAX_BL, bl).into()))).await;
                if bl < MAX_BL.into() {
                    bl += 1;
                    println!("Backing off level now {}.", bl);
                }
                continue;
            }
        };

        match stream_notifications_loop(&mastodon, &cs, &token2).await {
        select! {
        _ = token2.cancelled() =>
            StreamOutcome::Cancelled => {
        {
        println!("Shutting down...");
        break 'stream;
        }

                println!("Shutting down...");
                break;
            }
            StreamOutcome::Finished => {
                if backoff > 0 {
                    backoff -= 1;
                }
        _ =
        stream.try_for_each(|(event, _)| async {
        if let Event::Notification(n) = event {
        cs.send(GameEvent::Notification(n)).expect("Problem sending event through channel.");
        }
            }
        Ok(())
        })
        => {
            StreamOutcome::Error(err) => {
        if bl < MAX_BL { bl += 1; }
        println!("Streaming terminated. Backing off level now {}", bl);
                eprintln!("Streaming error: {}", err);
        }
        Some(()) = async {
        loop {
        sleep(Duration::from_secs(30)).await;
        if bl > 0 {
            bl -= 1;
            println!("Backing off level now {}.", bl);
        }
                let delay = Duration::from_secs(2u64.pow(u32::from(min(MAX_BL, backoff))));
                sleep(delay).await;
                if backoff < MAX_BL {
                    backoff += 1;
                    println!("Backing off level now {}.", backoff);
                }
        // Return value for the type checker.
        if false { return None }
        }
            }
        }
        =>

        {}
        };
        println!("Streaming terminated. Loop: {}. Backing off: {}", l, bl);
        l += 1;
        attempt = attempt.saturating_add(1);
    }

    Ok(())
}

async fn register() -> Result<Mastodon> {
    let client = ClientBuilder::new()
        .user_agent("Werewolf 0.1")
        .build()
        .expect("Problem building Reqwest client for registration.");
    let registration = Registration::new_with_client(INSTANCE, client)
        .client_name("Werewolf 0.1")
        .scopes(Scopes::read_all() | Scopes::write_all() | Scopes::follow())
        .build()
        .await?;
    let mastodon = cli::authenticate(registration).await?;

    // Save app data for using on the next run.
    toml::to_file(&mastodon.data, "mastodon-data.toml")?;
    mastodon_toml::to_file(&mastodon.data, "mastodon-data.toml")?;

    Ok(mastodon)
}

async fn post_status(m: &Mastodon, s: NewStatus) -> Result<()> {
    m.new_status(s).await?;
    // println!("Sent: {}", clean(&st.content.to_string()).await);
    Ok(())
}

async fn process_reply(mastodon: &Mastodon, reply: Reply) {
    let visibility = reply.1;
    for message in reply.0 {
        if let Some(sanitized) = sanitize_outgoing(&message) {
            println!("Sent: {}", sanitized);
            match StatusBuilder::new()
                .status(sanitized)
                .language(Language::Eng)
                .visibility(visibility)
                .build()
            {
                Ok(status) => {
                    if let Err(err) = post_status(mastodon, status).await {
                        eprintln!("Error posting status: {}", err);
                    }
                }
                Err(err) => eprintln!("Unable to build status: {}", err),
            }
        }
    }
}

/// Normalise and truncate outgoing messages to stay within Mastodon limits.
fn sanitize_outgoing(message: &str) -> Option<String> {
    const MAX_STATUS_BYTES: usize = 480; // leave headroom for mentions and signatures
    let trimmed = message.trim();
    if trimmed.is_empty() {
        return None;
    }

    let mut sanitized = String::with_capacity(trimmed.len().min(MAX_STATUS_BYTES));
    let mut last_was_space = false;
    for ch in trimmed.chars() {
        if ch.is_control() && ch != '\n' && ch != '\t' {
            continue;
        }
        let normalized = match ch {
            '\r' => '\n',
            _ => ch,
        };
        if normalized.is_whitespace() && normalized != '\n' {
            if last_was_space {
                continue;
            }
            sanitized.push(' ');
            last_was_space = true;
        } else {
            sanitized.push(normalized);
            last_was_space = false;
        }
        if sanitized.len() >= MAX_STATUS_BYTES {
            break;
        }
    }

    let collapsed = sanitized.trim().to_string();
    if collapsed.is_empty() {
        None
    } else {
        Some(collapsed)
    }
}

/// Coordinates the lifecycle of every enabled game and persistence hooks.
struct GameManager {
    games: Vec<Box<dyn Game>>,
}

impl GameManager {
    fn new(channel: &mpsc::UnboundedSender<GameEvent>, token: &CancellationToken) -> Self {
        let games = catalog::default_games(channel, token);
        Self { games }
    }

    fn load_states(&mut self, states: &HashMap<String, Value>) {
        for game in self.games.iter_mut() {
            if let Some(value) = states.get(game.name()) {
                if let Err(err) = game.load_state(value) {
                    eprintln!("Failed to load state for game '{}': {}", game.name(), err);
                }
            }
        }
    }

    async fn dispatch_player(&mut self, mastodon: &Mastodon, command: &PlayerCommand) {
        for game in self.games.iter_mut() {
            let reply = game.next(&Command::PlayerCommand(command));
            process_reply(mastodon, reply).await;
        }
    }

    async fn dispatch_internal(&mut self, mastodon: &Mastodon, internal: InternalCommand) {
        for game in self.games.iter_mut() {
            let reply = game.next(&Command::InternalCommand(internal.clone()));
            process_reply(mastodon, reply).await;
        }
    }

    async fn persist(&mut self) {
        let mut games_state = HashMap::new();
        for game in self.games.iter() {
            if let Some(value) = game.save_state() {
                games_state.insert(game.name().to_string(), value);
            }
        }
        let state = PersistedState { games: games_state };
        match toml::to_string(&state) {
            Ok(serialised) => {
                if let Err(err) = tokio::fs::write(STATE_FILE, serialised).await {
                    eprintln!("Failed to persist game state: {}", err);
                }
            }
            Err(err) => eprintln!("Failed to serialise game state: {}", err),
        }
    }
}

#[derive(Serialize, Deserialize, Default)]
struct PersistedState {
    games: HashMap<String, Value>,
}

/// Load persisted state from disk if present, logging any parse errors.
fn load_persisted_state() -> Option<PersistedState> {
    if !Path::new(STATE_FILE).exists() {
        return None;
    }
    match fs::read_to_string(STATE_FILE) {
        Ok(contents) => match toml::from_str::<PersistedState>(&contents) {
            Ok(state) => Some(state),
            Err(err) => {
                eprintln!("Failed to parse persisted game state: {}", err);
                None
            }
        },
        Err(err) => {
            eprintln!("Failed to read persisted game state: {}", err);
            None
        }
    }
}

enum StreamOutcome {
    Cancelled,
    Finished,
    Error(StreamError),
}

#[derive(Debug)]
enum StreamError {
    Api(mastodon_async::Error),
    Websocket(tokio_tungstenite::tungstenite::Error),
    Url(ParseError),
    Json(serde_json::Error),
    UnsupportedScheme,
}

impl std::fmt::Display for StreamError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            StreamError::Api(err) => write!(f, "API stream error: {}", err),
            StreamError::Websocket(err) => write!(f, "WebSocket error: {}", err),
            StreamError::Url(err) => write!(f, "Invalid streaming URL: {}", err),
            StreamError::Json(err) => write!(f, "Invalid streaming payload: {}", err),
            StreamError::UnsupportedScheme => {
                write!(f, "Unsupported instance scheme for WebSocket")
            }
        }
    }
}

impl std::error::Error for StreamError {}

async fn stream_notifications_loop(
    mastodon: &Mastodon,
    sender: &mpsc::UnboundedSender<GameEvent>,
    cancel: &CancellationToken,
) -> StreamOutcome {
    match stream_notifications_ws(mastodon, sender, cancel).await {
        Ok(outcome) => outcome,
        Err(err) => {
            eprintln!("WebSocket unavailable, falling back to SSE: {}", err);
            match stream_notifications_sse(mastodon, sender, cancel).await {
                Ok(outcome) => outcome,
                Err(err) => StreamOutcome::Error(err),
            }
        }
    }
}

async fn stream_notifications_sse(
    mastodon: &Mastodon,
    sender: &mpsc::UnboundedSender<GameEvent>,
    cancel: &CancellationToken,
) -> std::result::Result<StreamOutcome, StreamError> {
    let stream = mastodon
        .stream_notifications()
        .await
        .map_err(StreamError::Api)?
        .into_stream();
    pin_mut!(stream);
    loop {
        tokio::select! {
            _ = cancel.cancelled() => return Ok(StreamOutcome::Cancelled),
            result = stream.next() => match result {
                Some(Ok((Event::Notification(notification), _))) => {
                    if sender.send(GameEvent::Notification(notification)).is_err() {
                        return Ok(StreamOutcome::Cancelled);
                    }
                }
                Some(Ok(_)) => {}
                Some(Err(err)) => return Err(StreamError::Api(err)),
                None => return Ok(StreamOutcome::Finished),
            }
        }
    }
}

async fn stream_notifications_ws(
    mastodon: &Mastodon,
    sender: &mpsc::UnboundedSender<GameEvent>,
    cancel: &CancellationToken,
) -> std::result::Result<StreamOutcome, StreamError> {
    let url = build_websocket_url(mastodon)?;
    let (mut stream, _) = connect_async(url).await.map_err(StreamError::Websocket)?;

    loop {
        tokio::select! {
            _ = cancel.cancelled() => {
                let _ = stream.close(None).await;
                return Ok(StreamOutcome::Cancelled);
            }
            message = stream.next() => match message {
                Some(Ok(Message::Text(text))) => {
                    if let Some(notification) = parse_ws_notification(&text)? {
                        if sender.send(GameEvent::Notification(notification)).is_err() {
                            return Ok(StreamOutcome::Cancelled);
                        }
                    }
                }
                Some(Ok(Message::Ping(payload))) => {
                    use futures_util::SinkExt;
                    stream
                        .send(Message::Pong(payload))
                        .await
                        .map_err(StreamError::Websocket)?;
                }
                Some(Ok(Message::Pong(_))) => {}
                Some(Ok(Message::Close(_))) => return Ok(StreamOutcome::Finished),
                Some(Ok(Message::Binary(_))) => {}
                Some(Ok(Message::Frame(_))) => {}
                Some(Err(err)) => return Err(StreamError::Websocket(err)),
                None => return Ok(StreamOutcome::Finished),
            }
        }
    }
}

fn build_websocket_url(mastodon: &Mastodon) -> std::result::Result<Url, StreamError> {
    let mut url = Url::parse(mastodon.data.base.as_ref()).map_err(StreamError::Url)?;
    match url.scheme() {
        "https" => url
            .set_scheme("wss")
            .map_err(|_| StreamError::UnsupportedScheme)?,
        "http" => url
            .set_scheme("ws")
            .map_err(|_| StreamError::UnsupportedScheme)?,
        "wss" | "ws" => {}
        _ => return Err(StreamError::UnsupportedScheme),
    }
    url.set_path("/api/v1/streaming/user/notification");
    {
        let mut pairs = url.query_pairs_mut();
        pairs.clear();
        pairs.append_pair("access_token", mastodon.data.token.as_ref());
    }
    Ok(url)
}

#[derive(Debug, Deserialize)]
struct WebsocketEnvelope {
    event: Option<String>,
    payload: Option<String>,
}

fn parse_ws_notification(text: &str) -> std::result::Result<Option<Notification>, StreamError> {
    let envelope: WebsocketEnvelope = serde_json::from_str(text).map_err(StreamError::Json)?;
    if envelope.event.as_deref() != Some("notification") {
        return Ok(None);
    }
    let payload = match envelope.payload {
        Some(payload) => payload,
        None => return Ok(None),
    };
    let notification: Notification = serde_json::from_str(&payload).map_err(StreamError::Json)?;
    Ok(Some(notification))
}

use crate::game::{Command, Game, GameEvent, Reply};
use serde::{Deserialize, Serialize};
use std::{
    cmp::Ordering,
    collections::{HashMap, HashSet},
};
use toml::Value;
/// Rock, Paper, Scissors.

/// A match. Considering to move this to Game.
#[derive(Clone, Serialize, Deserialize)]
struct Match {
    state: HashMap<String, Option<Play>>,
}

impl Match {
    /// Create a new match from the set of players in the lobby.
    fn new(h: &HashSet<String>) -> Self {

/// Data structure of the game.
pub struct Rps {
    /// A HashSet with the players waiting to play as account strings.
    lobby: HashSet<String>,
    /// capacity determines  how many people a match contains.
    capacity: u8,
    /// A vector of ongoing matches.
    matches: Vec<Match>,
    /// Map of ongoing matches keyed by stable identifier.
    matches: HashMap<usize, Match>,
    /// HashSet indicating for each player which match they are in.
    players: HashMap<String, usize>,
    /// Next match identifier to allocate.
    next_match_id: usize,
}

impl Game for Rps {
    /// Creation of a new and empty Rps game structure.
    fn new(
        _c: tokio::sync::mpsc::UnboundedSender<GameEvent>,
        _token: tokio_util::sync::CancellationToken,
    ) -> Self {
        Rps {
            lobby: HashSet::new(),
            capacity: 2,
            matches: Vec::new(),
            matches: HashMap::new(),
            players: HashMap::new(),
            next_match_id: 0,
        }
    }

    /// State machine that accepts a command, changes state and delivers replies if required.
    fn next(&mut self, m: &Command) -> Reply {
        let mut r = Reply::new();
        let mut reply = Reply::new();
        let m = match m {
            Command::PlayerCommand(c) => c,
            Command::InternalCommand(_) => {
                return r;
                return reply;
            }
        };

        // The entire state depends on two factors: are we waiting to join a game, and are we playing a game?
        // It is possible for both to be false, and either one to be true.
        // If both are true, this is an error.
        let waiting = self.lobby.contains(&m.sender);
        let playing = self.players.contains_key(&m.sender);
        assert!(!(waiting & playing));
        // It is possible for a command to be: rps, a move in the game, or cancelrps.
        assert!(!(waiting && playing));

        if m.content == "help" {
            reply.quiet();
            if playing {
                if let Some(&match_id) = self.players.get(&m.sender) {
                    if let Some(current_match) = self.matches.get(&match_id) {
                        let opponent = current_match.opponent(&m.sender);
                        reply.push(format!(
                            "@{} You're in a Rock, Paper, Scissors match with {}. Send 'rock', 'paper', or 'scissors' to play, or 'cancelrps' to forfeit.",
                            m.sender, opponent
                        ));
                        return reply;
                    }
                }
                reply.push(format!(
                    "@{} You're in a Rock, Paper, Scissors match. Send 'rock', 'paper', or 'scissors' to play, or 'cancelrps' to forfeit.",
                    m.sender
                ));
            } else if waiting {
                reply.push(format!(
                    "@{} Waiting for an opponent. I'll start the match as soon as someone else sends 'rps'.",
                    m.sender
                ));
            } else {
                reply.push(
                    "Send 'rps' to join the lobby. Once matched, play with 'rock', 'paper', or 'scissors'. Use 'cancelrps' to withdraw.".
                        to_string(),
                );
            }
            return reply;
        }

        let joining = m.content == "rps";
        let quitting = m.content == "cancelrps";
        let choice = match m.content.as_str() {
            "rock" => Some(Play::Rock),
            "paper" => Some(Play::Paper),
            "scissors" => Some(Play::Scissors),
            _ => None,
        };
        // At most, one of these conditions can hold.

        assert!(!(joining && quitting));
        assert!(!(joining && choice.is_some()));
        assert!(!(quitting && choice.is_some()));
        // At this point we have all necessary information to match.

        match (joining, quitting, choice, playing, waiting) {
            // We don't bother with the impossible cases that are already excluded by assertion.
            // Let's start with joining the game.
            // There are 3 cases we need care about:
            // We're joining, not playing and not waiting.
            (true, false, None, false, false) => {
                // This has two cases.
                // If there's nobody waiting.
                if self.capacity > 1 {
                    // Put sender in the lobby. Reduce capacity.
                    r.push(format!("@{} You've asked to join a game of Rock, Paper, Scissors. As soon as someone else wants to play, I'll send you a message so you can tell me your choice.", m.sender));
                    reply.push(format!("@{} You've asked to join a game of Rock, Paper, Scissors. As soon as someone else wants to play, I'll send you a message so you can tell me your choice.", m.sender));
                    self.lobby.insert(m.sender.clone());
                    self.capacity -= 1;
                }
                // If Someone's waiting, start the game.
                else {
                } else {
                    // Put player in the lobby. This avoids us making players mut.
                    self.lobby.insert(m.sender.clone());
                    // Get the playes from the lobby.
                    let players = self.lobby.clone();
                    // Create this match.
                    let this_match = Match::new(&players);
                    // Empty the lobby.
                    self.lobby = HashSet::new();
                    let participants: Vec<String> = players.iter().cloned().collect();
                    self.lobby.clear();
                    // Reset capacity.
                    self.capacity = 2;
                    // Add the match to the matches vector.
                    let match_id = self.next_match_id;
                    self.matches.push(this_match);
                    // Get the index.
                    let n = self.matches.len() - 1;
                    // Place the match index for each player.
                    for i in players {
                        self.players.insert(i, n);
                    self.next_match_id = self.next_match_id.saturating_add(1);
                    let match_instance = Match::new(&players);
                    for participant in &participants {
                        self.players.insert(participant.clone(), match_id);
                    }
                    // Prepare the replies.
                    // Make this reply quiet, so that the move is responded in DM.
                    r.quiet();
                    for i in self.matches[n].state.keys() {
                        r.push(format!(
                            "@{} Got a partner! Your opponent is {}
                    self.matches.insert(match_id, match_instance);
                    reply.quiet();
                    if let Some(current_match) = self.matches.get(&match_id) {
                        for participant in current_match.state.keys() {
                            reply.push(format!(
                                "@{} Got a partner! Your opponent is {}

Tell me your choice: *rock*, *paper*, or *scissors*?",
                            i,
                            self.matches[n].opponent(i)
                        ));
                    }
                }
            }

                                participant,
                                current_match.opponent(participant)
                            ));
                        }
                    }
                }
            }
            // We're trying to join, but already in the lobby.
            (true, false, None, false, true) => {
                r.push(format!(
                reply.push(format!(
                    "@{} You're already waiting for a game of Rock, Paper, Scissors. Be patient.",
                    m.sender
                ));
            }
            // We're trying to join, but already playing.
            (true, false, None, true, false) => {
                if let Some(&match_id) = self.players.get(&m.sender) {
                    if let Some(current_match) = self.matches.get(&match_id) {
                r.push(format!(
                    "@{} You're already playing a game against {}
                        reply.push(format!(
                            "@{} You're already playing a game against {}

You can cancel it with *cancelrps* if you're bored of waiting.",
                    m.sender,
                    self.matches[*self.players.get(&m.sender).expect("Trying to get the match index for a player who sent a join  command and is playing a game, but  is not in the set.")].opponent(&m.sender)
                ));
            }

                            m.sender,
                            current_match.opponent(&m.sender)
                        ));
                    } else {
                        reply.push(format!(
                            "@{} You're already in a Rock, Paper, Scissors match. Send 'cancelrps' if you want out.",
                            m.sender
                        ));
                    }
                }
            // Now we do the two quit cases: while waiting, and while playing.
            // While waiting, it only affects the player.
            }
            (false, true, None, false, true) => {
                // Remove player from lobby.
                self.lobby.remove(&m.sender);
                // Reset capacity.
                self.capacity = 2;
                // Send message.
                r.push(format!(
"@{} You're no longer waiting for a partner. You may play again by sending *rps* any time.", m.sender));
                reply.push(format!(
                    "@{} You're no longer waiting for a partner. You may play again by sending *rps* any time.",
                    m.sender
                ));
            }
            // While playing, it affects both players.
            (false, true, None, true, false) => {
                // Get our match index.
                let n = self.players.get(&m.sender).expect("Trying to get the match of a player who sent a cancel command while playing a game, but is not in the set.");
                if let Some(&match_id) = self.players.get(&m.sender) {
                // Get our opponent.
                let o = self.matches[*n].opponent(&m.sender);
                // Remove the match.
                self.matches.remove(*n);
                    if let Some(current_match) = self.matches.get(&match_id) {
                        let opponent = current_match.opponent(&m.sender);
                        self.matches.remove(&match_id);
                // Remove both players from the player list.
                self.players.remove(&m.sender);
                self.players.remove(&o);
                        self.players.remove(&m.sender);
                        self.players.remove(&opponent);
                // The simplest way to do a cancellation is to tell both players.
                // TODO: The non-cancelling player can go to the lobby in a future version.
                r.push(format!(
                    "@{} has cancelled the game with @{}
                        reply.push(format!(
                            "@{} has cancelled the game with @{}

You're both welcome to play again any time. Use *rps* to start a new match.",
                    m.sender, o
                ));
            }
                            m.sender, opponent
                        ));
                    } else {
                        self.players.remove(&m.sender);
                        reply.push("Your match has already ended.".to_string());
                    }
            // Now we deal with making a move.
            (false, false, Some(c), true, false) => {
                }
            }
            (false, false, Some(choice), true, false) => {
                // Our name for later insertion.
                let name = m.sender.clone();
                let Some(&match_id) = self.players.get(&name) else {
                // Get our match index.
                let n = self.players.get(&name).expect("Trying to get the match of a player who made a move while playing a game, but is not in the set.");
                // Get our opponent.
                let o = self.matches[*n].opponent(&name);
                // If we already played:
                if self.matches[*n].state.get(&name).expect("Trying to get the match of a player making a move while playing a game, but is not in the set.").is_some() {
                    reply.push("Your match has already ended.".to_string());
                    return reply;
                };

                let mut resolution: Option<(Vec<String>, Reply)> = None;

                if let Some(current_match) = self.matches.get_mut(&match_id) {
                    if current_match
                        .state
                        .get(&name)
                        .expect("Trying to get the match of a player making a move while playing a game, but is not in the set.")
                    // We can't play twice.
                    r.push(format!(
                        "@{} You already sent me your choice. You need to wait for {}
                        .is_some()
                    {
                        reply.push(format!(
                            "@{} You already sent me your choice. You need to wait for {}

If you get bored, you can send me *cancelrps* to cancel the game.",
                        name, o
                    ));
                } else {
                    // Put our choice in the match.
                    self.matches[*n].state.insert(name, Some(c));
                            name,
                            current_match.opponent(&name)
                        ));
                        return reply;
                    }

                    current_match.state.insert(name.clone(), Some(choice));
                    // Check if the match is done.
                    if self.matches[*n].is_ready() {
                    if current_match.is_ready() {
                        // We're ready. Solve the game.
                        r = self.matches[*n].solve();
                        let players: Vec<String> = current_match.state.keys().cloned().collect();
                        let solve_reply = current_match.solve();
                        // Clean up.
                        self.matches.remove(*n);
                        self.players.remove(&m.sender);
                        self.players.remove(&o);
                        resolution = Some((players, solve_reply));
                    } else {
                        // Game isn't over, just send the message.
                        r.push(format!(
                        reply.push(format!(
                            "@{} Got your move. Let's see what your opponent does.",
                            m.sender
                        ));
                    }
                } else {
                    self.players.remove(&name);
                    reply.push("Your match has already ended.".to_string());
                    return reply;
                }
            }
            // And moves out of time.
            // When we're not in a game or waiting to play.

                if let Some((participants, resolve_reply)) = resolution {
                    self.matches.remove(&match_id);
                    for participant in participants {
                        self.players.remove(&participant);
                    }
                    return resolve_reply;
                }
            }
            (false, false, Some(_), false, false) => {
                reply.push(format!(
                r.push(format!("@{} You haven't joined a game yet. You can do so by sending me *rps* whenever you like.", m.sender));
                    "@{} You haven't joined a game yet. You can do so by sending me *rps* whenever you like.",
                    m.sender
                ));
            }
            // When we're still waiting for a partner.
            (false, false, Some(_), false, true) => {
                reply.push(format!(
                r.push(format!("@{} You're still waiting for a partner. Be patient. If you want, you can sende me *cancelrps* to cancel the game.", m.sender));
                    "@{} You're still waiting for a partner. Be patient. If you want, you can sende me *cancelrps* to cancel the game.",
                    m.sender
                ));
            }
            _ => {}
        }

        reply
    }

    fn name(&self) -> &'static str {
        "rps"
    }

    fn save_state(&self) -> Option<Value> {
        let lobby: Vec<String> = self.lobby.iter().cloned().collect();
        let matches: Vec<RpsMatchEntry> = self
            .matches
            .iter()
            .map(|(id, m)| RpsMatchEntry {
                id: *id,
                state: m.clone(),
            })
            .collect();
        let state = RpsState {
            lobby,
            capacity: self.capacity,
            matches,
            next_match_id: self.next_match_id,
        };
        Value::try_from(state).ok()

            _ => {} // __
        }

        r
    }
    }

    fn load_state(&mut self, value: &Value) -> Result<(), String> {
        let state: RpsState = value.clone().try_into().map_err(|e| e.to_string())?;
        self.lobby = state.lobby.into_iter().collect();
        self.capacity = state.capacity;
        self.matches = state
            .matches
            .into_iter()
            .map(|entry| (entry.id, entry.state))
            .collect();
        self.players.clear();
        for (match_id, m) in &self.matches {
            for player in m.state.keys() {
                self.players.insert(player.clone(), *match_id);
            }
        }
        self.next_match_id = state.next_match_id;
        Ok(())
    }
}

#[derive(Serialize, Deserialize)]
struct RpsMatchEntry {
    id: usize,
    state: Match,
}

#[derive(Serialize, Deserialize)]
struct RpsState {
    lobby: Vec<String>,
    capacity: u8,
    matches: Vec<RpsMatchEntry>,
    next_match_id: usize,
}

/// Valid plays.
#[derive(PartialEq, Debug)]
#[derive(Clone, Serialize, Deserialize, PartialEq, Debug)]
enum Play {
    Rock,
    Paper,
    Scissors,
}

impl Play {

        assert_eq!(r.0.len(), 1, "Incorrect number of replies in: {:?}", r);
        assert_eq!(r.0[0], "@modulux@node.isonomia.net You haven't joined a game yet. You can do so by sending me *rps* whenever you like.", "{:?}", r);

        r = command(&mut g, c2);
        assert_eq!(r.0.len(), 1, "Incorrect number of replies in: {:?}", r);
        assert_eq!(r.0[0], "@modulux2@node.isonomia.net You haven't joined a game yet. You can do so by sending me *rps* whenever you like.", "{:?}", r);
    }

    #[test]
    fn test_help_while_playing() {
        let mut g = Rps::new(
            tokio::sync::mpsc::unbounded_channel().0,
            crate::CancellationToken::new(),
        );
        let p1 = "modulux@node.isonomia.net".to_string();
        let p2 = "modulux2@node.isonomia.net".to_string();
        command(&mut g, (p1.clone(), "rps".to_string()));
        command(&mut g, (p2.clone(), "rps".to_string()));
        let help_reply = command(&mut g, (p1.clone(), "help".to_string()));
        assert!(help_reply
            .0
            .iter()
            .any(|msg| msg.contains("rock', 'paper', or 'scissors")));
    }

    #[test]
    fn test_join_full_then_cancel() {
        let r;
        let mut g = Rps::new(
            tokio::sync::mpsc::unbounded_channel().0,
            crate::CancellationToken::new(),

            "@modulux@node.isonomia.net has cancelled the game with @modulux2@node.isonomia.net

You're both welcome to play again any time. Use *rps* to start a new match.",
            "Incorrect response. {}.",
            r.0[0]
        );
    }
}

    #[test]
    fn test_parallel_matches() {
        let mut g = Rps::new(
            tokio::sync::mpsc::unbounded_channel().0,
            crate::CancellationToken::new(),
        );
        let p1 = "modulux@node.isonomia.net".to_string();
        let p2 = "modulux2@node.isonomia.net".to_string();
        let p3 = "modulux3@node.isonomia.net".to_string();
        let p4 = "modulux4@node.isonomia.net".to_string();

        command(&mut g, (p1.clone(), "rps".to_string()));
        command(&mut g, (p2.clone(), "rps".to_string()));
        command(&mut g, (p3.clone(), "rps".to_string()));
        command(&mut g, (p4.clone(), "rps".to_string()));

        let match_one = g.players.get(&p1).cloned();
        let match_two = g.players.get(&p3).cloned();
        assert!(match_one.is_some() && match_two.is_some());
        assert_ne!(match_one, match_two);
        assert_eq!(g.matches.len(), 2);
    }
}