#include "acceptor.h"
#include "workthread.h"
#include <QDebug>
#include <iostream>
#include "event2/buffer.h"
#include "msg.pb.h"
#define FRAME_FLAG 0xABCD

using namespace std;

Acceptor::Acceptor(WorkThread* work_thread, struct event_base* base, HandleResolver* resolver, int fd, unsigned short heartbeat)
    : work_thread_(work_thread),
      ev_base_(base),
      socket_(fd),
      heartbeat_(heartbeat),
      resolver_(resolver)
{

}

bool Acceptor::Init(ssl_ctx_st *ssl_ctx)
{
    bufferevent *bev = nullptr;
    if(ssl_ctx)
    {
        ssl_ = SSL_new(ssl_ctx);
        SSL_set_fd(ssl_, socket_);
        bev = bufferevent_openssl_socket_new(ev_base_,
                                             socket_,
                                             ssl_,
                                             BUFFEREVENT_SSL_ACCEPTING, // 接收连接后初始化
                                             BEV_OPT_CLOSE_ON_FREE); // 连接关闭后释放bufferevent和ssl
    }
    else
    {
        bev = bufferevent_socket_new(ev_base_, socket_, BEV_OPT_CLOSE_ON_FREE);
    }
    if (!bev)
    {
        return false;
    }
    bufferevent* bev_filter = bufferevent_filter_new(bev,
                                                     FilterIn,
                                                     FilterOut,
                                                     BEV_OPT_CLOSE_ON_FREE,
                                                     0,
                                                     0);
    // 指定参数
    bufferevent_setcb(bev_filter, ReadCB, WriteCB, EventCB, this);
    bufferevent_enable(bev_filter, EV_READ | EV_WRITE);
    timeval tv = {heartbeat_, 0};
    bufferevent_set_timeouts(bev_filter, &tv, NULL);
    return true;
}

void Acceptor::ReadCB(bufferevent *buffev, void *arg)
{
    // 获取bufferevent中的input和output
    evbuffer *input = bufferevent_get_input(buffev);
    evbuffer *output = bufferevent_get_output(buffev);
    Acceptor *ac = (Acceptor*)arg;
    ac->resolver_->handle(input, output);
    bufferevent_write_buffer(buffev, output);
}

void Acceptor::WriteCB(bufferevent *buffev, void *arg)
{

}

void Acceptor::EventCB(bufferevent *buffev, short what, void *arg)
{
    Acceptor *h = (Acceptor*)arg;
    if (what & BEV_EVENT_TIMEOUT)
    {
        h->work_thread_->Disconnection(h);
    }
    if (what & BEV_EVENT_EOF)
    {
        h->work_thread_->Disconnection(h);
    }
    // 用户断开连接，释放服务端资源
    if (what & BEV_EVENT_ERROR)
    {
        h->work_thread_->Disconnection(h);
    }
}

bufferevent_filter_result Acceptor::FilterIn(evbuffer *src, evbuffer *dst, ssize_t dst_limit, bufferevent_flush_mode mode, void *ctx)
{
    evbuffer_ptr ptr;
    evbuffer_ptr_set(src, &ptr, 0, EVBUFFER_PTR_SET);
    char buf[2] = {0};
    int i = 0;
    int flag = FRAME_FLAG;
    while(1)
    {
        evbuffer_copyout_from(src, &ptr, buf, 2);
        if(memcmp(buf, &flag, 2) != 0)
        {
            i++;
            evbuffer_ptr_set(src, &ptr, i, EVBUFFER_PTR_SET);
            continue;
        }
        evbuffer_drain(src, i);
        break;
    }
    evbuffer_copyout(src, buf, 2);
    unsigned long req_len = 0;
    evbuffer_ptr_set(src, &ptr, 2, EVBUFFER_PTR_SET);
    evbuffer_copyout_from(src, &ptr, &req_len, 8);
    if(evbuffer_get_length(src) < req_len + 2)
    {
        return BEV_NEED_MORE;
    }
    evbuffer_drain(src, 10);
    char *src_buf = new char[req_len];
    evbuffer_remove(src, src_buf, req_len);
    evbuffer_add(dst, src_buf, req_len);
    delete[] src_buf;
    return BEV_OK;
}

bufferevent_filter_result Acceptor::FilterOut(evbuffer *src, evbuffer *dst, ssize_t dst_limit, bufferevent_flush_mode mode, void *ctx)
{
    int flag = FRAME_FLAG;
    long src_length = evbuffer_get_length(src);
    evbuffer_prepend(src, &src_length, 8);
    evbuffer_prepend(src, &flag, 2);
    src_length = evbuffer_get_length(src);
    char *dst_buf = new char[src_length];
    evbuffer_remove(src, dst_buf, src_length);
    evbuffer_add(dst, dst_buf, src_length);
    delete[] dst_buf;
    return BEV_OK;
}