#include "user.h"
#include "gateway.h"
#include "dbproxy.h"
#include "sys.h"
#include "loginserv.h"
#include <gateway_msg.pb.h>
#include <db.pb.h>
#include "online_reward.h"
#include "game_cfg.h"


user_mgr_t* g_user_mgr;

void user_mgr_t::del_fd_user( int fd ){
	auto it = this->user_connected_map.find(fd);
	if (this->user_connected_map.end() == it){
		ERROR_LOG("[fd:%d]", fd);
		return;
	}
	user_t* user = it->second;
	USER_ID uid = user->uid();
	SAFE_DELETE(user);
	this->user_login_complete_map.erase(uid);
	this->user_connected_map.erase(fd);
}

void user_mgr_t::add_fd_user( el::lib_tcp_peer_info_t* peer_fd_info ){
	int fd = peer_fd_info->fd;
	auto it = this->user_connected_map.find(fd);
	if (this->user_connected_map.end() != it){
		ERROR_LOG("[fd:%d]", fd);
		return;
	}
	user_t* user = new user_t(peer_fd_info);
	this->user_connected_map[fd] = user;
	peer_fd_info->data = user;
}

user_t* user_mgr_t::find( USER_ID uid )
{
	auto it = this->user_login_complete_map.find(uid);
	if (this->user_login_complete_map.end() == it){
		return NULL;
	}
	return it->second;
}

user_t* user_mgr_t::find( int fd )
{
	auto it = this->user_connected_map.find(fd);
	if (this->user_connected_map.end() == it){
		return NULL;
	}
	return it->second;
}

void user_mgr_t::offline( int fd, bool is_active_close_peer)
{
	auto user = this->find(fd);
	if (NULL == user){
		WARN_LOG("[fd:%d]", fd);
		return;
	}
	
	auto fd_info = user->fd_info;

	this->del_fd_user(fd);

	if (is_active_close_peer){
		el_async::active_close_peer(fd_info);
	}
}

void user_mgr_t::add_uid_user( USER_ID uid, user_t* user )
{
	this->user_login_complete_map.insert(std::make_pair(uid, user));
}

void user_t::send_msg_res( google::protobuf::Message* msg )
{
	this->send_msg(g_proto_head.cmd, msg);
}

void user_t::send_msg( CMD_ID cmd_id, google::protobuf::Message* msg, uint32_t seq, USER_ID uid )
{
	static char msgBuf[MAXMESSAGE_LEN];
	try{
		static void* sb = msgBuf + proto_head_t::PROTO_HEAD_LEN;
		static const int sb_len = sizeof(msgBuf) - proto_head_t::PROTO_HEAD_LEN;
		msg->SerializeToArray(sb, sb_len);

		PROTO_LEN pkg_len = proto_head_t::PROTO_HEAD_LEN + msg->ByteSize();
		proto_head_t::pack(msgBuf, pkg_len, seq, cmd_id, 0, uid);

		TRACE_LOG("======send to user msg [cmd_id:0x%x, %u bytes]", cmd_id, pkg_len);
		if (!msg->Utf8DebugString().empty()){
			TRACE_LOG("%s", msg->Utf8DebugString().c_str());
		}
		el_async::s2peer(this->fd_info, msgBuf, pkg_len);
	}catch (...){
		ERROR_LOG("[cmd_id:0x%x", cmd_id);
	}
 }

user_t::~user_t()
{
	//after offline update user information		
	if (E_USER_LOGIN_STATUS_COMPLETE == this->login_status){//after the success of the login, off-line will set time

		this->lobby_mgr.out_lobby(true);

		db_msg::logout_user_msg out;
		out.set_last_logout_time(el_async::get_now_sec());
		g_dbproxy->send_msg(&out, this->uid(), db_logout_user_msg_cmd, NULL);

		g_online_reward_cfg_mgr->offline_save_time_sec(this);
	}

	// 清理dbproxy中未返回的数据记录	
	g_dbproxy->clear_handle_callback_user(this);

	if (NULL != this->time_out_login_handle){
		this->remove_sec_timer(this->time_out_login_handle);
	}
}

int user_t::send_err( CMD_ID cmd_id, uint32_t ret )
{
	WARN_LOG("[cmd:%x, ret:%u]", cmd_id, ret);

	static char msgBuf[proto_head_t::PROTO_HEAD_LEN];
	proto_head_t::pack(msgBuf, proto_head_t::PROTO_HEAD_LEN, 0, cmd_id, ret, 0);

	el_async::s2peer(this->fd_info, msgBuf, proto_head_t::PROTO_HEAD_LEN);
	return 0;
}

USER_ID user_t::uid()
{
	return this->user_show.uid();
}

user_t::user_t( el::lib_tcp_peer_info_t* peer_fd_info ) : el::lib_timer_base_t(g_timer)
{
	this->fd_info = peer_fd_info;
	this->login_status = E_USER_LOGIN_STATUS_CONNECTED;
	this->item_mgr.user = this;
	this->event_mgr.user = this;
	this->platform = share_msg::E_PLATFORM_VISITOR;
	this->commect_sec = el_async::get_now_sec();
	this->last_get_online_reward_sec = el_async::get_now_sec();
	this->time_out_login_handle = NULL;
	this->task_mgr.user = this;
	this->sign_mgr.user = this;
	this->login_reward_mgr.user = this;
	this->mail_mgr.user = this;
	this->agent_level = 0;
	this->achievement_mgr.user = this;
	this->furniture_mgr.user = this;
	this->pet_mgr.user = this;
	this->btl_mgr.user = this;
	this->pet_turntable_key = 0;
	this->lobby_mgr.user = this;
	//登陆超时时间,秒	
	if (0 != g_gateway->login_time_out_sec){
		this->time_out_login_handle = g_gateway->add_sec_event(gateway_t::time_out_login, this, el_async::get_now_sec() + g_gateway->login_time_out_sec);
	}
}

std::string user_t::nick()
{
	return this->user_show.nick();
}

EVENT_DATA user_t::gen_idx()
{
	auto idx = this->event_mgr.find_data(common_msg::FOREVER_EVENT_IDX);
	idx++;
	this->event_mgr.update_event(this->uid(), common_msg::FOREVER_EVENT_IDX, 0, idx, 0);
	return idx;
}

uint32_t user_t::head()
{
	return this->user_show.head();
}

bool user_t::is_vip_active()
{
	std::map<EVENT_ID, event_t>& events = this->event_mgr.find_events(common_msg::EXPRIE_EVENT_PAY_DAY);
	if (events.empty()){
		return false;
	}
	return true;
	//auto e = this->event_mgr.find(common_msg::EXPRIE_EVENT_PAY_DAY);
	//return NULL != e;
}


int gateway_t::on_get_user_show_msg(el::lib_tcp_peer_info_t* peer_fd_info,
								google::protobuf::Message* msg,
								user_t* user)
{
	auto in = (gateway_msg::get_user_show_msg*)msg;

	USER_ID uid = GEN_MAIL_RECV_UID(user->uid(), in->uid());

	{//send to db
		db_msg::get_user_show_msg out;
		out.set_uid(uid);

		g_dbproxy->send_msg(&out, 0, db_get_user_show_msg_cmd, user);
	}

	return 0;
}

int dbproxy_t::on_get_user_show_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){
	if (0 != ret){
		user->send_err(cli_get_user_show_msg_cmd, ret);
		return 0;
	}

	db_msg::get_user_show_msg_res* in = (db_msg::get_user_show_msg_res*)msg;
	gateway_msg::get_user_show_msg_res out;

	out.mutable_user_show()->CopyFrom(in->user_show());
	user->send_msg(cli_get_user_show_msg_cmd, &out);
	return SUCC;
}

int gateway_t::on_get_peer_user_home_msg(el::lib_tcp_peer_info_t* peer_fd_info,
									google::protobuf::Message* msg,
									user_t* user)
{
	auto in = (gateway_msg::get_peer_user_home_msg*)msg;

	USER_ID uid = GEN_MAIL_RECV_UID(user->uid(), in->uid());

	{//send to db
		db_msg::get_peer_user_home_msg out;
		out.set_uid(uid);

		g_dbproxy->send_msg(&out, 0, db_get_peer_user_home_msg_cmd, user);
	}

	return 0;
}

int dbproxy_t::on_get_peer_user_home_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){
	if (0 != ret){
		user->send_err(cli_get_peer_user_home_msg_cmd, ret);
		return 0;
	}

	db_msg::get_peer_user_home_msg_res* in = (db_msg::get_peer_user_home_msg_res*)msg;
	gateway_msg::get_peer_user_home_msg_res out;

	out.mutable_user_home()->CopyFrom(in->user_home());
	user->send_msg(cli_get_peer_user_home_msg_cmd, &out);
	return SUCC;
}

int gateway_t::on_add_friend_msg(el::lib_tcp_peer_info_t* peer_fd_info,
										 google::protobuf::Message* msg,
										 user_t* user)
{
	static int max_friend_cnt = 20;
	static int max_friend_cnt_vip = 50;
	auto in = (gateway_msg::add_friend_msg*)msg;
	USER_ID peer_uid = in->uid();
	if (peer_uid == user->uid()){
		return share_msg::EC_ERR_CODE;
	}

	std::map<EVENT_ID, event_t>& events = user->event_mgr.find_events(common_msg::FOREVER_EVENT_FRIEND);
	if (user->is_vip_active()){
		if (max_friend_cnt_vip <= events.size()){
			return share_msg::EC_ERR_CODE;
		}
	} else {
		if (max_friend_cnt <= events.size()){
			return share_msg::EC_ERR_CODE;
		}
	}
	
	{
		FOREACH(events, it){
			EVENT_ID friend_id = it->first;
			if (friend_id == peer_uid){
				return share_msg::EC_ERR_CODE;
			}
		}
	}

	{//send to db
		db_msg::check_uid_msg out;
		out.set_uid(peer_uid);
		g_dbproxy->send_msg(&out, peer_uid, db_check_uid_msg_cmd, user);
	}
	return 0;
}

int dbproxy_t::on_check_uid_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){
	if (0 != ret){
		user->send_err(cli_add_friend_msg_cmd, ret);
		return 0;
	}

	db_msg::check_uid_msg_res* in = (db_msg::check_uid_msg_res*)msg;

	if (0 == in->uid()){
		gateway_msg::add_friend_msg_res out;
		user->send_err(cli_add_friend_msg_cmd, share_msg::EC_INEXISTENT_USER);
	} else {
		user->event_mgr.update_event(user->uid(), common_msg::FOREVER_EVENT_FRIEND, in->uid(), 0, 0);
		{
			gateway_msg::add_friend_msg_res out;
			out.set_uid(in->uid());
			user->send_msg(cli_add_friend_msg_cmd, &out);
		}
	}
	return SUCC;
}

int gateway_t::on_del_friend_msg(el::lib_tcp_peer_info_t* peer_fd_info,
								 google::protobuf::Message* msg,
								 user_t* user)
{
	auto in = (gateway_msg::del_friend_msg*)msg;
	USER_ID peer_uid = in->uid();

	std::map<EVENT_ID, event_t>& events = user->event_mgr.find_events(common_msg::FOREVER_EVENT_FRIEND);
	{
		FOREACH(events, it){
			EVENT_ID friend_id = it->first;
			if (friend_id == peer_uid){
				user->event_mgr.del_event(user->uid(), common_msg::FOREVER_EVENT_FRIEND, peer_uid);
				{
					gateway_msg::del_friend_msg_res out;
					out.set_uid(peer_uid);
					user->send_msg_res(&out);
				}
				return 0;
			}
		}
	}

	return 0;
}

int gateway_t::on_random_friend_msg(el::lib_tcp_peer_info_t* peer_fd_info,
								 google::protobuf::Message* msg,
								 user_t* user)
{
	{//send to db
		db_msg::random_friend_msg out;
		g_dbproxy->send_msg(&out, 0, db_random_friend_msg_cmd, user);
	}
	return 0;
}

int dbproxy_t::on_random_friend_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){
	if (0 != ret){
		user->send_err(cli_random_friend_msg_cmd, ret);
		return 0;
	}

	db_msg::random_friend_msg_res* in = (db_msg::random_friend_msg_res*)msg;
	{
		gateway_msg::random_friend_msg_res out;
		FOREACH_PB(in->uid, idx){
			USER_ID peer_uid = in->uid(idx);
			if (peer_uid == user->uid()){
				continue;
			}
			
			out.add_uid(peer_uid);
		}
		user->send_msg(cli_random_friend_msg_cmd, &out);
		//user->send_msg_res(&out);
	}
	return SUCC;
}

int gateway_t::on_flower_msg(el::lib_tcp_peer_info_t* peer_fd_info,
								 google::protobuf::Message* msg,
								 user_t* user)
{
	auto in = (gateway_msg::flower_msg*)msg;
	USER_ID peer_uid = in->uid();

	{
		event_t* e = user->event_mgr.find(common_msg::DAILY_EVENT_FLOWER, peer_uid);
		if (NULL != e){
			return 0;
		}
	}
	{
		std::map<EVENT_ID, event_t>& events = user->event_mgr.find_events(common_msg::DAILY_EVENT_FLOWER);
		if (100 <= events.size()){
			return 0;
		}
	}
	{
		event_t* e = user->event_mgr.find(common_msg::FOREVER_EVENT_FRIEND, peer_uid);
		if (NULL == e){
			return 0;
		}
	}

	user->event_mgr.update_event(user->uid(), common_msg::DAILY_EVENT_FLOWER, peer_uid, 0, el::lib_time_t::tomorrow_start_time() - 1 );

	EVENT_DATA money_cnt = user->event_mgr.find_data(common_msg::DAILY_EVENT_FLOWER_MONEY, 0);
	if (g_game_cfg_mgr->daily_game_flower_money_cnt_max <= money_cnt){
	} else {
		user->item_mgr.add(share_msg::E_ITEM_ID_MONEY, g_game_cfg_mgr->daily_game_flower_money_cnt);
		user->event_mgr.update_event(user->uid(), common_msg::DAILY_EVENT_FLOWER_MONEY, 0, money_cnt + g_game_cfg_mgr->daily_game_flower_money_cnt, el::lib_time_t::tomorrow_start_time() - 1 );
	}
	
	// 给对方加一朵花  [2019/1/4 Administrator]
	user_t* peer_user = g_user_mgr->find(peer_uid);
	if (NULL == peer_user){
		// 加到对方数据库中 [2019/1/4 Administrator]

		db_msg::add_item_msg out;
		out.mutable_item()->set_id(share_msg::E_ITEM_ID_FLOWER);
		out.mutable_item()->set_cnt(1);
		g_dbproxy->send_msg(&out, peer_uid, db_add_item_msg_cmd, NULL);
	} else {
		peer_user->item_mgr.add(share_msg::E_ITEM_ID_FLOWER, 1);
	}

	{
		gateway_msg::flower_msg_res out;
		user->send_msg_res(&out);
	}
	{
		share_msg::mail_1_t out_mail;
		out_mail.set_uid(user->uid());
		out_mail.set_nick(user->nick());
		out_mail.set_time(el_async::get_now_sec());
		mail_mgr_t::add_record(peer_user, peer_uid, 1, &out_mail);
	}
	return 0;
}

int gateway_t::on_body_on_msg(el::lib_tcp_peer_info_t* peer_fd_info,
									google::protobuf::Message* msg,
									user_t* user)
{
	auto in = (gateway_msg::body_on_msg*)msg;

	common_msg::item_cfg_t* item_cfg = g_item_cfg_mgr->find(in->id());
	if (NULL == item_cfg){
		return 0;
	}
	if (!user->is_vip_active() && 0 != item_cfg->vip()){
		return 0;
	}
	
	if (!g_item_cfg_mgr->is_clothes(in->id())){
		return 0;
	}
	share_msg::item_t* item = user->item_mgr.find(in->id());
	if (NULL == item){
		return 0;
	}
	
	user->item_mgr.clothes_on(in->id());
	
	{
		gateway_msg::body_on_msg_res out;
		user->send_msg_res(&out);
	}

	user->task_mgr.listen_daily_task(share_msg::E_TASK_DAILY_TYPE_3, 1);

	return 0;
}

int gateway_t::on_body_off_msg(el::lib_tcp_peer_info_t* peer_fd_info,
							  google::protobuf::Message* msg,
							  user_t* user)
{
	auto in = (gateway_msg::body_off_msg*)msg;

	EVENT_DATA event_data = user->event_mgr.find_data(common_msg::FOREVER_EVENT_ROLE_CLOTHES, in->body_type());
	if (0 == event_data){
		return 0;
	}

	user->item_mgr.clothes_off(in->body_type());
	{
		gateway_msg::body_off_msg_res out;
		user->send_msg_res(&out);
	}

	user->task_mgr.listen_daily_task(share_msg::E_TASK_DAILY_TYPE_3, 1);
	return 0;
}

int gateway_t::on_furniture_pos_msg(el::lib_tcp_peer_info_t* peer_fd_info,
							   google::protobuf::Message* msg,
							   user_t* user)
{
	auto in = (gateway_msg::furniture_pos_msg*)msg;

	share_msg::furniture_t* f = user->furniture_mgr.find(in->mutable_furniture()->id());
	if (NULL == f){
		return 0;
	}

	if (0 != in->mutable_furniture()->x() || 0 != in->mutable_furniture()->y()){
		common_msg::item_cfg_t* item_cfg = g_item_cfg_mgr->find(f->id());
		if (NULL == item_cfg){
			return 0;
		}
		if (0 != item_cfg->vip() && !user->is_vip_active()){
			return 0;
		}
	}

	f->set_x(in->mutable_furniture()->x());
	f->set_y(in->mutable_furniture()->y());
	user->furniture_mgr.update(f);

	{
		gateway_msg::furniture_pos_msg_res out;
		out.mutable_furniture()->CopyFrom(*f);
		user->send_msg_res(&out);
	}

	user->task_mgr.listen_daily_task(share_msg::E_TASK_DAILY_TYPE_2, 1);
	return 0;
}

int gateway_t::on_wall_on_msg(el::lib_tcp_peer_info_t* peer_fd_info,
							  google::protobuf::Message* msg,
							  user_t* user)
{
	auto in = (gateway_msg::wall_on_msg*)msg;

	common_msg::item_cfg_t* item_cfg = g_item_cfg_mgr->find(in->id());
	if (NULL == item_cfg){
		return 0;
	}
	if (!g_item_cfg_mgr->is_wall(in->id())){
		return 0;
	}
	share_msg::item_t* item = user->item_mgr.find(in->id());
	if (NULL == item){
		return 0;
	}

	user->item_mgr.wall_on(in->id());

	{
		gateway_msg::wall_on_msg_res out;
		user->send_msg_res(&out);
	}

	user->task_mgr.listen_daily_task(share_msg::E_TASK_DAILY_TYPE_2, 1);
	return 0;
}

/*
int gateway_t::on_get_user_info_msg(el::lib_tcp_peer_info_t* peer_fd_info,
									google::protobuf::Message* msg,
									user_t* user)
{
	auto in = (gateway_msg::get_user_info_msg*)msg;

	user_t* u = g_user_mgr->find(in->uid());
	if (NULL != u){
		gateway_msg::get_user_info_msg_res out;

		out.set_achievement_cnt(u->achievement_mgr.get_finish_cnt());

		user->send_msg(cli_get_user_info_msg_cmd, &out);
	} else {
// 		{//send to db
// 			db_msg::get_user_info_msg out;
// 			out.set_uid(in->uid());
// 
// 			g_dbproxy->send_msg(&out, 0, db_get_user_info_msg_cmd, user);
// 		}
	}

	return 0;
}
*/