#include "ClientConnector.hpp"
#include "ClientsManager.hpp"
#include "ofThread.h"
#include "ofxGui.h"
#include "ofxTimeMeasurements.h"

namespace ofxCloudLib
{

ClientConnector::ClientConnector(int start_port, int tcp_port, int osc_port,
                                 std::string client_name, ofxCloudLib::ClientsManager &manager,
                                 int index)
    : ofxTCPClient(), AbstractClient(client_name, index), ofThread()
{
    xyz_receiver_.setCodec(ofxSquash::Codec(CLOUDCLIENT_DESIREDCODEC));
    rgb_receiver_.setCodec(ofxSquash::Codec(CLOUDCLIENT_DESIREDCODEC));
    depth_receiver_.setCodec(ofxSquash::Codec(CLOUDCLIENT_DESIREDCODEC));

    xyz_receiver_.init(start_port);
    rgb_receiver_.init(start_port + 1);
    depth_receiver_.init(start_port + 2);

    tcp_port_ = tcp_port;
    osc_port_ = osc_port;

    last_mesh_.setMode(OF_PRIMITIVE_POINTS);
    sticky_mesh_.setMode(OF_PRIMITIVE_POINTS);

    startThread();
}

ClientConnector::~ClientConnector()
{
    aggregated_.close();
    waitForThread(true);
}

void ClientConnector::threadedFunction()
{
    ofMesh fresh_mesh;
    while (1) {
        xyz_receiver_.update();
        if (xyz_receiver_.isFrameNew()) {
            fresh_mesh.clear();
            cloud_counter_++;
            xyz_receiver_.receive(fresh_mesh);
            if (fresh_mesh.getNumVertices()) {
                fresh_mesh.removeVertex(0);
            }
            TS_START("Client::send channel thread");
            aggregated_.send(std::move(fresh_mesh));
            TS_STOP("Client::send channel thread");
            // std::cout << "NEW CLOUD IN THREAD " << client_name_ << "#" << cloud_counter_ << std::endl;
        } else {

            handle_connection();

            // TS_START("Client::sleep()");

            // std::this_thread::sleep_for(std::chrono::milliseconds(10));

            // TS_STOP("Client::sleep()");
        }
    }
}

bool ClientConnector::is_xyz_new()
{
    if (is_new_) {
        is_new_ = false;
        return true;
    }
    return false;
}

void ClientConnector::setup()
{
    AbstractClient::setup();
    // de l'extérieur!
    gui_.add(parameters_);
    gui_.add(cropper_parameters_);
}

void ClientConnector::receive_mesh()
{

    while (aggregated_.tryReceive(last_mesh_)) {
        // std::cout << "...NEW FRAME IN THREAD A " << client_name_ << std::endl;
        is_new_ = true;
    }

    /*
    ofMesh tmp_mesh;
    //            tmp_mesh.append(sticky_mesh_);
    //            sticky_mesh_.clear();
    if (xyz_receiver_.isFrameNew()) {

        cloud_counter_++;
        for (const auto &v : last_mesh_.getVertices()) {
            if (v != zero_ && ofRandom(100) < 10) {
                tmp_mesh.addVertex(v);
                tmp_mesh.addColor(cloud_color_);
            }
        }
        xyz_receiver_.receive(last_mesh_);
        last_mesh_.removeVertex(0);
    }


*/
    //            for (unsigned int i=0;i<tmp_mesh.getNumVertices();i++) {
    //                auto color = tmp_mesh.getColors()[i];
    //                color.a = color.a * .55;
    //                if (color.a > .05) {
    //                    if (ofRandom(100)<1) {
    //                        color.a = color.a+0.5;
    //                    }
    //                    auto v = tmp_mesh.getVertices()[i];
    //                    v.x = v.x+ofRandom(-.1,.1);
    //                    v.y = v.y+ofRandom(-.1,.1);
    //                    v.z = v.z+ofRandom(-.1,.1);
    //                    sticky_mesh_.addVertex(v);
    //                    sticky_mesh_.addColor(color);
    //                }
    //            }
}

void ClientConnector::draw()
{
    ofSetColor(cloud_color_);
    ofDrawSphere(zero_, .075);

    ofPushMatrix();
    ofTranslate(zero_);
    ofDrawBitmapStringHighlight(etiquette_, 0, 0);
    ofTranslate(ofVec3f(0, -.15, 0));
    ofDrawBitmapStringHighlight(ofToString(cloud_counter_) + ": " +
                                    ofToString(last_mesh_.getNumVertices()),
                                0, 0);
    ofPopMatrix();

    last_mesh_.drawWireframe();

    //        ofEnableBlendMode(OF_BLENDMODE_ALPHA); //TODO trouver bug...
    //        sticky_mesh_.drawWireframe();
}

void ClientConnector::update()
{
    // handle_connection();
}

void ClientConnector::handle_connection()
{


    //        if (dead_client_) return;
    TS_START("ClientConnector::handle_connection()");

    bool res = false;

    res = isConnected();

    if (res) {


      //SYNC  if (sync_active_) osc_sync_.update();

        // xyz_receiver_.update();

        // rgb_receiver_.update();
        // depth_receiver_.update();

        string str = receive();
        if (str.length() > 0) {

            // std::cout << "PROCESSING TCP STREAM FROM " << client_name_ << ":" << str << std::endl;

            boost::char_separator<char> sep(" ");
            boost::tokenizer<boost::char_separator<char>> tokens(str, sep);

            vector<std::string> message;
            for (const auto &t : tokens) {
                message.push_back(t);

                // std::cout << "  tokens:" << t << std::endl;
            }

            lock();

            if (message.size() == 0) {
                std::cout << "TCP erreur: message vide" << std::endl;
            } else if (message[0] == "zero") {

                if (message.size() == 5) {

                    zero_.x = std::atof(message[2].c_str());
                    zero_.y = std::atof(message[3].c_str());
                    zero_.z = std::atof(message[4].c_str());

                } else {
                    std::cout << "TCP erreur: pas 5 elems dans message zero" << std::endl;
                }
            } else if (message[0] == "parameter") {

           //SYNC     osc_sync_.setup((ofParameterGroup &)gui_.getParameter(), 6666, client_name_, 6667);

                // de l'extérieur??

                if (!parameters_.update_parameter_from_strings(message)) {
                    cropper_parameters_.update_parameter_from_strings(message);
                }

          //SYNC      osc_sync_.setup((ofParameterGroup &)gui_.getParameter(), 6666, client_name_, OSCCLIENT_SYNCPORT);

            } else if (message[0] == "sync_ready") {

                send("trigger_request");

            } else if (message[0] == "etiquette") {

                if (message.size() == 3) {

                    etiquette_ = message[2];
                    AbstractClient::update_gui_name(etiquette_);

                } else {
                    std::cout << "TCP erreur: pas 3 elems dans message etiquette"
                              << std::endl;
                }
            } else if (message[0] == "color") {

                if (message.size() == 5) {

                    cloud_color_.r = std::atoi(message[2].c_str());
                    cloud_color_.g = std::atoi(message[3].c_str());
                    cloud_color_.b = std::atoi(message[4].c_str());
                    cloud_color_.a = 255;

                } else {
                    std::cout << "TCP erreur: pas 5 elems dans message couleur"
                              << std::endl;
                }
            } else {
                std::cout << "got TCP unknown msg from " << client_name_ << ":" << str
                          << std::endl;
            }
            unlock();
            // std::cout << "DONE PROCESSING TCP STREAM FROM " << client_name_ << std::endl;
        }

    } else {

        delta_time_ = ofGetElapsedTimeMillis() - connect_time_;

        if (delta_time_ > reconnect_time_) {
            if (ofxTCPClient::setup(client_name_, tcp_port_)) {
                setMessageDelimiter("\n");
                std::string info = "ports = " + ofToString(xyz_receiver_.getPort()) +
                                   " " + ofToString(rgb_receiver_.getPort()) + " " +
                                   ofToString(depth_receiver_.getPort());
                send("hello from server");
                send(info);
         //SYNC       osc_sync_.setup((ofParameterGroup &)gui_.getParameter(), 6666,   client_name_, OSCCLIENT_SYNCPORT);
                //                    osc_sync_.setup((ofParameterGroup&)gui_.getParameter(),osc_port_,client_name_,OSCCLIENT_SYNCPORT);

                send("sync : " + ofToString(osc_port_));
                std::cout << "synching " << client_name_ << ":" << osc_port_
                          << std::endl;
                sync_active_ = true;

            } else {
                std::cout << "ClientConnector:: problem with TCP connexion to " << client_name_ << ":" << tcp_port_ << std::endl;
                //                    sync_active_ = false;
                //                    std::cout << "can't setup -- destroy?" <<
                //                    std::endl;
                //                    dead_client_ = true;
                //                    close();
            }
            connect_time_ = ofGetElapsedTimeMillis();
        }
    }
    TS_STOP("ClientConnector::handle_connection()");
}
}