#include "sf_object.hpp"
#include <iostream>

using namespace skyfire;

// 1. 类继承自sf_object
class A: public sf_object
{
    // 2. 注册一个信号，信号名称为s1，参数列表为int
    SF_REG_SIGNAL(s1, int)
};

// 3.定义一个槽函数，参数列表与信号参数列表一致
void slot1(int a)
{
    std::cout<<std::this_thread::get_id()<<" "<<a<<std::endl;
}

int main()
{
    A a;
    // 4.绑定信号与槽， 对象指针（可以是智能指针），信号名称，槽，是否使用消息队列
    sf_bind_signal(&a, s1, slot1, false);
    sf_bind_signal(&a, s1, slot1, true);
    a.s1(56);

    sf_eventloop e;
    // 5.启动事件循环
    e.exec();
}

#include "sf_object.hpp"
#include <iostream>
using namespace skyfire;

// 1.对象继承自sf_object
class A : public sf_object
{
public:
    // 2. 注册aop成员函数，会生成aop_xxx函数
    SF_REG_AOP(func, int , int)
    int func(int a, int b)
    {
        std::cout<<a+b<<std::endl;
        return a+b;
    }
};

// 3.定义一个函数，使其插入到函数调用前，参数列表与要注入的函数相同
void before_call(int a,int b)
{
    std::cout<<"a="<<a<<",b="<<b<<std::endl;
}

// 4.定义一个函数，使其插入到函数调用后，参数列表与要注入的函数返回类型
void after_call()
{
    std::cout<<"call finished"<<std::endl;
}

int main()
{
    A a;
    // 5.注入before_call，参数为 对象指针、成员函数名称、注入函数名称, 返回注入id，可用此id撤销注入
    auto id = sf_aop_before_bind(&a, func, before_call);
    // 6. 同样也支持lambda
    sf_aop_before_bind(&a, func, [](int a,int b){
        std::cout<<"this is lambda, a="<<a<<",b="<<b<<std::endl;
    });
    // 7. 注入after_call
    sf_aop_after_bind(&a, func, after_call);
    // 8. 调用函数
    a.aop_func(5,10);

    // 输出:
    //    this is lambda, a=5,b=10
    //    a=5,b=10
    //    15
    //    call finished

    // 9.撤销注入
    sf_aop_before_unbind(&a, func, id);
    a.aop_func(5,10);

    // 输出：
    //    this is lambda, a=5,b=10
    //    15
    //    call finished
}

#include "sf_event_waiter.hpp"
#include "sf_timer.hpp"
#include <iostream>

using namespace skyfire;


sf_timer timer;

int main()
{
    std::cout<<"开始"<<std::endl;
    timer.start(5000, true);
    // 1. 等待超时
    sf_wait(&timer, timeout);
    std::cout<<"结束"<<std::endl;
}

#include "sf_finally.hpp"
#include <iostream>

using namespace skyfire;
using namespace std;

int main()
{
    int *p = new int;
    // 1. 注册一个删除函数，在作用域结束的时候执行（后执行）
    sf_finally del_p([&](){
        delete p;
        cout<<"Delete p"<<endl;
    });
    {
        int *q = new int;
        // 2. 注册一个删除函数，在作用域结束的时候执行（先执行）
        sf_finally del_q([&](){
            delete q;
            cout<<"Delete q"<<endl;
        });
    }
}

#include "sf_thread_pool.hpp"
#include <iostream>

using namespace skyfire;


void func()
{
    for(int i=0;i<10;++i)
    {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        std::cout<<std::this_thread::get_id()<<" "<<i<<std::endl;
    }
}

void func2(int a)
{
    for(int i=0;i<a;++i)
    {
        std::cout<<i<<std::endl;
    }
}


int main()
{
    // 1. 创建线程池
    sf_thread_pool pool4(4);
    // 2.添加任务
    pool4.add_task(std::bind(func2, 10));
    // 3.等待所有任务完成
    pool4.wait_all_task_finished();
    pool4.add_task(func2, 7);
    pool4.add_task(func);
    pool4.wait_all_task_finished();
    pool4.add_task([](int a)
                   {
                       for (auto i = 0; i < 5; ++i)
                       {
                           std::cout << "hello world" << std::endl;
                       }
                   }, 5);
    pool4.wait_all_task_finished();
}

#include "sf_tcp_server.hpp"

using namespace skyfire;

int main()
{
    // 1.创建服务器
    auto server = sf_tcp_server::make_server(true);
    // 2.监听
    if(!server->listen("0.0.0.0",9988))
    {
        std::cout<<"listen on 9988 error"<<std::endl;
        return -1;
    }
    // 3.设置数据到来事件响应
    sf_bind_signal(server,raw_data_coming,[=](SOCKET sock, const byte_array& data){
        std::cout<<"recv:"<<to_string(data)<<std::endl;
    },true);
    // 4. 启动消息循环
    sf_eventloop loop;
    loop.exec();
}

#include "sf_tcp_nat_traversal_server.hpp"

#include <iostream>

using namespace skyfire;

int main(){
    g_logger->add_level_stream(SF_DEBUG_LEVEL,&std::cout);
    // 1. 创建nat穿透server
    auto pserver = sf_tcp_nat_traversal_server::make_server();
    std::cout<<"port:"<<std::flush;
    unsigned short port;
    std::cin>>port;
    // 2.监听端口
    auto ret = pserver->listen("0.0.0.0",port);
    if(ret){
        std::cout<<"监听成功"<<std::endl;
    }else{
        std::cout<<"监听失败"<<std::endl;
    }

    // 3. 启动事件循环
    sf_eventloop loop;
    loop.exec();
}

#include "sf_tcp_nat_traversal_client.hpp"
#include <iostream>
#include <sf_timer.hpp>

using namespace skyfire;

void connect(std::shared_ptr<sf_tcp_nat_traversal_client> client){
    std::string ip;
    unsigned short port;
    std::cout<<"ip:"<<std::flush;
    getline(std::cin,ip);
    std::cout<<"port:"<<std::flush;
    std::cin>>port;
    std::cin.clear();
    if(client->connect_to_server(ip,port)){
        std::cout<<"连接成功"<<std::endl;
    }else{
        std::cout<<"连接失败"<<std::endl;
    }
}

void ls(std::shared_ptr<sf_tcp_nat_traversal_client> client){
    auto clients = client->get_clients();
    for(auto &p:clients){
        std::cout<<p<<std::endl;
    }
}

void nat_conn(std::shared_ptr<sf_tcp_nat_traversal_client> client){
    unsigned long long id;
    std::cout<<"id:"<<std::flush;
    std::cin>>id;
    std::cin.clear();
    client->connect_to_peer(id, false);
}

void send(std::shared_ptr<sf_tcp_nat_traversal_connection> conn) {
    if(!conn){
        std::cout<<"连接未建立"<<std::endl;
        return;
    }
    std::cout<<"msg:"<<std::flush;
    std::string msg;
    getline(std::cin,msg);
    conn->send(TCP_PKG_TYPE_USER + 1,sf_serialize_binary(msg));
}


int main() {

    g_logger->add_level_stream(SF_DEBUG_LEVEL,&std::cout);
    // 1.创建nat穿透客户端
    auto pclient = sf_tcp_nat_traversal_client::make_client();
    std::shared_ptr<sf_tcp_nat_traversal_connection> conn;

    // 2.设新连接到来响应
    sf_bind_signal(pclient, new_nat_connection, [&](std::shared_ptr<sf_tcp_nat_traversal_connection> conn_t, int){
        std::cout<<"new connection!"<<std::endl;
        conn = conn_t;
        sf_bind_signal(conn, data_coming, [](const sf_pkg_header_t &header, const byte_array &data){
            std::string msg;
            sf_deserialize_binary(data,msg,0);
            std::cout<<"Recv:"<<msg<<std::endl;
        }, true);
    },true);

    while(true){
        std::string cmd;
        std::cout<<">"<<std::flush;
        getline(std::cin,cmd);
        if(cmd == "exit"){
            break;
        }
        // 3.连接
        if(cmd == "conn"){
            connect(pclient);
        }else if(cmd == "ls"){ // 4.枚举客户端
            ls(pclient);
        }else if(cmd == "natconn"){ // 5.连接客户端
            nat_conn(pclient);
        }else if(cmd == "id"){ // 6.获取id
            std::cout<<pclient->get_id()<<std::endl;
        }else if(cmd == "send"){ // 7.发送消息
            send(conn);
        }
    }
}

#include <iostream>
// 1.SF_LOGGER_STANDALONE宏表示单独使用sf_logger，不必依赖其他sflib库
#define SF_LOGGER_STANDALONE
// 2.SF_DEBUG表示启用sf_debug宏
#define SF_DEBUG
#include "sf_logger.hpp"

using namespace skyfire;


int main()
{
    // 3.获取单例对象
    auto logger = sf_logger::get_instance();
    // 4.添加日志文件，SF_WARN_LEVEL以上的日志级别将会打印到此文件中
    logger->add_level_file(SF_WARN_LEVEL, "runlog.log");
    // 5.SF_INFO_LEVEL以上的日志级别将会打印到标准输出流
    logger->add_level_stream(SF_INFO_LEVEL, &std::cout);
    // 6.日志打印
    sf_error("hello", "world");
    sf_warn("this is warn");
    sf_error("hello", "world");
    sf_warn("this is warn");
    getchar();
    g_logger->stop_logger();
    getchar();
}

#include "sf_rpc_server.hpp"
#include <iostream>

using namespace skyfire;

void print()
{
    std::cout<<"print"<<std::endl;
}

std::vector<int> add_one(std::vector<int> data)
{
    for(auto &p: data)
    {
        ++p;
    }
    return data;
}

void output(const char *str)
{
    std::cout<<str<<std::endl;
}

int main()
{
    // 1.创建server对象
    auto server = sf_rpc_server::make_server();
    // 2.注册rpc函数
    server->reg_rpc_func("print", print);
    server->reg_rpc_func("add_one", add_one);
    // 3.监听
    std::cout<<server->listen("127.0.0.1",10001)<<std::endl;
    sf_eventloop event_loop;
    // 4.启动时间循环
    event_loop.exec();
}

#include <iostream>
#include "sf_rpc_client.hpp"

using namespace skyfire;
using namespace std::literals;

void disp_vec(std::vector<int> data)
{
    for(auto p: data)
    {
        std::cout<<p<<" "<<std::flush;
    }
    std::cout<<std::endl;
}

int main()
{
    // 1.创建rpc客户端
    auto client = sf_rpc_client::make_client();
    // 2.连接rpc服务器
    if (!client->connect_to_server("127.0.0.1", 10001))
    {
        std::cout << "connect error" << std::endl;
        return -1;
    }
    // 3.同步调用，无返回值
    client->call<>("print"s);
    std::cout<<"call finished"<<std::endl;
    std::vector<int> data = {9,5,6,7,41,23,4,5,7};
    disp_vec(data);
    // 4.同步调用，返回sf_tri_type<vector<int>>，使用*解引用（需要显式指明返回值类型）
    data = *client->call<std::vector<int>>("add_one"s, data);
    disp_vec(data);
    std::cout<<"---------"<<std::endl;
    // 5.异步调用，第二个参数为参数为rpc函数返回类型的回调函数（需要显式指明返回值类型）
    client->async_call<std::vector<int>>("add_one"s, disp_vec, data);
    getchar();
}

#include <iostream>
#include "sf_msg_bus_server.hpp"

using namespace skyfire;

int main()
{
    // 1.创建一个消息总线服务器
    auto server = sf_msg_bus_server::make_server();
    // 2.监听
    server->listen("127.0.0.1", 5678);
    std::string type;
    std::string data;
    while(true)
    {
        // 3.输入并往总线上投递消息
        std::cout<<"type:"<<std::flush;
        std::cin>>type;
        if(type == "quit")
            break;
        std::cout<<"data:"<<std::flush;
        std::cin>>data;
        server->send_msg(type, sf_serialize_binary(data));
    }
    // 4.关闭总线
    server->close();
}

#include <iostream>
#include "sf_msg_bus_client.hpp"

using namespace skyfire;

int main()
{
    // 1. 生成客户端
    auto client = sf_msg_bus_client::make_client();
    // 2. 连接到消息总线服务器
    client->connect_to_server("127.0.0.1", 5678);
    // 3. 添加事件到来相应
    sf_bind_signal(client, msg_come, [](std::string, byte_array data){
        std::string str;
        sf_deserialize_binary(data, str, 0);
        std::cout<<"msg_come:"<<str<<std::endl;
        }, true);
    std::string type;
    std::cin>>type;
    // 4. 注册消息
    client->reg_msg_to_bus(type);
    sf_eventloop e;
    // 5.事件循环
    e.exec();
}

#include "sf_http_static_router.hpp"
#include "sf_http_server.hpp"

using namespace std::literals;

using namespace skyfire;

void upload_file_route(const sf_http_request &req,sf_http_response& res) {
    // 判断请求类型是否为分块请求
    if(req.is_multipart_data())
    {
        std::string ret_str;
        // 获取请求头
        auto header = req.get_multipart_data_context().header;
        for(auto &p:header)
        {
            ret_str += p.first + ":" + p.second + "\n";
        }
        ret_str += "-----------header end-------------\n";
        // 获取分块
        auto multipart = req.get_multipart_data_context().multipart;
        for (auto &p: multipart)
        {
            // 获取分块请求头
            auto tmp_header = p.get_header().get_header();
            for (auto &q:tmp_header)
            {
                ret_str += q.first + ":" + q.second + "\n";
            }
            ret_str += "temp filename:" + p.get_filename() + "\n--------------------------\n\n";
        }
        // 将上述拼接的头信息拼装至body返回
        res.set_body(to_byte_array(ret_str));
    }
    else
    {
        res.set_body(to_byte_array("upload ok, no file"s));
        sf_http_cookie_t cookie;

        cookie.path = req.get_request_line().url;
        cookie.key="token";
        cookie.value=sf_random::get_instance()->get_uuid_str();
        // 添加cookie
        res.add_cookie(cookie);
        cookie.key="time";
        cookie.value = sf_make_http_time_str();
        cookie.http_only = false;
        res.add_cookie(cookie);
    }

    res.set_status(200);
}

void websocket_route(const sf_websocket_param_t& param)
{
    // 如果类型为文本，返回hello:原内容
    if(param.type == websocket_data_type::TextData){
        param.p_server->send_websocket_data(param.sock,"hello:" + param.text_msg);
    } else{
        std::cout<<"binary data"<<std::endl;
    }
}


int main() {
    // 1. 生成一份http server配置
    sf_http_server_config config;
    config.host = "0.0.0.0";        // 监听ip
    config.port = 8080;             // 端口
    config.thread_count = 8;        // 线程数量
    config.request_timeout = 30;    // http请求超时
    // 2. 根据配置生成一个http server
    auto server = sf_http_server::make_server(config);

    // 3. 添加一个http路由，地址为/upload_file， 回调函数为upload_file_route，方法为所有
    server->add_router(make_http_router(
            "/upload_file"s,
            upload_file_route,
            std::vector<std::string>{{"*"s}}
    ));

    // 4. 同样支持lambda
    server->add_router(make_http_router(
            "/user/(.*)/name"s,
            // 使用lambda时需要使用function包装一下，例子中第一个string参数会接收整个url，第二个会接收(.*?)匹配的url，规则与<regex>相同
            std::function([](const sf_http_request &req,sf_http_response& res, std::string, std::string user){
                res.set_body(to_byte_array(user+"'s name is skyfire"s));
            }),
            std::vector<std::string>{{"GET"s}}
            ));

    // 5. 添加一个websocket路由，地址为/ws，回调函数为websocket_route
    server->add_router(make_websocket_router("/ws", websocket_route));

    // 6. 设置一个静态资源路由，位置为"../test/test_http_server/testWebsite"，请求为所有，默认文件编码为utf-8，启用deflate压缩
    server->add_router(make_static_router(R"(../test/test_http_server/testWebsite)", {{"*"s}}, "utf-8", true));

    // 7. 启动服务
    server->start();
}