#include "sign.h"
#include "item.h"
#include "gateway.h"
#include <gateway_msg.pb.h>
#include "user.h"

sign_cfg_mgr_t* g_sign_cfg_mgr;

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

void sign_mgr_t::load_sign_day( const EVENT_STR_DATA& str_data )
{
	std::vector<uint32_t> day_vec;
	el::g_cat_string(day_vec, str_data);

	FOREACH(day_vec, it){
		this->sign_day_set.insert(*it); 
	}
}

void sign_mgr_t::load_get_reward( const EVENT_STR_DATA& str_data )
{
	std::vector<uint32_t> vec;
	el::g_cat_string(vec, str_data);

	FOREACH(vec, it){
		this->sign_day_get_reward_set.insert(*it); 
	}
}



//////////////////////////////////////////////////////////////////////////
//sign config
//////////////////////////////////////////////////////////////////////////

sign_cfg_t* sign_cfg_mgr_t::find( uint32_t day )
{
	auto it = this->sign_cfg_map.find(day);
	if (this->sign_cfg_map.end() == it){
		return NULL;
	}
	return &it->second;
}

void sign_cfg_mgr_t::init()
{
	this->sign_cfg_map.clear();
}

bool sign_cfg_mgr_t::load_cfg()
{
	const std::string cfg_path = "./cfg/sign.xml";
	el::lib_xmlparser_t xml;
	int ret = xml.open(cfg_path.c_str());
	if (SUCC != ret){
		ALERT_LOG("open");
		return false;
	}

	this->init();

	xml.move2children_node();
	xmlNodePtr cur = xml.node_ptr;
	while (cur) {
		if (!xmlStrcmp(cur->name, (const xmlChar *)"sign")) {
			std::string str_def;
			{
				std::string str_reward;
				xml.get_xml_prop_def(cur, str_reward, "reward", str_def);

				std::vector<uint_pair> uint_pair_val;
				str_split_uint(str_reward, uint_pair_val);
				FOREACH(uint_pair_val, it) {
					if (NULL == g_item_cfg_mgr->find(it->key)){
						ALERT_LOG("[reward:%u]", it->key);
						return false;
					}
					if (!this->day_reward_map.insert(std::make_pair(it->key, it->val)).second) {
						ALERT_LOG("[reward:%u]", it->key);
						return false;
					}
				}
			}
			{
				std::string str_reward;
				xml.get_xml_prop_def(cur, str_reward, "vipreward", str_def);

				std::vector<uint_pair> uint_pair_val;
				str_split_uint(str_reward, uint_pair_val);
				FOREACH(uint_pair_val, it) {
					if (NULL == g_item_cfg_mgr->find(it->key)){
						ALERT_LOG("[reward:%u]", it->key);
						return false;
					}
					if (!this->day_vipreward_map.insert(std::make_pair(it->key, it->val)).second) {
						ALERT_LOG("[reward:%u]", it->key);
						return false;
					}
				}
			}

			xmlNodePtr child_cur = cur->xmlChildrenNode;
			while (child_cur) {
				if (!xmlStrcmp(child_cur->name, (const xmlChar *)"day")) {
					sign_cfg_t sign_cfg;
					uint32_t day = 0;
					xml.get_xml_prop(child_cur, day, "id");

					std::string str_reward;
					xml.get_xml_prop_def(child_cur, str_reward, "reward", str_def);

					std::vector<uint_pair> uint_pair_val;
					str_split_uint(str_reward, uint_pair_val);
					FOREACH(uint_pair_val, it) {
						if (NULL == g_item_cfg_mgr->find(it->key)){
							ALERT_LOG("[reward:%u]", it->key);
							return false;
						}

						if (!sign_cfg.reward_map.insert(std::make_pair(it->key, it->val)).second) {
							ALERT_LOG("[reward:%u]", it->key);
							return false;
						}
					}
					if (!this->sign_cfg_map.insert(std::make_pair(day, sign_cfg)).second) {
						ALERT_LOG("[step_id:%u]", day);
						return false;
					}
				}

				child_cur = child_cur->next;
			}//while
		}

		cur = cur->next;
	}//while
	return true;
}

sign_cfg_t::sign_cfg_t()
{
}


//////////////////////////////////////////////////////////////////////////

int gateway_t::on_sign_msg(el::lib_tcp_peer_info_t* peer_fd_info,
							   google::protobuf::Message* msg,
							   user_t* user)
{
	uint16_t year = 0; 
	uint8_t month = 0;
	uint8_t day = 0;
	uint8_t hour = 0;
	uint8_t minute = 0;
	uint8_t second = 0;
	el::lib_time_t::cal_ymdhms(el_async::get_now_sec(), year, month, day, hour, minute, second);

	auto it = user->sign_mgr.sign_day_set.find(day);
	if (user->sign_mgr.sign_day_set.end() != it){
		return share_msg::EC_VALUE_INVALID;
	}

	user->sign_mgr.sign_day_set.insert(day);

	{//update event
		std::string str_data;
		FOREACH(user->sign_mgr.sign_day_set, it){
			str_data += el::convert_to_string(*it);
			str_data += ",";
		}
		str_data.pop_back();
		user->event_mgr.update_event(user->uid(), common_msg::MONTHLY_EVENT_SIGN, 0, 0, el::lib_time_t::next_month_start_time(el_async::get_now_sec())-1, str_data);
	}

	{//send to user
		gateway_msg::sign_msg_res out;
		user->send_msg_res(&out);
	}

	{
		if (user->is_vip_active()){
			FOREACH(g_sign_cfg_mgr->day_vipreward_map, it){
				user->item_mgr.add(it->first, it->second);
			}
		} else {
			FOREACH(g_sign_cfg_mgr->day_reward_map, it){
				user->item_mgr.add(it->first, it->second);
			}
		}
	}
	return 0;
}

int gateway_t::on_sign_reward_msg(el::lib_tcp_peer_info_t* peer_fd_info,
						   google::protobuf::Message* msg,
						   user_t* user)
{
	return 0;//废弃		
	auto in = (gateway_msg::sign_reward_msg*)msg;
	uint32_t reward_key = in->day();

	auto it = user->sign_mgr.sign_day_get_reward_set.find(reward_key);
	if (user->sign_mgr.sign_day_get_reward_set.end() != it){
		return share_msg::EC_VALUE_INVALID;
	}

	auto sign_cfg = g_sign_cfg_mgr->find(reward_key);
	if (NULL == sign_cfg){
		return share_msg::EC_VALUE_INVALID;
	}
	uint32_t now_sec = el_async::get_now_sec();
	
	if (0 == reward_key){// 检查连续天数是否足够 	
		int cur_yyyymm = el::lib_time_t::get_date_yyyymm(now_sec);
		int next_yyyymm = el::lib_time_t::get_date_yyyymm(now_sec + el::lib_time_t::ONE_DAY_SEC);
		if (cur_yyyymm == next_yyyymm){
			return share_msg::EC_VALUE_INVALID;
		}

		uint16_t year = 0; 
		uint8_t month = 0;
		uint8_t day = 0;
		uint8_t hour = 0;
		uint8_t minute = 0;
		uint8_t second = 0;
		el::lib_time_t::cal_ymdhms(now_sec, year, month, day, hour, minute, second);

		if (user->sign_mgr.sign_day_set.size() < day){
			return share_msg::EC_VALUE_INVALID;
		}
	} else {
		uint32_t cnt_max = el::g_serial_max_cnt(user->sign_mgr.sign_day_set);

		if (cnt_max < reward_key){
			return share_msg::EC_VALUE_INVALID;
		}
	}

	user->sign_mgr.sign_day_get_reward_set.insert(reward_key);

	{
		std::string str_data;
		FOREACH(user->sign_mgr.sign_day_get_reward_set, it){
			str_data += el::convert_to_string(*it);
			str_data += ",";
		}
		str_data.pop_back();
		user->event_mgr.update_event(user->uid(), common_msg::MONTHLY_EVENT_SIGN_REWARD, 0, 0, el::lib_time_t::next_month_start_time(now_sec)-1, str_data);
	}

	{
		gateway_msg::sign_reward_msg_res out;
		out.set_day(reward_key);
		user->send_msg_res(&out);
	}

	{
		FOREACH(sign_cfg->reward_map, it){
			user->item_mgr.add(it->first, it->second);
		}
	}
	return 0;
}

int gateway_t::on_sign_update_msg(el::lib_tcp_peer_info_t* peer_fd_info,
						   google::protobuf::Message* msg,
						   user_t* user)
{
	return 0;
	if (!user->item_mgr.is_has_all(share_msg::E_ITEM_ID_SIGN, 1)){
		return share_msg::EC_INEXISTENT_ITEM;
	}
	uint32_t now_sec = el_async::get_now_sec();
	uint16_t year = 0; 
	uint8_t month = 0;
	uint8_t day = 0;
	uint8_t hour = 0;
	uint8_t minute = 0;
	uint8_t second = 0;
	el::lib_time_t::cal_ymdhms(now_sec, year, month, day, hour, minute, second);

	uint32_t sign_day = 0;
	for (int i = day-1; i > 0; i--){
		auto it = user->sign_mgr.sign_day_set.find(i);
		if (user->sign_mgr.sign_day_set.end() == it){
			sign_day = i;
			break;
		}
	}
	if (0 == sign_day){
		return share_msg::EC_VALUE_INVALID;
	}

	user->item_mgr.reduce(share_msg::E_ITEM_ID_SIGN, 1);

	user->sign_mgr.sign_day_set.insert(sign_day);

	{
		std::string str_data;
		FOREACH(user->sign_mgr.sign_day_set, it){
			str_data += el::convert_to_string(*it);
			str_data += ",";
		}
		str_data.pop_back();
		user->event_mgr.update_event(user->uid(), common_msg::MONTHLY_EVENT_SIGN, 0, 0, el::lib_time_t::next_month_start_time(now_sec)-1, str_data);
	}

	{
		gateway_msg::sign_update_msg_res out;
		out.set_sign_day(sign_day);
		user->send_msg_res(&out);
	}

	{
		FOREACH(g_sign_cfg_mgr->day_reward_map, it){
			user->item_mgr.add(it->first, it->second);
		}
	}
	return 0;
}