#include <iostream>

#include "WebSocketServer.h"
#include "./Utils/StringTools.hpp"
#include "ConfigParser.hpp"
#include "./Utils/logger.hpp"

using websocketpp::lib::placeholders::_1;
using websocketpp::lib::placeholders::_2;
using websocketpp::lib::bind;


WebSocketServer::WebSocketServer(/* args */)
{
}

WebSocketServer::~WebSocketServer()
{
}

int WebSocketServer::parse_invite(vector<string>& vec_msg, std::string ip) {
    string net_type = "";
    if (StringTools::to_lower(vec_msg[1]) == "udp") {
        net_type = "udp";
    } else if (StringTools::to_lower(vec_msg[1]) == "tcp") {
        net_type = "tcp";
    }
    std::cout << "net type: " << vec_msg[1] << std::endl;
    
    std::cout << "invite   " << vec_msg[2] << ":" << vec_msg[3] << std::endl;
    int ret = -100;
    if ("udp" == net_type) {
        ret = sip_server.RequestInvite_UDP(vec_msg[2].c_str(), ip.c_str(), atoi(vec_msg[3].c_str()));
        // ret = sip_server.RequestInvite_UDP(vec_data[0].c_str(), "176.10.0.3", 30026);
    } else if ("tcp" == net_type)
    {
        /* code */
    }

    return ret;
}

string WebSocketServer::get_ip_from_hdl(websocketpp::connection_hdl hdl) {
    server::connection_ptr con = ws_server.get_con_from_hdl(hdl);
    // 获取客户端IP地址
    auto addr = con->get_socket().remote_endpoint().address().to_string();
    std::string ip = addr.substr(addr.find_last_of(":")+1);
    std::cout << "ip:" << ip << endl;
    return ip;
}

int WebSocketServer::msg_parser(websocketpp::connection_hdl hdl, string msg) {
    vector<string> vec_msg = StringTools::split(msg, "|");
    if (vec_msg.size() <= 0)  {
        return -1;
    }

    string ip = get_ip_from_hdl(hdl);

    string response_msg = "";

    int ret = -100;
    if ( StringTools::to_lower(vec_msg[0]) == "invite") {
        ret = parse_invite(vec_msg, ip);
        response_msg = vec_msg[2] + "_" + vec_msg[3] +"|" + vec_msg[0] + "|" + vec_msg[1] + "|" + to_string(ret);
        ws_server.send(hdl, response_msg, websocketpp::frame::opcode::text);
    } else if ( StringTools::to_lower(vec_msg[0]) == "bye") {
        if (StringTools::to_lower(vec_msg[1]) == "invite") {
            std::cout << "bye  invite: " << vec_msg[2] << std::endl;
            ret = sip_server.ByeInvite(vec_msg[2], ip, atoi(vec_msg[3].c_str()));
        }
    } else {
        std::cout << "on_message called with hdl: " << hdl.lock().get()
            << " and message: " << msg
            << std::endl;
    }

    return ret;
}

// Define a callback to handle incoming messages
void WebSocketServer::on_message(websocketpp::connection_hdl hdl, message_ptr msg) {

    if (msg->get_payload() == "stop-listening") {
        ws_server.stop_listening();
        return;
    }

    try {
        int ret = msg_parser(hdl,msg->get_payload());
        // 返回执行结果
        // ws_server.send(hdl, to_string(ret), websocketpp::frame::opcode::text);
    } catch (websocketpp::exception const & e) {
        std::cout << "Echo failed because: " << "(" << e.what() << ")" << std::endl;
        ws_server.send(hdl, to_string(-101), websocketpp::frame::opcode::text);
    }
}

void WebSocketServer::on_open(websocketpp::connection_hdl hdl)
{
    //   std::string msg = "hello";
    //   c.send(hdl, msg, websocketpp::frame::opcode::text);
    //   c.get_alog().write(websocketpp::log::alevel::app, "Tx: " + msg);
    std::cout << "连接sip服务器成功！" << std::endl;
}

void WebSocketServer::on_fail(websocketpp::connection_hdl h){
    std::cout << "连接sip服务器失败！" << std::endl;
}

void WebSocketServer::on_close(websocketpp::connection_hdl h){
    std::cout << "on_close" << std::endl;
}


void WebSocketServer::start() {
    ConfigParser* pConfig = ConfigParser::getInstance();
    if (!pConfig->init())
    {
        LOG_ERROR("get config failed!");
        return;
    }

    ServerInfo info = pConfig->getServerCfg();
    
    sip_server.Init(&info);

    try {
        // Set logging settings
        ws_server.set_access_channels(websocketpp::log::alevel::all);
        ws_server.clear_access_channels(websocketpp::log::alevel::frame_payload);

        // Initialize Asio
        ws_server.init_asio();

        // Register our message handler
        ws_server.set_message_handler(bind(&WebSocketServer::on_message,this,::_1,::_2));
        ws_server.set_open_handler(bind(&WebSocketServer::on_open, this, _1));
        ws_server.set_fail_handler(bind(&WebSocketServer::on_fail, this, _1));
        ws_server.set_close_handler(bind(&WebSocketServer::on_close, this, _1));

        // Listen on port 9002
        int port = info.getWsPort();
        std::cout << "websocket server listen:" << port << std::endl;
        ws_server.listen(port);

        // Start the server accept loop
        ws_server.start_accept();

        // Start the ASIO io_service run loop
        ws_server.run();
    } catch (websocketpp::exception const & e) {
        std::cout << e.what() << std::endl;
    } catch (...) {
        std::cout << "other exception" << std::endl;
    }
}