/*
    Hurry Curry! - a game about cooking
    Copyright 2024 metamuffin

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, version 3 of the License only.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.

*/
use anyhow::Result;
use clap::Parser;
use hurrycurry_bot::{algos::ALGO_CONSTRUCTORS, BotAlgo, BotInput};
use hurrycurry_client_lib::{network::sync::Network, Game};
use hurrycurry_protocol::{PacketC, PacketS, PlayerID};
use log::warn;
use std::{thread::sleep, time::Duration};

#[derive(Parser)]
struct Args {
    /// Bot player name, algo name by default
    #[arg(short, long)]
    username: Option<String>,
    /// Bot character id
    #[arg(short, long, default_value_t = 51)]
    character: i32,
    algo: String,
    /// Websocket address of the server
    address: String,
}

pub struct BotDriver {
    pub interacting: bool,
    id: PlayerID,
    state: Box<dyn BotAlgo>,
}

fn main() -> Result<()> {
    env_logger::init_from_env("LOG");
    rustls::crypto::ring::default_provider()
        .install_default()
        .unwrap();

    let args = Args::parse();

    let mut network = Network::connect(&args.address)?;

    let mut game = Game::default();

    network.queue_out.push_back(PacketS::Join {
        name: format!("{}-bot", args.username.clone().unwrap_or(args.algo.clone())),
        character: args.character,
        id: None,
    });

    let mut bots = Vec::new();

    loop {
        let dt = 1. / 50.;

        network.poll()?;

        while let Some(packet) = network.queue_in.pop_front() {
            match &packet {
                PacketC::Joined { id } => bots.push(BotDriver {
                    id: *id,
                    interacting: false,
                    state: ALGO_CONSTRUCTORS
                        .iter()
                        .find(|(n, _)| n == &args.algo)
                        .map(|(_, c)| c())
                        .expect(&format!("unknown algo {:?}", args.algo)),
                }),
                PacketC::Error { message } => {
                    warn!("server error message: {message}");
                }
                _ => (),
            }
            game.apply_packet(packet);
        }

        bots.retain_mut(|b| {
            let BotInput {
                direction,
                boost,
                interact,
                leave,
                extra,
            } = b.state.tick(b.id, &game, dt);

            if leave {
                network.queue_out.push_back(PacketS::Leave { player: b.id });
                return false;
            }

            if interact.is_some() != b.interacting {
                b.interacting = interact.is_some();
                network.queue_out.push_back(PacketS::Interact {
                    player: b.id,
                    pos: interact,
                })
            }
            network.queue_out.push_back(PacketS::Movement {
                player: b.id,
                dir: direction,
                boost,
                pos: None,
            });
            network.queue_out.extend(extra);
            true
        });

        sleep(Duration::from_secs_f32(dt));
    }
}