code guessing, round #45 (completed)

use crate::game::*;
use rand::seq::IteratorRandom;
use rayon::prelude::*;
use std::cmp::Ordering;
use std::mem::swap;

pub trait Bottable<P: GamePlayer, M: GameMove>: Game<P, M> {
    fn random_move(&self) -> Option<M> {
        let mut rng = rand::thread_rng();
        return self.moves().choose(&mut rng);
    }
    fn best_move(&self) -> Option<M> {
        let p = self.current_player();
        let moves = self.moves().collect::<Vec<M>>();
        if moves.is_empty() {
            return None;
        } else if moves.len() == 1 {
            return moves.into_iter().next();
        }
        let mut score: Vec<f64> = vec![0.0; moves.len()];
        let mut weights: Vec<f64> = vec![0.0; moves.len()];
        let mut weights_old: Vec<f64> = vec![0.0; moves.len()];
        loop {
            (&moves).into_par_iter().zip(&mut score).for_each(|(m, c)| {
                *c += (0..2048)
                    .into_par_iter()
                    .map(|_| self.clone())
                    .map(|mut game| {
                        let mut m = *m;
                        loop {
                            match game.apply(m).unwrap() {
                                MoveOutcome::Win(p2) => break if p2 == p { 1.0 } else { -1.0 },
                                MoveOutcome::Tie => break 0.0,
                                MoveOutcome::Pass => (),
                            }
                            m = game.random_move().unwrap();
                        }
                    })
                    .sum::<f64>();
            });
            let min_score = score.iter().copied().reduce(f64::min).unwrap();
            (&mut weights)
                .into_iter()
                .zip(&score)
                .for_each(|(c, s)| *c = s - min_score);
            let total: f64 = weights.iter().copied().sum::<f64>();
            // normalize scores
            if total > 0.0 {
                (&mut weights).into_iter().for_each(|c| *c /= total);
            } else {
                (&mut weights).into_iter().for_each(|c| *c = 0.0);
            }
            let deviation: f64 = weights
                .iter()
                .copied()
                .zip(weights_old.iter().copied())
                .max_by(|(a, _), (b, _)| a.partial_cmp(b).unwrap_or(Ordering::Equal))
                .map(|(s, s_old)| f64::abs(s - s_old))
                .unwrap();
            if deviation < (1.0 / f64::powf(2.0, 12.0)) {
                break Some(
                    moves
                        .into_iter()
                        .zip(weights)
                        .max_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap_or(Ordering::Equal))
                        .unwrap()
                        .0,
                );
            }
            swap(&mut weights, &mut weights_old);
        }
    }
}

impl<P: GamePlayer, M: GameMove, T: Game<P, M>> Bottable<P, M> for T {}

use crate::game::*;
use std::fmt;

#[derive(Clone)]
pub struct Four<P> {
    player: P,
    data: [(u8, [Option<P>; 6]); 7],
    filled: u8,
    done: bool,
}

impl<P: GamePlayer + fmt::Display> fmt::Display for Four<P> {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("\n")?;
        for y in (0..6).rev() {
            formatter.write_str(" ")?;
            for x in 0..7 {
                match self.data[x].1[y] {
                    Some(p) => formatter.write_fmt(format_args!("{} ", &p)),
                    None => formatter.write_fmt(format_args!(". ")),
                }?;
            }
            formatter.write_str("\n")?;
        }
        formatter.write_str(" ")?;
        for x in 0..7 {
            formatter.write_fmt(format_args!("{} ", x + 1))?;
        }
        formatter.write_str("\n")?;
        Ok(())
    }
}

#[derive(Copy, Clone)]
pub struct FourMove(u8);
impl GameMove for FourMove {}
impl fmt::Display for FourMove {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        (self.0 + 1).fmt(formatter)
    }
}
impl TryFrom<u8> for FourMove {
    type Error = ();
    fn try_from(num: u8) -> Result<Self, ()> {
        if num >= 1 && num <= 7 {
            Ok(Self(num - 1))
        } else {
            Err(())
        }
    }
}

pub struct FourMoves<'a, P: 'a> {
    cols: std::iter::Enumerate<std::slice::Iter<'a, (u8, [Option<P>; 6])>>,
    size: usize,
}

impl<'a, P: GamePlayer> Iterator for FourMoves<'a, P> {
    type Item = FourMove;
    fn next(&mut self) -> Option<Self::Item> {
        let r = self.cols.find(|(_, d)| d.0 < 6).map(|(x, _)| {
            self.size -= 1;
            FourMove(x as u8)
        });
        r
    }
    fn size_hint(&self) -> (usize, Option<usize>) {
        (self.size, Some(self.size))
    }
}

impl<P: GamePlayer> Four<P> {
    const DIRS: [[[i8; 2]; 2]; 4] = [
        [[0, -1], [0, 1]],
        [[-1, 0], [1, 0]],
        [[-1, -1], [1, 1]],
        [[1, -1], [-1, 1]],
    ];
    pub fn new() -> Self {
        Self {
            player: P::first(),
            data: [(0, [None; 6]); 7],
            filled: 0,
            done: false,
        }
    }
}

impl<P: GamePlayer> Game<P, FourMove> for Four<P> {
    type Moves<'a> = FourMoves<'a, P> where P: 'a;
    fn current_player(&self) -> P {
        self.player
    }
    fn moves<'a>(&'a self) -> Self::Moves<'a> {
        FourMoves {
            cols: self.data.iter().enumerate(),
            size: self.data.iter().filter(|d| d.0 < 6).count(),
        }
    }
    fn apply(&mut self, m: FourMove) -> Option<MoveOutcome<P>> {
        use MoveOutcome::*;
        if self.done {
            return None;
        }
        let x = m.0;
        if x >= 7 {
            return None;
        }
        let col = &mut self.data[x as usize];
        if col.0 >= 6 {
            return None;
        }
        let y = col.0;
        col.1[y as usize] = Some(self.player);
        col.0 += 1;
        self.filled += 1;
        for axis in Self::DIRS.iter() {
            let mut count = 1;
            for dir in axis.iter() {
                let (mut x, mut y) = (x as i8, y as i8);
                loop {
                    (x, y) = (x + dir[0], y + dir[1]);
                    if x < 0
                        || x >= 7
                        || y < 0
                        || y >= 6
                        || self.data[x as usize].1[y as usize].map_or(true, |p| p != self.player)
                    {
                        break;
                    }
                    count += 1;
                    if count >= 4 {
                        self.done = true;
                        return Some(Win(self.player));
                    }
                }
            }
        }
        self.player = self.player.next();
        Some(if self.filled >= 6 * 7 {
            self.done = true;
            Tie
        } else {
            Pass
        })
    }
}

#[derive(Debug)]
pub enum MoveOutcome<P> {
    Win(P),
    Tie,
    Pass,
}

pub trait GamePlayer: Copy + Clone + Eq + Send + Sync {
    fn first() -> Self;
    fn next(&self) -> Self;
}

pub trait GameMove: Copy + Clone + Send + Sync {}

pub trait Game<P: GamePlayer, M: GameMove>: Clone + Send + Sync {
    type Moves<'a>: Iterator<Item = M> + Sized
    where
        Self: 'a;
    fn current_player(&self) -> P;
    fn moves<'a>(&'a self) -> Self::Moves<'a>;
    fn apply(&mut self, m: M) -> Option<MoveOutcome<P>>;
}

mod bot;
mod four;
mod game;
mod pl2;

use bot::Bottable;
use crossterm::tty::IsTty;
use four::{Four, FourMove};
use game::*;
use pl2::BinaryPlayer;
use std::io::{self, BufRead, Write};

#[derive(Debug)]
enum Miscommunication {
    Io(io::Error),
    MoveParse,
    ModeParse,
}

impl From<io::Error> for Miscommunication {
    fn from(error: io::Error) -> Self {
        Self::Io(error)
    }
}

fn handle_outcome<P: GamePlayer>(mmeee: P, out: MoveOutcome<P>) -> (&'static str, bool) {
    match out {
        MoveOutcome::Win(p) => (
            if p == mmeee {
                "YIPPIEE I WINNER"
            } else {
                "nuuuu :("
            },
            false,
        ),
        MoveOutcome::Tie => ("meh", false),
        MoveOutcome::Pass => ("...", true),
    }
}

fn apply_debugged<P: GamePlayer, M: GameMove, T: Game<P, M> + std::fmt::Display>(
    mmeee: P,
    game: &mut T,
    m: M,
    istty: bool,
) -> bool {
    let (msg, out) = handle_outcome(mmeee, game.apply(m).expect("unexpected move failure"));
    if istty {
        eprintln!("{}{}", &game, msg);
    }
    out
}

use clap::Parser;

#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
struct Args {
    #[arg(short, long)]
    quite: bool,
    #[arg(short, long)]
    load: bool,
}

fn main() -> Result<(), Miscommunication> {
    let args = Args::parse();
    assert!(
        !(args.quite && args.load),
        "can't be load and quite at once..."
    );
    let mut game: Four<BinaryPlayer> = Four::new();
    let reader = io::stdin();
    let mut stdout = io::stdout();
    let istty = if !(args.quite || args.load) {
        reader.is_tty()
    } else {
        args.load
    };
    let mut reader = reader.lock().lines();
    let mmeee;
    loop {
        if istty {
            eprint!("> ");
        }
        match reader.next().ok_or(Miscommunication::ModeParse)??.as_str() {
            "f" => {
                mmeee = BinaryPlayer::first();
                let m = game.best_move().expect("first move fail");
                println!("{}", m);
                stdout.flush()?;
                assert!(
                    apply_debugged(mmeee, &mut game, m, istty),
                    "first move fail"
                );
                break;
            }
            "s" => {
                mmeee = BinaryPlayer::first().next();
                if istty {
                    eprintln!("{}", &game);
                }
                break;
            }
            _ => {
                if istty {
                    eprintln!("bad mode");
                }
            }
        }
    }
    let mut reader = reader.map(|l| l.map(|s| s.parse::<u8>()));
    loop {
        loop {
            let m = loop {
                if istty {
                    eprint!("{}> ", game.current_player());
                }
                let num = reader.next().ok_or(Miscommunication::MoveParse)??.ok();
                if let Some(m) = num.map(|num| FourMove::try_from(num).ok()).flatten() {
                    break m;
                }
            };
            let out = game.apply(m);
            match out {
                Some(out) => {
                    let (msg, out) = handle_outcome(mmeee, out);
                    if !out {
                        if istty {
                            eprintln!("{}{}", &game, msg);
                        }
                        return Ok(());
                    }
                    break;
                }
                None => (),
            }
        }
        let m = game.best_move().expect("no moves");
        println!("{}", m);
        stdout.flush()?;
        if !apply_debugged(mmeee, &mut game, m, istty) {
            break;
        }
    }
    Ok(())
}

mod four;
mod game;
mod pl2;
use four::*;
use game::*;
use pl2::*;

use clap::Parser;
use std::ffi::{OsStr, OsString};
use std::io::{self, BufRead, BufReader, Write};
use std::mem::drop;
use std::process::{Child, ChildStdin, ChildStdout, Command, Stdio};

struct Bot {
    pub proc: Child,
    pub read: Option<BufReader<ChildStdout>>,
    pub write: Option<ChildStdin>,
}

impl Bot {
    fn new<S: AsRef<OsStr>>(program: S) -> io::Result<Self> {
        let mut proc = Command::new(program)
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .spawn()?;
        let read = proc.stdout.take().map(|s| BufReader::new(s));
        let write = proc.stdin.take();
        Ok(Self { proc, read, write })
    }
}

#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
struct Args {
    bot_x: OsString,
    bot_o: OsString,
}

fn main() -> io::Result<()> {
    let args = Args::parse();
    println!("Player X: {:#?}", &args.bot_x);
    println!("Player O: {:#?}", &args.bot_o);
    let mut bots = [Bot::new(&args.bot_x)?, Bot::new(&args.bot_o)?];
    if let Some(s) = &mut bots[0].write {
        s.write(b"f\n")?;
    }
    if let Some(s) = &mut bots[1].write {
        s.write(b"s\n")?;
    }
    let mut game: Four<BinaryPlayer> = Four::new();
    let mut line = String::new();
    let mut stdout = io::stdout();
    let mut bot_read = bots
        .iter_mut()
        .map(|bot| bot.read.take().expect("no stdin"))
        .collect::<Vec<_>>();
    let mut bot_write = bots
        .iter_mut()
        .map(|bot| bot.write.take().expect("no stdout"))
        .collect::<Vec<_>>();
    'iter: for (from, to) in [(0, 1), (1, 0)].into_iter().cycle() {
        let from = &mut bot_read[from];
        let to = &mut bot_write[to];
        let pl = game.current_player();
        match 'read: {
            line.clear();
            print!("waiting for {}... ", pl);
            stdout.flush()?;
            if from.read_line(&mut line).is_err() {
                println!("fail");
                break 'read None;
            }
            println!("output: {:?}", &line);
            to.write(&line.as_bytes())?;
            to.flush()?;
            match line.strip_suffix("\n").unwrap().parse::<u8>() {
                Ok(m) => FourMove::try_from(m).ok(),
                Err(_) => None,
            }
        } {
            Some(m) => {
                let out = match game.apply(m) {
                    Some(out) => {
                        print!("{}: {}.{}", pl, m, &game);
                        out
                    }
                    None => {
                        println!("{}: invalid move ({}).", pl, m);
                        println!("{} wins.", pl.next());
                        break 'iter;
                    }
                };
                match out {
                    MoveOutcome::Win(p) => {
                        println!("{} wins.", p);
                        break 'iter;
                    }
                    MoveOutcome::Tie => {
                        println!("Tie.");
                        break 'iter;
                    }
                    MoveOutcome::Pass => {
                        println!("...");
                    }
                }
            }
            None => {
                println!("{} generated invalid output: {:?}", pl, &line);
                println!("{} wins.", pl.next());
                break 'iter;
            }
        }
    }
    drop((bot_read, bot_write));
    let exits: Vec<_> = bots
        .into_iter()
        .map(|c| c.proc)
        .map(|mut c| c.wait())
        .collect();
    for e in exits {
        e?;
    }
    Ok(())
}