/*
    Hurry Curry! - a game about cooking
    Copyright (C) 2026 Hurry Curry! Contributors

    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/>.

*/

pub mod record;
pub mod render;
pub mod replay;

use crate::{
    record::record,
    render::{RenderArgs, render},
    replay::replay,
};
use anyhow::Context;
use clap::Parser;
use futures_util::{SinkExt, StreamExt};
use hurrycurry_protocol::{Character, Message, PacketC, PacketS, PlayerClass};
use log::{LevelFilter, debug, error, info, warn};
use serde::{Deserialize, Serialize};
use std::{
    path::PathBuf,
    time::{Duration, SystemTime},
};
use tokio::{net::TcpListener, time::sleep};
use tokio_tungstenite::tungstenite::{self};

#[derive(Parser)]
enum Args {
    /// Connects as a spectator and saves the protocol packets for replay
    Record {
        /// Dont stop after the first game but restart instead
        #[arg(short, long)]
        r#loop: bool,
        url: String,
        output: PathBuf,
    },
    /// Starts a local server that replays previously recorded sessions
    Replay {
        input: PathBuf,
    },
    /// Runs a replay server and the client in movie mode to record that replay
    Render(#[command(flatten)] RenderArgs),
    DownloadMap {
        url: String,
        mapname: String,
    },
}

#[derive(Serialize, Deserialize)]
struct Event {
    ts: f64,
    packet: PacketC,
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    env_logger::builder()
        .filter_level(LevelFilter::Info)
        .parse_env("LOG")
        .init();

    rustls::crypto::ring::default_provider()
        .install_default()
        .unwrap();

    let args = Args::parse();

    match args {
        Args::Record {
            url,
            output,
            r#loop,
        } => loop {
            let out = if r#loop {
                output.join(format!(
                    "replay-{}",
                    SystemTime::now()
                        .duration_since(SystemTime::UNIX_EPOCH)
                        .unwrap()
                        .as_secs()
                ))
            } else {
                output.clone()
            };
            if let Err(e) = record(&out, &url).await {
                warn!("recording failed: {e:#}");
                sleep(Duration::from_secs(1)).await;
            }
            if r#loop {
                info!("restarting...");
            } else {
                break;
            }
        },
        Args::Replay { input } => {
            let ws_listener = TcpListener::bind("127.0.0.1:27032").await?;
            info!("listening for websockets on {}", ws_listener.local_addr()?);

            loop {
                replay(&ws_listener, &input).await?;
            }
        }
        Args::Render(a) => {
            render(a).await?;
        }
        Args::DownloadMap { url, mapname } => {
            download_map(&url, &mapname).await?;
        }
    }
    Ok(())
}

pub async fn download_map(url: &str, mapname: &str) -> anyhow::Result<()> {
    let (mut sock, _) = tokio_tungstenite::connect_async(url).await?;

    sock.send(tungstenite::Message::Text(
        serde_json::to_string(&PacketS::Join {
            name: "map downloader".to_string(),
            character: Character::default(),
            class: PlayerClass::Chef,
            id: None,
            position: None,
        })
        .unwrap()
        .into(),
    ))
    .await?;

    while let Some(Ok(message)) = sock.next().await {
        match message {
            tungstenite::Message::Text(line) => {
                let packet: PacketC = serde_json::from_str(&line).context("invalid packet")?;
                debug!("<- {packet:?}");

                match packet {
                    PacketC::Joined { id } => {
                        sock.send(tungstenite::Message::Text(
                            serde_json::to_string(&PacketC::Communicate {
                                player: id,
                                message: Some(Message::Text(format!("/download map {mapname}"))),
                                timeout: None,
                            })
                            .unwrap()
                            .into(),
                        ))
                        .await?;
                    }
                    PacketC::ServerMessage {
                        message: Message::Text(t),
                        ..
                    } => {
                        println!("{t}");
                        return Ok(());
                    }
                    _ => (),
                }
            }
            tungstenite::Message::Close(_) => {
                error!("connection closed by server");
                break;
            }
            _ => (),
        }
    }

    Ok(())
}
