use std::time::Duration;

use bevy::prelude::*;
use uuid::Uuid;

use super::{
    packet::{InboundPacket, OutboundPacket, Packet},
    peer::{Peer, PeerChangeEvent, PeerMap, PeerReceiveTiming, PeerSendTiming},
    queues::{NetworkReceive, NetworkSend},
};

pub fn handle_network_input(
    from_socket: Res<NetworkReceive>,
    peer_map: Res<PeerMap>,
    mut peers: Query<(&Peer, &mut PeerReceiveTiming)>,
    mut to_app: EventWriter<InboundPacket>,
    time: Res<Time>,
    mut change_peer: EventWriter<PeerChangeEvent>,
) -> Result {
    for (mut message, address) in from_socket.iter() {
        if message.len() < 16 {
            return Err(format!(
                "Message of length {} is not large enough to contain UUID",
                message.len()
            )
            .into());
        }
        let uuid = Uuid::from_slice(message.split_off(message.len() - 16).as_slice())?;
        if !message.is_empty() {
            to_app.write(InboundPacket(Packet::new(message, uuid)));
        }
        if let Some(peer_id) = peer_map.get(&uuid) {
            let (peer, mut last) = peers.get_mut(*peer_id)?;
            last.update(&time);
            if address == peer.addr {
                continue;
            }
        }
        change_peer.write(PeerChangeEvent::new(uuid, Some(address)));
    }
    Ok(())
}

pub fn handle_network_output(
    mut from_app: EventReader<OutboundPacket>,
    peer_map: Res<PeerMap>,
    mut peers: Query<(&Peer, &mut PeerSendTiming)>,
    config: Res<Config>,
    to_socket: Res<NetworkSend>,
    time: Res<Time>,
) -> Result {
    for packet in from_app.read() {
        let peer_id = peer_map.try_get(&packet.0.peer)?;
        let (peer, mut last) = peers.get_mut(*peer_id)?;
        // Append our UUID for client identification
        let message = [packet.0.message.as_slice(), config.id.as_bytes()].concat();
        to_socket.send(message, peer.addr)?;
        last.update(&time);
    }
    Ok(())
}

const TIMEOUT: Duration = Duration::from_secs(10);

pub fn heartbeat(
    peers: Query<(&Peer, &PeerSendTiming)>,
    time: Res<Time>,
    mut outbound: EventWriter<OutboundPacket>,
) {
    for (peer, last) in peers {
        // Allow for 2 consecutive missed heartbeats without timing out
        if last.time() + TIMEOUT / 3 > time.elapsed() {
            continue;
        }
        outbound.write(OutboundPacket(Packet::new(Vec::new(), peer.uuid)));
    }
}

pub fn timeout(
    peers: Query<(&Peer, &PeerReceiveTiming)>,
    time: Res<Time>,
    mut delete: EventWriter<PeerChangeEvent>,
) {
    for (peer, last) in peers {
        if let Some(previous) = last.time() {
            if previous + TIMEOUT < time.elapsed() {
                warn!("Peer {} timed out", peer.uuid);
                delete.write(PeerChangeEvent::new(peer.uuid, None));
            }
        }
    }
}

#[derive(Debug, Resource)]
pub struct Config {
    pub id: Uuid,
}

impl Config {
    pub fn new() -> Self {
        Self { id: Uuid::new_v4() }
    }
}