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

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

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

impl Default for Config {
    fn default() -> Self {
        Self { id: Uuid::new_v4() }
    }
}

pub fn format_message(peer: Uuid, entity: Uuid, data: &Vec<u8>) -> Vec<u8> {
    [peer.as_bytes(), entity.as_bytes(), data.as_slice()].concat()
}

pub fn handle_network_input(
    from_socket: Res<NetworkReceive>,
    peer_map: Res<PeerMap>,
    mut peers: Query<(&PeerData, &mut PeerReceiveTiming)>,
    mut to_app: MessageWriter<InboundPacket>,
    time: Res<Time>,
    mut change_peer: MessageWriter<PeerChangeMessage>,
) -> Result {
    for (message, address) in from_socket.iter() {
        match Packet::try_from(message) {
            Ok(packet) => {
                if !packet.message.is_empty() {
                    to_app.write(packet.clone().into());
                }
                if let Some(peer_id) = peer_map.get(&packet.peer) {
                    let (peer, mut last) = peers.get_mut(*peer_id)?;
                    last.update(&time);
                    if address == peer.addr {
                        continue;
                    }
                }
                change_peer.write(PeerChangeMessage::new(packet.peer, Some(address)));
            }
            Err(err) => warn!("Error reading packet: {:?}", err),
        }
    }
    Ok(())
}

pub fn handle_network_output(
    mut from_app: MessageReader<OutboundPacket>,
    peer_map: Res<PeerMap>,
    mut peers: Query<(&PeerData, &mut PeerSendTiming)>,
    config: Res<Config>,
    to_socket: Res<NetworkSend>,
    time: Res<Time>,
) -> Result {
    for OutboundPacket(packet) in from_app.read() {
        let peer_id = peer_map.try_get(&packet.peer)?;
        let (peer, mut last) = peers.get_mut(*peer_id)?;
        let message = format_message(config.id, packet.entity, &packet.message);
        to_socket.send(message, peer.addr.into())?;
        last.update(&time);
    }
    Ok(())
}