/*
    wearechat - generic multiplayer game with voip
    Copyright (C) 2025 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/>.
*/
pub mod network;

use anyhow::Result;
use clap::Parser;
use log::{debug, warn};
use network::ServerNetwork;
use std::net::{IpAddr, SocketAddr};
use weareshared::{
    packets::{Data, Packet},
    store::ResourceStore,
    tree::SceneTree,
};

#[derive(Parser, Debug)]
struct Args {
    #[arg(short, long, default_value = "::")]
    bind_addr: IpAddr,
    #[arg(short, long, default_value = "28555")]
    port: u16,
}

struct State {
    store: ResourceStore,
    tree: SceneTree,
}

fn main() -> Result<()> {
    env_logger::init_from_env("LOG");
    let args = Args::parse();

    let net = ServerNetwork::new(SocketAddr::new(args.bind_addr, args.port))?;
    let mut state = State::new()?;

    while let Ok((conn, packet)) = net.recv.recv() {
        if let Err(e) = state.handle_packet(conn, packet, &net) {
            warn!("state handler error: ({conn}) {e}");
        }
    }

    Ok(())
}

impl State {
    pub fn new() -> Result<Self> {
        Ok(Self {
            store: ResourceStore::new_persistent(
                &xdg::BaseDirectories::with_prefix("weareserver")?.place_cache_file("resources")?,
            )?,
            tree: SceneTree::default(),
        })
    }
    pub fn handle_packet(&mut self, conn: u128, packet: Packet, net: &ServerNetwork) -> Result<()> {
        self.tree.packet(&packet);
        match packet {
            Packet::Connect(_) => {
                for p in self.tree.prime_client() {
                    net.send(conn, p, true);
                }
            }
            Packet::Disconnect => {}
            Packet::RequestResource(resource) => {
                if let Some(r) = self.store.get(resource)? {
                    debug!("resource is cached");
                    net.send(conn, Packet::RespondResource(Data(r)), true);
                } else {
                    debug!("resource not cached, request is broadcast");
                    net.broadcast(Packet::RequestResource(resource), true);
                }
            }
            Packet::RespondResource(data) => {
                self.store.set(&data.0)?;
                net.broadcast(Packet::RespondResource(data), true);
            }
            Packet::Add(object, resource) => {
                net.broadcast(Packet::Add(object, resource), true);
            }
            Packet::Remove(object) => {
                net.broadcast(Packet::Remove(object), true);
            }
            Packet::Position(object, pos, rot) => {
                net.broadcast(Packet::Position(object, pos, rot), false);
            }
            Packet::Pose(object, vec) => {
                net.broadcast(Packet::Pose(object, vec), false);
            }
            Packet::Parent(parent, child) => {
                net.broadcast(Packet::Parent(parent, child), true);
            }
            Packet::Sound(object, vec) => {
                net.broadcast(Packet::Sound(object, vec), true);
            }
        }
        Ok(())
    }
}