monorepo/sgf/src/go.rs

// https://red-bean.com/sgf/
// https://red-bean.com/sgf/user_guide/index.html
// https://red-bean.com/sgf/sgf4.html

// todo: support collections in a file
// Properties to support. Remove each one as it gets support.
//  B
//  KO
//  MN
//  W
//  AB
//  AE
//  AW
//  PL
//  C
//  DM
//  GB
//  GW
//  HO
//  N
//  UC
//  V
//  BM
//  DO
//  IT
//  TE
//  AR
//  CR
//  DD
//  LB
//  LN
//  MA
//  SL
//  SQ
//  TR
//  AP
//  CA
//  FF
//  GM
//  ST
//  SZ
//  AN
//  BR
//  BT
//  CP
//  DT
//  EV
//  GN
//  GC
//  ON
//  OT
//  PB
//  PC
//  PW
//  RE
//  RO
//  RU
//  SO
//  TM
//  US
//  WR
//  WT
//  BL
//  OB
//  OW
//  WL
//  FG
//  PM
//  VW

use crate::{
    date::{parse_date_field, Date},
    tree::{Size, Tree},
    Error,
};
use serde::{Deserialize, Serialize};
use typeshare::typeshare;

#[derive(Clone, Debug)]
pub struct Game {
    pub board_size: Size,
    pub info: GameInfo,

    pub tree: Tree,
}

impl TryFrom<Tree> for Game {
    type Error = Error;

    fn try_from(tree: Tree) -> Result<Self, Self::Error> {
        let board_size = match tree.sequence[0].find_prop("SZ") {
            Some(prop) => Size::try_from(prop.values[0].as_str())?,
            None => Size {
                width: 19,
                height: 19,
            },
        };
        let mut info = GameInfo::default();
        info.app_name = tree.sequence[0]
            .find_prop("AP")
            .map(|prop| prop.values[0].clone());

        info.game_name = tree.sequence[0]
            .find_prop("GN")
            .map(|prop| prop.values[0].clone());

        info.black_player = tree.sequence[0]
            .find_prop("PB")
            .map(|prop| prop.values.join(", "));

        info.black_rank = tree.sequence[0]
            .find_prop("BR")
            .and_then(|prop| Rank::try_from(prop.values[0].as_str()).ok());

        info.white_player = tree.sequence[0]
            .find_prop("PW")
            .map(|prop| prop.values.join(", "));

        info.white_rank = tree.sequence[0]
            .find_prop("WR")
            .and_then(|prop| Rank::try_from(prop.values[0].as_str()).ok());

        info.result = tree.sequence[0]
            .find_prop("RE")
            .and_then(|prop| GameResult::try_from(prop.values[0].as_str()).ok());

        info.time_limits = tree.sequence[0]
            .find_prop("TM")
            .and_then(|prop| prop.values[0].parse::<u64>().ok())
            .and_then(|seconds| Some(std::time::Duration::from_secs(seconds)));

        info.date = tree.sequence[0]
            .find_prop("DT")
            .and_then(|prop| {
                let v = prop
                    .values
                    .iter()
                    .map(|val| parse_date_field(val))
                    .fold(Ok(vec![]), |acc, v| match (acc, v) {
                        (Ok(mut acc), Ok(mut values)) => {
                            acc.append(&mut values);
                            Ok(acc)
                        }
                        (Ok(_), Err(err)) => Err(err),
                        (Err(err), _) => Err(err),
                    })
                    .ok()?;
                Some(v)
            })
            .unwrap_or(vec![]);

        info.event = tree.sequence[0]
            .find_prop("EV")
            .map(|prop| prop.values.join(", "));

        info.round = tree.sequence[0]
            .find_prop("RO")
            .map(|prop| prop.values.join(", "));

        info.source = tree.sequence[0]
            .find_prop("SO")
            .map(|prop| prop.values.join(", "));

        info.game_keeper = tree.sequence[0]
            .find_prop("US")
            .map(|prop| prop.values.join(", "));

        Ok(Game {
            board_size,
            info,

            tree,
        })
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[typeshare]
pub enum Rank {
    Kyu(u8),
    Dan(u8),
    Pro(u8),
}

impl TryFrom<&str> for Rank {
    type Error = String;
    fn try_from(r: &str) -> Result<Rank, Self::Error> {
        let parts = r.split(" ").map(|s| s.to_owned()).collect::<Vec<String>>();
        let cnt = parts[0].parse::<u8>().map_err(|err| format!("{:?}", err))?;
        match parts[1].to_ascii_lowercase().as_str() {
            "kyu" => Ok(Rank::Kyu(cnt)),
            "dan" => Ok(Rank::Dan(cnt)),
            "pro" => Ok(Rank::Pro(cnt)),
            _ => Err("unparsable".to_owned()),
        }
    }
}

impl ToString for Rank {
    fn to_string(&self) -> String {
        unimplemented!()
    }
}

#[derive(Clone, Debug, Default)]
pub struct GameInfo {
    pub app_name: Option<String>,
    pub annotator: Option<String>,
    pub copyright: Option<String>,
    pub event: Option<String>,
    // Games can be played across multiple days, even multiple years. The format specifies
    // shortcuts.
    pub date: Vec<Date>,
    pub location: Option<String>,
    // special rules for the round-number and type
    pub round: Option<String>,
    pub ruleset: Option<String>,
    pub source: Option<String>,
    pub time_limits: Option<std::time::Duration>,
    pub game_keeper: Option<String>,
    pub komi: Option<f32>,

    pub game_name: Option<String>,
    pub game_comments: Option<String>,

    pub black_player: Option<String>,
    pub black_rank: Option<Rank>,
    pub black_team: Option<String>,

    pub white_player: Option<String>,
    pub white_rank: Option<Rank>,
    pub white_team: Option<String>,

    pub opening: Option<String>,
    pub overtime: Option<String>,
    pub result: Option<GameResult>,
}

#[derive(Clone, Debug, PartialEq)]
pub enum GameResult {
    Annulled,
    Draw,
    Black(Win),
    White(Win),
}

impl TryFrom<&str> for GameResult {
    type Error = String;
    fn try_from(s: &str) -> Result<GameResult, Self::Error> {
        if s == "0" {
            Ok(GameResult::Draw)
        } else if s == "Void" {
            Ok(GameResult::Annulled)
        } else {
            let parts = s.split("+").collect::<Vec<&str>>();
            let res = match parts[0].to_ascii_lowercase().as_str() {
                "b" => GameResult::Black,
                "w" => GameResult::White,
                _ => panic!("unknown result format"),
            };
            match parts[1].to_ascii_lowercase().as_str() {
                "r" | "resign" => Ok(res(Win::Resignation)),
                "t" | "time" => Ok(res(Win::Time)),
                "f" | "forfeit" => Ok(res(Win::Forfeit)),
                _ => {
                    let score = parts[1].parse::<f32>().unwrap();
                    Ok(res(Win::Score(score)))
                }
            }
        }
    }
}

#[derive(Clone, Debug, PartialEq)]
pub enum Win {
    Score(f32),
    Resignation,
    Forfeit,
    Time,
}

/*
enum PropType {
    Move,
    Setup,
    Root,
    GameInfo,
}

enum PropValue {
    Empty,
    Number,
    Real,
    Double,
    Color,
    SimpleText,
    Text,
    Point,
    Move,
    Stone,
}
*/

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{
        date::Date,
        tree::{parse_collection, Size},
    };
    use std::fs::File;
    use std::io::Read;

    const EXAMPLE: &'static str = "(;FF[4]C[root](;C[a];C[b](;C[c])
(;C[d];C[e]))
(;C[f](;C[g];C[h];C[i])
(;C[j])))";

    fn with_text(text: &str, f: impl FnOnce(Vec<Game>)) {
        let (_, games) = parse_collection::<nom::error::VerboseError<&str>>(text).unwrap();
        let games = games
            .into_iter()
            .map(|game| Game::try_from(game).expect("game to parse"))
            .collect::<Vec<Game>>();
        f(games);
    }

    fn with_file(path: &std::path::Path, f: impl FnOnce(Vec<Game>)) {
        let mut file = File::open(path).unwrap();
        let mut text = String::new();
        let _ = file.read_to_string(&mut text);
        with_text(&text, f);
    }

    #[test]
    fn it_parses_game_root() {
        with_text(EXAMPLE, |trees| {
            assert_eq!(trees.len(), 1);
            let tree = &trees[0];
            assert_eq!(tree.info.app_name, None);
            assert_eq!(
                tree.board_size,
                Size {
                    width: 19,
                    height: 19
                }
            );
            // assert_eq!(tree.text, EXAMPLE.to_owned());
        });

        with_file(std::path::Path::new("test_data/print1.sgf"), |trees| {
            assert_eq!(trees.len(), 1);
            let tree = &trees[0];
            assert_eq!(tree.info.app_name, None);
            assert_eq!(
                tree.board_size,
                Size {
                    width: 19,
                    height: 19
                }
            );
        });
    }

    #[test]
    fn it_parses_game_info() {
        with_file(std::path::Path::new("test_data/print1.sgf"), |trees| {
            assert_eq!(trees.len(), 1);
            let tree = &trees[0];
            assert_eq!(tree.info.black_player, Some("Takemiya Masaki".to_owned()));
            assert_eq!(tree.info.black_rank, Some(Rank::Dan(9)));
            assert_eq!(tree.info.white_player, Some("Cho Chikun".to_owned()));
            assert_eq!(tree.info.white_rank, Some(Rank::Dan(9)));
            assert_eq!(tree.info.result, Some(GameResult::White(Win::Resignation)));
            assert_eq!(
                tree.info.time_limits,
                Some(std::time::Duration::from_secs(28800))
            );
            assert_eq!(
                tree.info.date,
                vec![
                    Date::Date(chrono::NaiveDate::from_ymd_opt(1996, 10, 18).unwrap()),
                    Date::Date(chrono::NaiveDate::from_ymd_opt(1996, 10, 19).unwrap()),
                ]
            );
            assert_eq!(tree.info.event, Some("21st Meijin".to_owned()));
            assert_eq!(tree.info.round, Some("2 (final)".to_owned()));
            assert_eq!(tree.info.source, Some("Go World #78".to_owned()));
            assert_eq!(tree.info.game_keeper, Some("Arno Hollosi".to_owned()));
        });
    }
}