#include "gateway.h"
#include <gateway_msg.pb.h>
#include "dbproxy.h"
#include "user.h"
#include "sys.h"
#include "loginserv.h"
#include "level.h"
#include "shop.h"
#include "role_reward.h"
#include "user_head.h"
#include "nick.h"
#include "pay.h"
#include "online_reward.h"
#include "btl_cnt_reward.h"
#include <bind_conf.h>
#include <statisitcs_srv.h>
#include "turntable.h"
#include "event.h"
#include "wx_share_reward.h"
#include "game_cfg.h"
#include "rank.h"
#include "pet_turntable.h"
#include "btl_rank.h"
#include "lobby_service.h"

gateway_t* g_gateway;

gateway_t::gateway_t() : el::lib_timer_base_t(g_timer){
	this->login_time_out_sec = ::atoi(g_bench_conf->get_strval("login", "time_out_sec").c_str());

	this->init_msg_map();

	g_user_mgr = new user_mgr_t;
	g_dbproxy = new dbproxy_t;
	g_loginserv = new loginserv_t;
	g_lobby_service = new lobby_service_t;

	g_item_cfg_mgr = new item_cfg_mgr_t;
	g_sys = new sys_t;

	g_vip_level_cfg_mgr = new vip_level_cfg_mgr_t;

	g_statisitcs = new statisitcs_t;

	g_shop_cfg_mgr = new shop_cfg_mgr_t;
	g_play_game_reward_cfg_mgr = new play_game_reward_cfg_mgr_t;
	g_task_cfg_mgr = new task_cfg_mgr_t;
	g_sign_cfg_mgr = new sign_cfg_mgr_t;
	g_achievement_cfg_mgr = new achievement_cfg_mgr_t;
	g_single_game_cfg_mgr = new single_game_cfg_mgr_t;
	g_rank_mgr = new rank_mgr_t;
	g_exprie_rank_mgr = new exprie_rank_mgr_t;
	g_btl_rank_mgr = new btl_rank_mgr_t;
	g_login_reward_cfg_mgr = new login_reward_cfg_mgr_t;
	g_role_reward_cfg_mgr = new role_reward_cfg_mgr_t;
	g_create_reward_cfg_mgr = new create_reward_cfg_mgr_t;
	g_online_reward_cfg_mgr = new online_reward_cfg_mgr_t;
	g_btl_cnt_reward_cfg_mgr = new btl_cnt_reward_cfg_mgr_t;
	g_turntable_reward_cfg_mgr = new turntable_reward_cfg_mgr_t;
	g_pet_turntable_cfg_mgr = new pet_turntable_cfg_mgr_t;
	g_game_cfg_mgr = new game_cfg_mgr_t;
	g_head_cfg_mgr = new head_cfg_mgr_t;
	g_pet_cfg_mgr = new pet_cfg_mgr_t;
	g_mail_conf = new mail_conf_t;
	g_pay_cfg_mgr = new pay_cfg_mgr_t;
	g_rand_nick_mgr = new rand_nick_mgr;

}

int gateway_t::init(){
	uint32_t is_release = g_bench_conf->get_uint32_def_val("server", "is_release");
	if (0 == is_release){
		g_sys->is_release = false;
	}

	g_sys->platform = g_bench_conf->get_uint32_def_val("common", "platform", 0);
	if (0 == g_sys->platform){
		ALERT_LOG("game platform failed...");
		return ERR;
	}

	if (SUCC != this->load_conf()) {
		return ERR;
	}

	{//timer
		this->add_sec_event(gateway_t::time_out_new_day, NULL, el::lib_time_t::tomorrow_start_time());
		this->add_sec_event(gateway_t::time_out_one_sec, NULL, el_async::get_now_sec() + 1);
		this->add_sec_event(gateway_t::time_out_one_minute, NULL, el_async::get_now_sec() + 60);
	}
	INFO_LOG("init compeleted!");
	return SUCC;
}

void gateway_t::release(){
    this->release_msg_map();

	SAFE_DELETE(g_user_mgr);
	SAFE_DELETE(g_dbproxy);

	SAFE_DELETE(g_loginserv);
	SAFE_DELETE(g_item_cfg_mgr);
	SAFE_DELETE(g_sys);

	SAFE_DELETE(g_statisitcs);
	SAFE_DELETE(g_shop_cfg_mgr);
	SAFE_DELETE(g_play_game_reward_cfg_mgr);
	SAFE_DELETE(g_task_cfg_mgr);
	SAFE_DELETE(g_achievement_cfg_mgr);
	SAFE_DELETE(g_rank_mgr);
	SAFE_DELETE(g_exprie_rank_mgr);
	SAFE_DELETE(g_btl_rank_mgr);
	SAFE_DELETE(g_single_game_cfg_mgr);
	SAFE_DELETE(g_sign_cfg_mgr);
	SAFE_DELETE(g_login_reward_cfg_mgr);
	SAFE_DELETE(g_create_reward_cfg_mgr);
	SAFE_DELETE(g_online_reward_cfg_mgr);
	SAFE_DELETE(g_btl_cnt_reward_cfg_mgr);
	SAFE_DELETE(g_turntable_reward_cfg_mgr);
	SAFE_DELETE(g_pet_turntable_cfg_mgr);
	SAFE_DELETE(g_game_cfg_mgr);
	SAFE_DELETE(g_role_reward_cfg_mgr);
	SAFE_DELETE(g_head_cfg_mgr);
	SAFE_DELETE(g_pet_cfg_mgr);
	SAFE_DELETE(g_mail_conf);
	SAFE_DELETE(g_pay_cfg_mgr);
	SAFE_DELETE(g_rand_nick_mgr);
	SAFE_DELETE(g_lobby_service);

}

void gateway_t::release_msg_map(){
	FOREACH(this->msg_map, it){
        SAFE_DELETE(it->second.prototype);
    }
    this->msg_map.clear();
}

int gateway_t::on_recv(el::lib_tcp_peer_info_t* peer_fd_info, char* pdata, int len){
	if (!g_sys->is_run()){
		ALERT_LOG("sys is not run");
		return el::ERR_SYS::DISCONNECT_PEER;
	}

	user_t* user = (user_t*)peer_fd_info->data;
// 	if (NULL == user){
// 		return el::ERR_SYS::DISCONNECT_PEER;
// 	}
	
	CMD_ID cmd_id = g_proto_head.cmd;
    auto it = this->msg_map.find(cmd_id);
    if(this->msg_map.end() == it){
		if (common_msg::E_PENETRATE_ROOM_MSG_BEGIN <= cmd_id
			&& cmd_id <= common_msg::E_PENETRATE_ROOM_MSG_END){
			return SUCC;
		} 
        CRIT_LOG("no msg define for [cmd:0x%x]", cmd_id);
        return el::ERR_SYS::DISCONNECT_PEER;
    }

    try{
        if(!it->second.prototype->ParseFromArray(pdata, len)){
            ERROR_LOG("decode message [cmd:0x%x] with %d bytes failed", cmd_id, len);
            return el::ERR_SYS::DISCONNECT_PEER;
        }

		TRACE_LOG("<======recv client [uid:%" PRIu64 ", cmd:0x%x, body_len:%d]", 
			user->uid(), cmd_id, len);
		if (!it->second.prototype->Utf8DebugString().empty()){
			TRACE_LOG("%s", it->second.prototype->Utf8DebugString().c_str());
		}

		if (E_USER_LOGIN_STATUS_COMPLETE != user->login_status){
			if (E_USER_LOGIN_STATUS_CONNECTED == user->login_status
				&& cli_login_msg_cmd != cmd_id){
				ERROR_LOG("");
				return el::ERR_SYS::DISCONNECT_PEER;
			}
			if (E_USER_LOGIN_STATUS_LOGINING == user->login_status){
				ERROR_LOG("");
				return el::ERR_SYS::DISCONNECT_PEER;
			}
			if (E_USER_LOGIN_STATUS_CREATE_ROLE == user->login_status
				&& cli_create_role_msg_cmd != cmd_id){
				ERROR_LOG("");
				return el::ERR_SYS::DISCONNECT_PEER;
			}
		} else {
			if (gateway_msg::LOGIN_CMD_BEGIN <= cmd_id && cmd_id <= gateway_msg::LOGIN_CMD_END){
				ERROR_LOG("");
				return el::ERR_SYS::DISCONNECT_PEER;
			}
		}

		int ret = (this->*it->second.func)(peer_fd_info, it->second.prototype, user);
		if (SUCC != ret){
			TRACE_LOG("======>client msg handle error [uid:%" PRIu64 ", cmd:0x%x, ret:%d]", 
				user->uid(), cmd_id, ret);
			user->send_err(cmd_id, ret);
		}
		return ret;
    }catch(...){
        ERROR_LOG("parse message failed cmd:0x%x]. kick client", cmd_id);
		return el::ERR_SYS::DISCONNECT_PEER;
    }
	return SUCC;
}

int gateway_t::time_out_new_day( void* owen, void* data ){
	int yyyymmdd = el::lib_time_t::get_date_yyyymmdd(el_async::get_now_sec());
	if (1 == yyyymmdd%100){//new mon
		g_gateway->time_out_new_mon();
	}

	time_t t = el_async::get_now_sec();
	if (1 == time_week(t)){
		g_gateway->time_out_new_week();
	}

	FOREACH(g_user_mgr->user_login_complete_map, it){
		user_t* user = it->second;
		user->event_mgr.clear_overdue_daily_events();
	}

	g_btl_rank_mgr->db_delete_yesterday_rank();
	g_btl_rank_mgr->yesterday_rank_map.clear();

	{
		FOREACH(g_btl_rank_mgr->rank_map, it_type){
			auto type = it_type->first;
			if (share_msg::E_BTL_RANK_TYPE_COMMON != type){
				continue;
			}
			
			uint32_t no = 0;
			std::set<btl_rank_user_t>& rank_user_set = it_type->second;

			g_btl_rank_mgr->clear(rank_user_set);
			std::set<btl_rank_user_t> add_rank_user_set;
			FOREACH(rank_user_set, it){
				const btl_rank_user_t& ru = *it;
				no++;
				if (no <= share_msg::E_BTL_RANK_MAX_CNT){
					share_msg::btl_rank_user_t* sru = (btl_rank_user_t*)&ru;
					g_btl_rank_mgr->db_yesterday_update_rank(*sru);
					add_rank_user_set.insert(ru);
				}
			}
			g_btl_rank_mgr->yesterday_rank_map.insert(std::make_pair(type, add_rank_user_set));
		}
	}
	{

		FOREACH(g_user_mgr->user_login_complete_map, it){
			user_t* user = it->second;

			user->task_mgr.do_task_set.clear();
			user->task_mgr.finish_task_set.clear();
			user->event_mgr.del_event_by_type(user->uid(), common_msg::DAILY_EVENT_TASK);

			user->task_mgr.create();

			user->task_mgr.notify_all();
		}
	}
	{
		gateway_msg::sys_new_day_msg_res out;

		FOREACH(g_user_mgr->user_login_complete_map, it){
			user_t* user = it->second;
			user->send_msg(cli_sys_new_day_msg_cmd, &out);
		}
	}

	g_gateway->add_sec_event(gateway_t::time_out_new_day, NULL, el::lib_time_t::tomorrow_start_time());

	return 0;
}

int gateway_t::time_out_one_sec( void* owen, void* data ){
	g_gateway->add_sec_event(gateway_t::time_out_one_sec, NULL, g_timer->now_sec()+1);

	{
		if (NULL == g_loginserv->fd_info){
			loginserv_msg::login_msg out;
			out.set_ip(el_async::get_server_ip());
			out.set_port(el_async::get_server_port());
			out.set_gateway_cnt(g_bind_conf->elems.size());
			g_loginserv->send_msg(&out, el_async::get_server_id(), loginserv_login_msg_cmd);
		}
	}
	return 0;
}

int gateway_t::init_msg_map(){
	
#undef  BIND_PROTO_CMD
#undef  BIND_PROTO_CMD_NO_CB

#define BIND_PROTO_CMD_NO_CB(__cmd_id__, fun_name, proto_name)
	
#define BIND_PROTO_CMD(__cmd_id__, fun_name, proto_name)\
	{\
		if (this->msg_map.end() != this->msg_map.find(__cmd_id__)){\
		ALERT_LOG("cmd inster err![0x%x]", __cmd_id__);\
		exit(0);\
		} else {\
			this->msg_map[__cmd_id__] = MSG_HANDLE_GATEWAY_T(new gateway_msg::proto_name(), &gateway_t::fun_name);\
		}\
	}
#include <gateway_cmd.h>

#undef  BIND_PROTO_CMD
	
	return SUCC;
}

int gateway_t::load_conf()
{
	if (!g_item_cfg_mgr->load_cfg()){
		ALERT_LOG("g_item_cfg_mgr->load_cfg()");
		return ERR;
	}

	if (!g_pet_cfg_mgr->load_cfg()){
		ALERT_LOG("g_pet_cfg_mgr->load_cfg()");
		return ERR;
	}

	if (!g_shop_cfg_mgr->load_cfg()){
		ALERT_LOG("g_shop_cfg_mgr->load_cfg()");
		return ERR;
	}

	if (!g_play_game_reward_cfg_mgr->load_cfg()){
		ALERT_LOG("g_shop_draw_cfg_mgr->load_cfg()");
		return ERR;
	}

	if (!g_vip_level_cfg_mgr->load_cfg()){
		ALERT_LOG("g_vip_level_cfg_mgr->load_cfg()");
		return ERR;
	}

	if (!g_task_cfg_mgr->load_cfg()){
		ALERT_LOG("g_task_cfg_mgr->load_cfg()");
		return ERR;
	}

	if (!g_sign_cfg_mgr->load_cfg()){
		ALERT_LOG("g_sign_cfg_mgr->load_cfg()");
		return ERR;
	}
	if (!g_achievement_cfg_mgr->load_cfg()){
		ALERT_LOG("g_achievement_cfg_mgr->load_cfg()");
		return ERR;
	}

	if (!g_single_game_cfg_mgr->load_cfg()){
		ALERT_LOG("g_single_game_cfg_mgr->load_cfg()");
		return ERR;
	}

	if (!g_login_reward_cfg_mgr->load_cfg()){
		ALERT_LOG("g_login_reward_cfg_mgr->load_cfg()");
		return ERR;
	}

	if (!g_head_cfg_mgr->load_cfg()){
		ALERT_LOG("g_head_cfg_mgr->load_cfg()");
		return ERR;
	}

	if (!g_role_reward_cfg_mgr->load_cfg()){
		ALERT_LOG("g_role_reward_cfg_mgr->load_cfg()");
		return ERR;
	}

	if (!g_online_reward_cfg_mgr->load_cfg()){
		ALERT_LOG("g_online_reward_cfg_mgr->load_cfg()");
		return ERR;
	}

	if (!g_btl_cnt_reward_cfg_mgr->load_cfg()){
		ALERT_LOG("g_btl_cnt_reward_cfg_mgr->load_cfg()");
		return ERR;
	}

	if (!g_turntable_reward_cfg_mgr->load_cfg()){
		ALERT_LOG("g_turntable_reward_cfg_mgr->load_cfg()");
		return ERR;
	}

	if (!g_game_cfg_mgr->load_cfg()){
		ALERT_LOG("g_game_cfg_mgr->load_cfg()");
		return ERR;
	}

	if (!g_create_reward_cfg_mgr->load_cfg()){
		ALERT_LOG("g_create_reward_cfg_mgr->load_cfg()");
		return ERR;
	}

	if (!g_mail_conf->load_cfg()){
		ALERT_LOG("g_mail_conf->load_cfg()");
		return ERR;
	}

	if (!g_pay_cfg_mgr->load_cfg()){
		ALERT_LOG("g_pay_cfg_mgr->load_cfg()");
		return ERR;
	}

	if (!g_rand_nick_mgr->load_cfg()){
		ALERT_LOG("g_rand_nick_mgr->load_cfg()");
		return ERR;
	}

	if (!g_pet_turntable_cfg_mgr->load_cfg()){
		ALERT_LOG("g_pet_turntable_reward_cfg_mgr->load_cfg()");
		return ERR;
	}

	if (!g_exprie_rank_mgr->load_cfg()){
		ALERT_LOG("g_rank_mgr->load_cfg()");
		return ERR;
	}

	if (!check_config()) {
		ALERT_LOG("check_config()");
		return ERR;
	}

	return SUCC;
}

bool gateway_t::check_config(void)
{
	if (!g_shop_cfg_mgr->check_cfg()){
		ALERT_LOG("g_shop_cfg_mgr->check_cfg()");
		return false;
	}

	if (!g_pet_cfg_mgr->check_cfg()){
		ALERT_LOG("g_pet_cfg_mgr->check_cfg()");
		return false;
	}


	return true;
}

int gateway_t::time_out_login( void* owen, void* data )
{
	user_t* u = (user_t*)data;
	u->time_out_login_handle = NULL;
	if (E_USER_LOGIN_STATUS_COMPLETE != u->login_status){
		g_user_mgr->offline(u->fd_info->fd, true);
	}

	return 0;
}

gateway_t::~gateway_t()
{
	this->release();
}

int gateway_t::time_out_new_mon()
{
	FOREACH(g_user_mgr->user_login_complete_map, it){
		user_t* user = it->second;
		user->sign_mgr.sign_day_set.clear();
		user->sign_mgr.sign_day_get_reward_set.clear();
		user->event_mgr.clear_overdue_monthly_events();
	}
	return 0;
}

int gateway_t::time_out_one_minute( void* owen, void* data )
{
	g_gateway->add_sec_event(gateway_t::time_out_one_minute, NULL, g_timer->now_sec() + 60);

	INFO_LOG("[user_cnt:%lu, connect_cnt:%lu]",
		g_user_mgr->user_login_complete_map.size(), g_user_mgr->user_connected_map.size());

	auto it = g_user_mgr->user_in_room_reconnect_map.begin();
	for (; it != g_user_mgr->user_in_room_reconnect_map.end(); ){
		auto& r = it->second;
		if (r.time_sec + 30*60 < el_async::get_now_sec()){
			g_user_mgr->user_in_room_reconnect_map.erase(it++);
		} else {
			++it;
		}
	}
	return 0;
}

int gateway_t::time_out_new_week()
{
	g_exprie_rank_mgr->clear();
	return 0;
}