#include "event.h"
#include "user.h"
#include "dbproxy.h"
#include "gateway.h"
#include <gateway_msg.pb.h>
#include <db.pb.h>
#include <common_msg.pb.h>

event_t* event_mgr_t::find(EVENT_TYPE type, EVENT_ID id)
{
    auto it = this->event_map.find(type);
    if (it != this->event_map.end()){
        auto& infoMap = it->second;
        auto iter = infoMap.find(id);
        if (iter != infoMap.end()){
            return &iter->second;
        }
    }

    return NULL;
}

bool event_mgr_t::load_from_db(EVENT_TYPE type, EVENT_ID id,
							   EVENT_DATA data, EVENT_TIME time,
							   const EVENT_STR_DATA& str_data,
							   const EVENT_BIN_DATA& bin_data)
{
	if (event_t::is_expire_time(type, time)){
		return false;
	}
    this->event_map[type][id] = event_t(type, id, data, time, str_data, bin_data);
	return true;
}

void event_mgr_t::clear_overdue_daily_events()
{
    auto it = this->event_map.begin(); 
    for (; it != this->event_map.end(); ){
		auto type = it->first;
        if (event_t::is_daily_event(type)){
            this->event_map.erase(it++);
        } else {
            ++it;
        }
    }
}

void event_mgr_t::update_event( USER_ID uid, EVENT_TYPE type, 
							   EVENT_ID id, EVENT_DATA data,
							   EVENT_TIME time )
{
	this->event_map[type][id] = event_t(type, id, data, time);

	event_mgr_t::db_update_event(uid, type, id, data, time);
}

void event_mgr_t::update_event( USER_ID uid, EVENT_TYPE type, EVENT_ID id,
							   EVENT_DATA data, EVENT_TIME time,
							   const EVENT_STR_DATA& str_data )
{
	this->event_map[type][id] = event_t(type, id, data, time, str_data);

	event_mgr_t::db_update_event(uid, type, id, data, time, str_data);
}

void event_mgr_t::update_event( USER_ID uid, EVENT_TYPE type, EVENT_ID id,
							   EVENT_DATA data, EVENT_TIME time,
							   const EVENT_STR_DATA& str_data,
							   const std::string& bin_data)
{
	this->event_map[type][id] = event_t(type, id, data, time, str_data, bin_data);

	event_mgr_t::db_update_event(uid, type, id, data, time, str_data, bin_data);
}

EVENT_DATA event_mgr_t::find_data(EVENT_TYPE type, EVENT_ID id)
{
	auto event = this->find(type, id);
	if (NULL == event){
		return 0;
	}
	return event->data;
}

void event_mgr_t::db_update_event( USER_ID uid, EVENT_TYPE type,
								  EVENT_ID id, EVENT_DATA data,
								  EVENT_TIME time )
{
	db_msg::update_event_msg out;
	auto event = out.mutable_event();
	event->set_type(type);
	event->set_id(id);
	event->set_data(data);
	event->set_time(time);
	g_dbproxy->send_msg(&out, uid, db_update_event_msg_cmd, NULL);
}

void event_mgr_t::db_update_event( USER_ID uid, EVENT_TYPE type,
								  EVENT_ID id, EVENT_DATA data,
								  EVENT_TIME time,
								  const EVENT_STR_DATA& str_data )
{
	db_msg::update_event_msg out;
	auto event = out.mutable_event();
	event->set_type(type);
	event->set_id(id);
	event->set_data(data);
	event->set_time(time);
    event->set_str_data(str_data);
	g_dbproxy->send_msg(&out, uid, db_update_event_msg_cmd, NULL);
}

void event_mgr_t::db_update_event( USER_ID uid, EVENT_TYPE type,
								  EVENT_ID id, EVENT_DATA data,
								  EVENT_TIME time,
								  const EVENT_STR_DATA& str_data,
								  const std::string& bin_data)
{
	db_msg::update_event_msg out;
	auto event = out.mutable_event();
	event->set_type(type);
	event->set_id(id);
	event->set_data(data);
	event->set_time(time);
	event->set_str_data(str_data);
	event->set_bin_data(bin_data);
	g_dbproxy->send_msg(&out, uid, db_update_event_msg_cmd, NULL);
}

void event_mgr_t::del_event( USER_ID uid, EVENT_TYPE type, EVENT_ID id /*= 0*/ )
{
	auto it = this->event_map.find(type);
	if (this->event_map.end() == it){
		return;
	}
	auto it2 = it->second.find(id);
	if (it->second.end() == it2){
		return;
	}
	it->second.erase(it2);
	event_mgr_t::db_del_event(uid, type, id);
}

void event_mgr_t::del_event_by_type(USER_ID uid, EVENT_TYPE type,
									bool effect_db)
{
	auto it = this->event_map.find(type);
	if (this->event_map.end() == it){
		return;
    }

    this->event_map.erase(it);
	if (effect_db){
		event_mgr_t::db_del_event_by_type(uid, type);
	}
}

void event_mgr_t::db_del_event( USER_ID uid, EVENT_TYPE type, EVENT_ID id )
{
	db_msg::del_event_msg out;
	out.set_type(type);
	out.set_id(id);
	g_dbproxy->send_msg(&out, uid, db_del_event_msg_cmd, NULL);
}

void event_mgr_t::db_del_event_by_type( USER_ID uid, EVENT_TYPE type)
{
	db_msg::del_event_by_type_msg out;
	out.set_type(type);
	g_dbproxy->send_msg(&out, uid, db_del_event_by_type_msg_cmd, NULL);
}

std::map<EVENT_ID, event_t>& event_mgr_t::find_events( EVENT_TYPE type )
{
	auto it = this->event_map.find(type);
	if (it != this->event_map.end()){
		return it->second;
	}

	static std::map<EVENT_ID, event_t> null_map;
	return null_map;
}

uint32_t event_mgr_t::find_time( EVENT_TYPE type, EVENT_ID id /*= 0*/ )
{
	auto event = this->find(type, id);
	if (NULL == event){
		return 0;
	}
	return event->time;
}

const EVENT_STR_DATA& event_mgr_t::find_str_data( EVENT_TYPE type,
												 EVENT_ID id )
{
	static std::string str_data;
	auto event = this->find(type, id);
	if (NULL == event){
		return str_data;
	}
	return event->str_data;
}

const EVENT_BIN_DATA& event_mgr_t::find_bin_data( EVENT_TYPE type,
												 EVENT_ID id )
{
	static std::string str_empty;
	auto event = this->find(type, id);
	if (NULL == event){
		return str_empty;
	}

	return event->bin_data;
}

void event_mgr_t::clear_overdue_monthly_events()
{
	auto it = this->event_map.begin(); 
	for (; it != this->event_map.end(); ){
		auto type = it->first;
		if (event_t::is_monthly_event(type)){
			this->event_map.erase(it++);
		} else {
			++it;
		}
	}
}

event_mgr_t::event_mgr_t()
{
	this->user = NULL;
}


event_t::event_t( EVENT_TYPE type, EVENT_ID id, EVENT_DATA data,
				 EVENT_TIME time )
{
	this->type = type;
	this->id = id;
	this->data = data;
	this->time = time;
}

event_t::event_t(EVENT_TYPE type, EVENT_ID id, EVENT_DATA data, 
			   EVENT_TIME time, const EVENT_STR_DATA& str_data)
{
	this->type = type;
	this->id = id;
	this->data = data;
	this->time = time;
	this->str_data = str_data;
}

event_t::event_t(EVENT_TYPE type, EVENT_ID id, EVENT_DATA data,
				 EVENT_TIME time, const EVENT_STR_DATA& str_data, 
				 const std::string& bin_data)
{
	this->type = type;
	this->id = id;
	this->data = data;
	this->time = time;
	this->str_data = str_data;
	this->bin_data = bin_data;
}

bool event_t::is_daily_event( EVENT_TYPE type )
{
	return common_msg::DAILY_EVENT_BEGIN <= type && type <= common_msg::DAILY_EVENT_END;
}

bool event_t::is_expire_time(EVENT_TYPE type, EVENT_TIME time)
{
	if (event_t::is_expire_event(type)){
		return time < el_async::get_now_sec();
	}
	return false;
}

bool event_t::is_expire_event( EVENT_TYPE type )
{
		return (common_msg::DAILY_EVENT_BEGIN <= type && type <= common_msg::DAILY_EVENT_END)
			|| (common_msg::WEEKLY_EVENT_BEGIN <= type && type <= common_msg::WEEKLY_EVENT_END)
			|| (common_msg::MONTHLY_EVENT_BEGIN <= type && type <= common_msg::MONTHLY_EVENT_END)
			|| (common_msg::EXPRIE_EVENT_BEGIN <= type && type <= common_msg::EXPRIE_EVENT_END);
}

bool event_t::is_monthly_event( EVENT_TYPE type )
{
	return common_msg::MONTHLY_EVENT_BEGIN <= type && type <= common_msg::MONTHLY_EVENT_END;
}

//////////////////////////////////////////////////////////////////////////
//msg
int dbproxy_t::on_get_events_msg_res(el::lib_tcp_peer_info_t* peer_fd_info,
									 google::protobuf::Message* msg,
									 USER_ID uid, uint32_t seq,
									 uint32_t ret, user_t* user){
	return SUCC;
}

int gateway_t::on_update_event_msg(el::lib_tcp_peer_info_t* peer_fd_info,
								google::protobuf::Message* msg, user_t* user)
{
	auto in = (gateway_msg::update_event_msg*)msg;
	if (in->event().type() <= common_msg::FOREVER_EVENT_CLI_START 
		|| common_msg::FOREVER_EVENT_CLI_END <= in->event().type()){
		return common_msg::EEC_CLI_EVENT_TYPE;
	}
	user->event_mgr.update_event(user->uid(), in->event().type(), 
		in->event().id(), in->event().data(), in->event().time(), in->event().str_data());
	return 0;
}

int gateway_t::on_get_event_msg(el::lib_tcp_peer_info_t* peer_fd_info,
								   google::protobuf::Message* msg, user_t* user)
{
	auto in = (gateway_msg::get_event_msg*)msg;
	EVENT_TYPE type = in->type();
	EVENT_ID id = in->id();

	gateway_msg::get_event_msg_res out;
	auto e = out.mutable_event();
	e->set_type(type);
	e->set_id(id);

	event_t* event = user->event_mgr.find(type, id);
	if (NULL != event){
		e->set_data(event->data);
		e->set_time(event->time);
		e->set_str_data(event->str_data);
		e->set_bin_data(event->bin_data);
	}
	user->send_msg_res(&out);

	return 0;
}