#include "NetworkServer.hh"
#include "Engine.hh"
#include "Logger.hh"

#include <cassert>

NetworkServer::NetworkServer (GameState &state, const NetworkAddress &listen_addr) : 
    NetworkCore(state), netsession(NETWORK_MAGIC_ID), netobjs(netsession, NETCHAN_CORE) {
    
    // connect slots
    slots.connect(netsession.sig_node_connected(), this, &NetworkServer::on_node_connected);
    
    // and then we listen
    netsession.listen(listen_addr);

    Engine::log(INFO, "server") << "running, listen_addr=" << listen_addr;
}

void NetworkServer::on_node_connected (NetworkNode *node) {
    // create the player object (it logs it)
    NetworkServerPlayer *player = new NetworkServerPlayer(*this, node);

    // add to players
    players.push_back(player);
    
    // add to GameState
    state.newRemotePlayer(player);
}
        
void NetworkServer::handle_disconnect (NetworkServerPlayer *player) {
    // remove from state
    state.removePlayer(player);

    // remove from list
    players.remove(player);
}
        
NetworkServerPlayer::NetworkServerPlayer (NetworkServer &server, NetworkNode *node) : 
    RemotePlayer(server.state, Vector(PLAYER_INITIAL_X, PLAYER_INITIAL_Y), true), server(server), obj(server.netobjs), node(node) {
    
    // log
    Engine::log(INFO, "server_player.connected") << "node=" << node << ", obj=" << obj;

    // messages
    slots.connect(node->sig_disconnected(), this, &NetworkServerPlayer::on_disconnected);
    slots.connect(obj.sig_message(NETMSG_CLIENT_MOVE), this, &NetworkServerPlayer::on_move);

    // the initial NETMSG_PLAYER_HELLO
    NetworkPacket hello_pkt;
    hello_pkt.write_vector(position);

    obj.send_to(node, NETMSG_SERVER_HELLO, hello_pkt, true);

    // send other player objects
    for (std::list<NetworkServerPlayer*>::iterator it = server.players.begin(); it != server.players.end(); it++) {
        NetworkServerPlayer *player = *it;
        NetworkPacket player_pkt;
        
        // player is not in players list yet
        assert(player != this);
        
        player_pkt.write_vector(player->position);

        player->obj.send_to(node, NETMSG_PLAYER_INFO, player_pkt, true);
    }

    // broadcast NETMSG_PLAYER_JOIN to all clients except current
    obj.send_all_except(NETMSG_PLAYER_JOIN, hello_pkt, node, true);
}

void NetworkServerPlayer::on_disconnected (void) {
    NetworkPacket pkt;
    
    Engine::log(INFO, "server_player.disconnected") << "node=" << node << ", obj=" << obj;
    
    // remove from server
    server.handle_disconnect(this);
    
    // tell other clients
    obj.send_all(NETMSG_PLAYER_QUIT, pkt, true);

    // free
//    delete this;
}

void NetworkServerPlayer::on_move (NetworkNode *src, NetworkPacket &pkt) {
    // sanity-check
    if (src != node)
        return;
    
    Vector impulse_force = pkt.read_vector();
    uint16_t impulse_ms = pkt.read_uint16();

    Engine::log(INFO, "server_player.on_move") << "player=" << obj << ", old_pos=" << position << ", impulse=" << impulse_force << "@" << impulse_ms << "ms";
    
    // apply force
    applyForce(impulse_force, impulse_ms);

    // send position update
    send_position_update();
}
        
void NetworkServerPlayer::send_position_update (void) {
    NetworkPacket pkt;
    pkt.write_vector(position);
    pkt.write_vector(velocity);

    Engine::log(INFO, "server_player.send_position_update") << "obj=" << obj << " -> " << position << "+" << velocity;

    obj.send_all(NETMSG_PLAYER_POSITION, pkt, false);
}