/*
    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/>.
*/
#![feature(iter_array_chunks, mpmc_channel, array_chunks, new_zeroed_alloc)]
#![allow(clippy::too_many_arguments, clippy::type_complexity)]
pub mod armature;
pub mod audio;
pub mod camera;
pub mod download;
pub mod interfaces;
pub mod network;
pub mod render;
pub mod state;
pub mod window;
pub mod chat;

use anyhow::Result;
use clap::Parser;
use log::info;
use rand::random;
use std::{
    io::Write,
    net::{SocketAddr, TcpStream},
};
use weareshared::{helper::ReadWrite, packets::Packet};
use window::WindowState;
use winit::event_loop::EventLoop;

#[derive(Parser)]
struct Args {
    address: SocketAddr,
}

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

    #[cfg(feature = "deadlock_detection")]
    std::thread::spawn(deadlock_task);

    info!("connecting...");
    let mut sock = TcpStream::connect(args.address)?;
    Packet::Connect(random()).write(&mut sock)?;
    sock.flush()?;
    info!("connection established");
    let evloop = EventLoop::new()?;
    evloop.run_app(&mut WindowState::new(sock))?;

    Ok(())
}

#[cfg(feature = "deadlock_detection")]
fn deadlock_task() {
    let deadlocks = loop {
        std::thread::sleep(std::time::Duration::from_secs(1));
        let deadlocks = parking_lot::deadlock::check_deadlock();
        if !deadlocks.is_empty() {
            break deadlocks;
        }
    };
    for threads in &deadlocks {
        for t in threads {
            println!("thread {:#?}", t.thread_id());
            println!("{:#?}", t.backtrace());
        }
    }
}