/*
    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 crate::{data::DataIndex, game::Game};
use anyhow::{anyhow, bail, Result};
use clap::{Parser, ValueEnum};
use hurrycurry_protocol::{Message, PacketC, PacketS, PlayerID};
use log::{debug, trace};
use std::{collections::VecDeque, time::Duration};
use tokio::sync::broadcast::Sender;

pub struct State {
    index: DataIndex,
    packet_out: VecDeque<PacketC>,
    tx: Sender<PacketC>,
    pub game: Game,
}

#[derive(Parser)]
#[clap(multicall = true)]
enum Command {
    /// Start a new game
    Start {
        /// Gamedata specification
        #[arg(default_value = "junior")]
        spec: String,
        /// Duration in seconds
        #[arg(default_value = "420")]
        timer: u64,
    },
    /// Abort the current game
    End,
    /// Download recipe/map's source declaration
    Download {
        /// Resource kind
        #[arg(value_enum)]
        r#type: DownloadType,
        /// Name
        name: String,
    },
    /// List all recipes and maps
    List,
    /// Send an effect
    Effect { name: String },
    /// Send an item
    Item { name: String },
    /// Reload the resource index
    ReloadIndex,
    /// Reload the current map
    #[clap(alias = "r")]
    Reload,
}

#[derive(ValueEnum, Clone)]
enum DownloadType {
    Map,
    Recipes,
}

impl State {
    pub async fn new(tx: Sender<PacketC>) -> Result<Self> {
        let mut index = DataIndex::default();
        index.reload()?;

        let mut packet_out = VecDeque::new();
        let mut game = Game::new();
        game.load(
            index.generate("lobby-none".to_string()).await?,
            None,
            &mut packet_out,
        );

        Ok(Self {
            game,
            index,
            tx,
            packet_out,
        })
    }

    pub async fn tick(&mut self, dt: f32) -> anyhow::Result<()> {
        if self.game.tick(dt, &mut self.packet_out) {
            self.game.load(
                self.index.generate("lobby-none".to_string()).await?,
                None,
                &mut self.packet_out,
            );
        }
        while let Some(p) = self.packet_out.pop_front() {
            if matches!(p, PacketC::UpdateMap { .. } | PacketC::Position { .. }) {
                trace!("-> {p:?}");
            } else {
                debug!("-> {p:?}");
            }
            self.tx.send(p).unwrap();
        }
        Ok(())
    }
    pub async fn packet_in(&mut self, player: PlayerID, packet: PacketS) -> Result<Vec<PacketC>> {
        let mut replies = Vec::new();
        match &packet {
            PacketS::Communicate {
                message: Some(Message::Text(text)),
                persist: false,
            } if let Some(command) = text.strip_prefix("/") => {
                match self.handle_command_parse(player, command).await {
                    Ok(()) => return Ok(vec![]),
                    Err(e) => {
                        return Ok(vec![PacketC::ServerMessage {
                            text: format!("{e}"),
                        }]);
                    }
                }
            }
            _ => (),
        }
        self.game
            .packet_in(player, packet, &mut replies, &mut self.packet_out)?;
        if self.game.players.is_empty() && !self.game.lobby {
            self.tx
                .send(PacketC::ServerMessage {
                    text: "Game was aborted automatically due to a lack of players".to_string(),
                })
                .ok();
            self.game.load(
                self.index.generate("lobby-none".to_string()).await?,
                None,
                &mut self.packet_out,
            );
        }
        Ok(replies)
    }

    async fn handle_command_parse(&mut self, player: PlayerID, command: &str) -> Result<()> {
        self.handle_command(
            player,
            Command::try_parse_from(
                shlex::split(command)
                    .ok_or(anyhow!("quoting invalid"))?
                    .into_iter(),
            )?,
        )
        .await?;
        Ok(())
    }

    async fn handle_command(&mut self, player: PlayerID, command: Command) -> Result<()> {
        match command {
            Command::Start { spec, timer } => {
                let data = self.index.generate(spec).await?;
                self.game
                    .load(data, Some(Duration::from_secs(timer)), &mut self.packet_out);
            }
            Command::End => {
                self.tx
                    .send(PacketC::ServerMessage {
                        text: format!(
                            "Game was aborted by {}.",
                            self.game
                                .players
                                .get(&player)
                                .ok_or(anyhow!("player missing"))?
                                .name
                        ),
                    })
                    .ok();
                self.game.load(
                    self.index.generate("lobby-none".to_string()).await?,
                    None,
                    &mut self.packet_out,
                );
            }
            Command::Reload => {
                if self.game.count_chefs() > 1 {
                    bail!("must be at most one player to reload");
                }
                self.game.load(
                    self.index.generate(self.game.data.spec.to_string()).await?,
                    None,
                    &mut self.packet_out,
                );
            }
            Command::ReloadIndex => {
                self.index.reload()?;
            }
            Command::Download { r#type, name } => {
                let source = match r#type {
                    DownloadType::Map => self.index.read_map(&name).await,
                    DownloadType::Recipes => self.index.read_recipes(&name).await,
                }?;
                bail!("{source}");
            }
            Command::List => {
                bail!(
                    "Maps: {:?}\nRecipes: {:?}",
                    self.index.maps.keys().collect::<Vec<_>>(),
                    self.index.recipes
                )
            }
            Command::Effect { name } => {
                self.tx
                    .send(PacketC::Communicate {
                        player,
                        message: Some(Message::Effect(name)),
                        persist: false,
                    })
                    .ok();
            }
            Command::Item { name } => {
                let item = self
                    .game
                    .data
                    .get_item_by_name(&name)
                    .ok_or(anyhow!("unknown item"))?;
                self.tx
                    .send(PacketC::Communicate {
                        player,
                        message: Some(Message::Item(item)),
                        persist: false,
                    })
                    .ok();
            }
        }
        Ok(())
    }
}