import Signal from "../../core/Signal";
import Http from "../../utils/Http";
import PlayerMgr from "../../object/PlayerMgr";
import GMMgr from "../../core/GMMgr";
import NoticeMgr from "../../core/NoticeMgr";
import ChargeSum from "../../core/ChargeSum";
import DB from "../../utils/DB";
import Player from "../../object/Player";
// 网络请求
import bodyParser from "body-parser";
import express from "express";
import {Request, Response } from "express";
import Launch from "../../core/Launch";
import GameUtil from "../../core/GameUtil";
import SKDataUtil from "../../gear/SKDataUtil";
import SKLogger from "../../gear/SKLogger";
import DugMgr from "../../role/DugMgr";
import { MsgCode } from "../../role/EEnum";
import GameConf from "../../../conf/GameConf";
import MailData from "../../mail/MailData";
import MailMgr from "../../mail/MailMgr";
import JingJiChang from "../../activity/JingJiChang";
import LotteryMgr from "../../core/LotteryMgr";
import SignInMgr from "../../core/SignInMgr";
import MallMgr from "../../core/MallMgr";
import ZhenbukuiMgr from "../../activity/ZhenbukuiMgr";
import RobotMgr from "../../core/RobotMgr";
import SKRedisUtil from "../../gear/SKRedisUtil";
import DialMgr from "../../core/DialMgr";
import DebrisMall from "../../core/DebrisMall";
import OnlineRewards from "../../activity/OnlineRewards";
import Currency from "../../activity/Currency";
import Ofuda from "../../object/Ofuda";
import { nextTick } from "process";

export default class HttpGame {
	static shared = new HttpGame();
	app: any;
	constructor() {
		this.app = express();
		this.app.use(function (req: Request, res: Response, next: any) {
			res.header("Access-Control-Allow-Origin", "*");
			res.header("Access-Control-Expose-Headers", "'Content-Type,Access-Control-Allow-Headers,Authorization,X-Requested-With");
			res.header("Access-Control-Allow-Methods", "PUT,POST,GET,DELETE,OPTIONS");
			res.header("X-Powered-By", ' 3.2.1');
			res.header("Content-Type", "application/json;charset=utf-8");
			next();
		});
		this.app.use(bodyParser.json({ limit: "1mb" }));
		this.app.use(bodyParser.urlencoded({ limit: "1mb", extended: true }));
	}

	loginToken(req: any, res: any) {
		SKLogger.info("login token")
		let accountid = req.query.accountid;
		let roleid = req.query.roleid;
		let login_token = req.query.token;
		Signal.shared.addLoginToken(accountid, login_token);
		Http.reply(res, {
			result: MsgCode.SUCCESS,
		});
	}

	getClientIP(req: any, res: any): string {
		var ip = req.headers['x-forwarded-for'] ||
			req.ip ||
			req.connection.remoteAddress ||
			req.socket.remoteAddress ||
			req.connection.socket.remoteAddress || '';
		if (ip.split(',').length > 0) {
			ip = ip.split(',')[0];
		}
		return ip;
	}
	// 充值回调
	chargeCallback(req: any, res: any) {
		let roleid = req.query.roleid;
		let jade = SKDataUtil.numberBy(req.query.jade);
		let sdorderno = req.query.sdorderno;
		let sdpayno = req.query.sdpayno;
		let sd_money: number = SKDataUtil.numberBy(req.query.sd_money);
		let total_fee: number = SKDataUtil.numberBy(req.query.total_fee);
		let msg: string = "";
		if (sd_money != total_fee) {
			// 支付调试模式下不验证金额是否匹配
			if (GameConf.debugPay.length < 0) {
				msg = `支付:在线玩家[${roleid}]订单金额${sd_money}元与实充金额${total_fee}元不匹配，游戏订单${sdorderno},支付订单${sdpayno}无效！`
				SKLogger.warn(msg);
			}
		}
		let player = PlayerMgr.shared.getPlayerByRoleId(roleid);
		if (player) {
			let msg = `支付:在线玩家[${player.roleid}:${player.name}]充值${jade}仙玉成功，游戏订单${sdorderno},支付订单${sdpayno}！`
			SKLogger.info(msg);
			player.send('s2c_notice', {
				strRichText: `您充值${total_fee}元成功！`,
			});
			// 充值奖励凤羽道具
			this.addGoods(roleid,50019, Math.ceil(total_fee/2))
			ChargeSum.shared.playerCharge(roleid, total_fee, jade);
			Http.reply(res, { code: MsgCode.SUCCESS, msg: msg });
		} else {
			msg = `支付:离线玩家${roleid}充值${jade}仙玉成功，游戏订单:${sdorderno},支付订单:${sdpayno}！`
			SKLogger.info(msg);
			// 充值奖励凤羽道具
			this.addGoods(roleid,50019, Math.ceil(total_fee/2))
			ChargeSum.shared.playerCharge(roleid, total_fee, jade);
			Http.reply(res, { code: MsgCode.SUCCESS, msg: msg });
		}
	}
	// 系统通知
	sysNotice(req: any, res: any) {
		let text = req.query.text;
		let type = req.query.type;         // 1 走马灯 2 聊天框 3 走马灯 + 聊天框
		let serverid = req.query.servre_id; // 0 则全服公告
		let times = req.query.times;       // -1 则永久公告 需入库
		let interval = req.query.interval; // 单位 秒
		let id = req.query.id;             // 消息id
		if (!id) {
			id = 0;
		}
		let notice = {
			id: id,
			text: text,
			type: type,
			times: times,
			interval: interval,
		};
		NoticeMgr.shared.addNewNotice(notice);
		Http.reply(res, { code: MsgCode.SUCCESS, msg: `发送系统通知:${text}成功` });
	}

	// 同步风雨同舟数据
	syncDial(req: any, res: any) {
		DialMgr.shared.init();
		Http.reply(res, { code: MsgCode.SUCCESS, msg: `同步宝图数据成功` });
	}

	// 同步宝图数据
	syncTreasure(req: any, res: any) {
		LotteryMgr.shared.init();
		Http.reply(res, { code: MsgCode.SUCCESS, msg: `同步宝图数据成功` });
	}

	// 同步签到数据
	syncSignIn(req: any, res: any) {
		SignInMgr.shared.readDB();
		Http.reply(res, { code: MsgCode.SUCCESS, msg: `同步签到数据成功` });
	}

	// 同步新鲜玩意数据
	syncFresh(req: any, res: any) {
		MallMgr.shared.syncFresh();
		Http.reply(res, { code: MsgCode.SUCCESS, msg: `同步新鲜玩意数据成功` });
	}

	// 同步强化材料数据
	syncIntensify(req: any, res: any) {
		MallMgr.shared.syncIntensify();
		Http.reply(res, { code: MsgCode.SUCCESS, msg: `同步强化材料数据成功` });
	}

	// 同步限购商店
	syncQuota(req: any, res: any) {
		MallMgr.shared.syncQuota();
		Http.reply(res, { code: MsgCode.SUCCESS, msg: `同步限购数据成功` });
	}

	// 同步每日推荐
	syncRecommend(req: any, res: any) {
		MallMgr.shared.syncRecommend();
		Http.reply(res, { code: MsgCode.SUCCESS, msg: `同步每日推荐数据成功` });
	}

	// 同步积分商店
	syncIntegral(req: any, res: any) {
		MallMgr.shared.syncIntegral();
		Http.reply(res, { code: MsgCode.SUCCESS, msg: `同步积分商店数据成功` });
	}

	// 同步绑定商店
	syncBindJade(req: any, res: any) {
		MallMgr.shared.syncBindJade();
		Http.reply(res, { code: MsgCode.SUCCESS, msg: `同步绑定商店数据成功` });
	}

	// 同步碎片商店
	syncDebris(req: any, res: any) {
		DebrisMall.shared.init();
		Http.reply(res, { code: MsgCode.SUCCESS, msg: `同步碎片商店数据成功` });
	}

	// 同步在线奖励
	syncOnlineRewards(req: any, res: any) {
		OnlineRewards.shared.init();
		Http.reply(res, { code: MsgCode.SUCCESS, msg: `同步在线奖励数据成功` });
	}

	// 同步限购商店
	syncKuiNot(req: any, res: any) {
		ZhenbukuiMgr.shared.init();
		Http.reply(res, { code: MsgCode.SUCCESS, msg: `同步甄不亏数据成功` });
	}

	deleteNotice(req: any, res: any) {
		let id = req.query.id;
		NoticeMgr.shared.delNotice(id);
		Http.reply(res, { errcode: MsgCode.SUCCESS });
	}

	can_speak(req: any, res: any) {
		let roleid = req.query.roleid;
		let state = req.query.state;
		GMMgr.shared.can_speak(roleid, state);
		Http.reply(res, { code: MsgCode.SUCCESS });
	}

	clearPCache(req: any, res: any) {
		let ip = this.getClientIP(req, res);
		if (ip != GameConf.gate_ip) {
			return;
		}
		let roleid = req.query.roleid;
		PlayerMgr.shared.clearPlayerCache(roleid);
		res.end(SKDataUtil.toJson({
			ret: `操作完成`,
		}, "{}"));
	}

	kickedOut(req: any, res: any) {
		let roleids = req.query.roleids;
		let sign = req.query.sign; // 签名
		if (sign != GameConf.sign) {
			Http.reply(res, {
				code: MsgCode.FAILED,
				msg: `你是傻逼吗!`
			});
			return;
		}
		PlayerMgr.shared.kickedOutPlayer(roleids);
	}

	/*
	 * 设置充值活动时间
	 */
	setChargeActivity(req: any, res: any) {
		let start = parseInt(req.query.start);
		let end = parseInt(req.query.end);
		GMMgr.shared.setChargeActivity(start, end);
		Http.reply(res, { errcode: 0, });
	}
	/*
	 * 关闭充值活动
	 */
	closeChargeActivity(req: any, res: any) {
		GMMgr.shared.closeChargeActivity();
		Http.reply(res, { errcode: 0, });
	}
	// 加仙玉
	addJade(req: any, res: any) {
		let roleId = req.query.roleId;
		let jade: number = parseInt(req.query.jade);
		jade = Math.min(100000000, jade);
		let player = PlayerMgr.shared.getPlayerByRoleId(roleId);
		if (player) {
			player.addMoney(GameUtil.goldKind.Jade, jade, "系统加仙玉");
			let info = `玩家[${player.roleid}:${player.name}]加${jade}仙玉成功`;
			SKLogger.debug(info);
			Http.reply(res, {
				code: MsgCode.SUCCESS,
				msg: info
			});
			return;
		}
		let info = `玩家[${roleId}}]加${jade}仙玉失败`;
		Http.reply(res, {
			code: MsgCode.FAILED,
			msg: info
		});
	}
	// 加经验
	addExp(req: any, res: any) {
		let roleId = req.query.roleId;
		let exp: number = parseInt(req.query.exp);
		exp = Math.min(999999999999, exp);
		let player = PlayerMgr.shared.getPlayerByRoleId(roleId);
		if (player) {
			player.addExp(exp);
			let info = `玩家[${player.roleid}:${player.name}]增加${exp}经验成功`;
			Http.reply(res, {
				code: MsgCode.SUCCESS,
				msg: info
			});
			return;
		}
		DB.addExp(roleId, exp, (code: any) => {
			Http.reply(res, {
				code: code
			});
		});
	}
	//模拟战斗
	testBattle(req: any, res: any){
		let roleId = req.query.roleId;
		let eroleId = req.query.eroleid;
		let player = PlayerMgr.shared.getPlayerByRoleId(roleId);
		if(player){
			JingJiChang.shared.battleStart(roleId,eroleId);
			Http.reply(res, { code: MsgCode.SUCCESS });
			return;
		}
		Http.reply(res, { code: MsgCode.FAILED });
	}

	//测试http线程锁死情况下， http链接能否处理，
	testSleep(){
		SKLogger.info("test slerrp...............")
		var start = (new Date()).getTime();
		while ((new Date()).getTime() - start < 5 * 60* 1000) { //卡死5分钟
			// 使用  continue 实现；
			continue; 
		}
		SKLogger.info("test slerrp...............success")
	}


	// 加道具
	addItem(req: any, res: any) {
		let roleId = req.query.roleId;
		let item: number = parseInt(req.query.item);
		let num: number = parseInt(req.query.num);
		let player = PlayerMgr.shared.getPlayerByRoleId(roleId);
		// 在线玩家发放道具
		if (player != null) {
			if (player.addItem(item, num, true, "")) {
				Http.reply(res, { code: MsgCode.SUCCESS });
			} else {
				Http.reply(res, { code: MsgCode.FAILED });
			}
			return;
		}
		// 离线玩家道具发放
		DB.loginByRoleid(roleId, (code: number, data: any) => {
			if (code != MsgCode.SUCCESS || data == null) {
				Http.reply(res, { code: MsgCode.FAILED });
				return;
			}
			let player = new Player();
			player.loaded = true;
			player.setDB(data);
			if (player.addItem(item, num, true, "")) {
				player.offline = false;
				player.saveAll((failed: string[]) => {
					player.offline = true;
					if (failed.length > 0) {
						SKLogger.warn(`玩家[${player.roleid}:${player.name}]加入存档道具失败!`);
						Http.reply(res, { code: MsgCode.FAILED });
					} else {
						SKLogger.warn(`玩家[${player.roleid}:${player.name}]加入存档道具成功!`);
						Http.reply(res, { code: MsgCode.SUCCESS });
					}
				});
				return;
			}
			SKLogger.warn(`玩家[${player.roleid}:${player.name}]加入道具失败!`);
			Http.reply(res, { code: MsgCode.FAILED });
		});
	}

	//发送天策符
	addOfuda(req: any, res: any){
		let roleId = req.query.roleId;
		let name = req.query.name;
		let grade = req.query.grade;
		let addition = req.query.addition;
		let ofudaobj = Ofuda.shared.createOfuda({
			roleid: parseInt(roleId),
			name: name,
			grade: grade,
			addition: addition
		});
		if(ofudaobj == null){
			Http.reply(res, { code: MsgCode.FAILED });
			return;
		}
		let player = PlayerMgr.shared.getPlayerByRoleId(roleId);
		// 在线玩家发放道具
		if (player) {
			if (Ofuda.shared.pofuda_map.has(player.roleid)) {//map里有没有这个key值
				Ofuda.shared.pofuda_map.get(player.roleid).push(ofudaobj)
			} else {
				let list = [];
				list.push(ofudaobj)
				Ofuda.shared.pofuda_map.set(player.roleid, list);
			}
			Http.reply(res, { code: MsgCode.SUCCESS });
			return;
		}else {
			Http.reply(res, { code: MsgCode.FAILED });
			return;
		}
	}

	// 充值发送道具
	addGoods(roleId: any,item: number,num:number){
		if (GameConf.integral){
			let player = PlayerMgr.shared.getPlayerByRoleId(roleId);
			// 在线玩家发放道具
			if (player != null) {
				player.addItem(item, num, true, "")
				return;
			}
			// 离线玩家道具发放
			DB.loginByRoleid(roleId, (code: number, data: any) => {
				if (code != MsgCode.SUCCESS || data == null) {
					return;
				}
				let player = new Player();
				player.loaded = true;
				player.setDB(data);
				if (player.addItem(item, num, true, "")) {
					player.offline = false;
					player.saveAll((failed: string[]) => {
						player.offline = true;
						if (failed.length > 0) {
							SKLogger.warn(`玩家[${player.roleid}:${player.name}]加入存档道具失败!`);
						} else {
							SKLogger.warn(`玩家[${player.roleid}:${player.name}]加入存档道具成功!`);
						}
					});
					return;
				}
				SKLogger.warn(`玩家[${player.roleid}:${player.name}]加入道具失败!`);
			});
		}
	}

	// 加称谓
	addTitle(req: any, res: any) {
		let role_id = req.query.role_id;
		let type = req.query.type;
		let title_id = req.query.title_id;
		let value = req.query.value;
		let onload = req.query.onload;
		let player = PlayerMgr.shared.getPlayerByRoleId(role_id);
		if (player) {
			player.addTitle(type, title_id, value, onload);
		} else {
			DB.addTitle(role_id, type, title_id, (code: number, msg: string) => {
			});
		}
		Http.reply(res, { code: MsgCode.SUCCESS });
	}

	// 提现更改
	withdrawState(req: any, res: any) {
		let state = req.query.state;
		let serial = req.query.serial;
		let role_id = req.query.role_id;
		let flag: boolean = Currency.shared.update_withdraw_state(role_id,{state:state,serial:serial});
		if (flag){
			Http.reply(res, { code: MsgCode.SUCCESS });
			return;
		}
		Http.reply(res, { code: MsgCode.FAILED });
		return;

	}

	// 获得现金
	obtainCurrency(req: any, res: any) {
		let msg = req.query.msg;
		let role_id = req.query.role_id;
		let player = PlayerMgr.shared.getPlayerByRoleId(role_id);
		if (player) {
			Currency.shared.gm_obtain_currency(player,msg);
			Http.reply(res, { code: MsgCode.SUCCESS });
			return;
		}
		Http.reply(res, { code: MsgCode.FAILED });
		return;

	}

	// 清理玩家任务
	closeTask(req: any, res: any) {
		let role_id = req.query.roleId;
		let player = PlayerMgr.shared.getPlayerByRoleId(role_id);
		if (player) {
			player.F5_Task();
		}
		Http.reply(res, { code: MsgCode.SUCCESS });
	}

	// 恢复数据
	async rollbackPlayer(req: any, res: any) {

		let role_id = req.query.roleId;
		let msg = "";
		// 先进行清理角色
		let player = PlayerMgr.shared.player_role_list[role_id];
		if (player){
			player.destroy();
			delete PlayerMgr.shared.player_role_list[player.roleid];
			delete PlayerMgr.shared.player_only_list[player.onlyid];
		}
		// 获取角色缓存
		let role = await  SKRedisUtil.getValue(role_id.toString());
		let pet = await  SKRedisUtil.getValue(role_id + "pet");
		let scheme = await  SKRedisUtil.getValue(role_id + "scheme");
		let hourse = await  SKRedisUtil.getValue(role_id + "hourse");
		let hourseskill = await  SKRedisUtil.getValue(role_id + "hourseskill");
		// 数据不为undefined
		if (role != undefined){
			let callback = (ret: any, item: any) => {
				if (ret == MsgCode.SUCCESS) {
					msg = "成功";
					Http.reply(res, {code: MsgCode.SUCCESS, msg: msg});
				} else {
					msg = "失败";
					Http.reply(res, {code: MsgCode.SUCCESS, msg: msg});
				}
				DB.saveSignIn(SKDataUtil.toJson(role.daySignIn,"{}"), role_id, role.mendDate,(code: number, msg: string) => {
					let info = `存档:[${role_id}:${role.dbinfo.name}]签到数据存档`;
					if (code == MsgCode.SUCCESS) {
						info += `成功!`;
						SKLogger.debug(info);
					} else {
						info += `失败[${msg}]!`;
						SKLogger.warn(info);
					}
				});
				DB.saveDial(role_id, role.dial_num,role.dial_count,role.dial_date,(code: number, msg: string) => {
					let info = `存档:[${role_id}:${role.dbinfo.name}]风雨转盘数据存档`;
					if (code == MsgCode.SUCCESS) {
						info += `成功!`;
						SKLogger.debug(info);
					} else {
						info += `失败[${msg}]!`;
						SKLogger.warn(info);
					}
				});
				DB.savePetsRedis(pet, role_id, (code: number, msg: string) => {
					let info = `存档:[${role_id}:${role.dbinfo.name}]召唤兽存档`;
					if (code == MsgCode.SUCCESS) {
						info += `成功!`;
						SKLogger.debug(info);
					} else {
						info += `失败[${msg}]!`;
						SKLogger.warn(info);
					}
				});
				// 保存套装
				DB.saveSchemeRedis(scheme, (code: number, msg: string) => {
				});
				DB.saveHorseList(role_id, hourse, (error: any, rows: any[]) => {
					if (error != null) {
						SKLogger.warn(`存档:玩家[${role_id}:坐骑列表存档失败[${DB.errorInfo(error)}]!`);
					} else {
						SKLogger.debug(`存档:玩家[${role_id}:坐骑列表存档成功!`);
					}
				});
				DB.saveHorseSkillList(role_id, hourseskill, (error: any, rows: any[]) => {
					if (error != null) {
						SKLogger.warn(`存档:玩家[${role_id}:坐骑技能存档失败[${DB.errorInfo(error)}]!`);
					} else {
						SKLogger.debug(`存档:玩家[${role_id}:坐骑技能存档完成!`);
					}
				});
				callback = null;
			}
			DB.savePlayerInfo(role_id, role.dbinfo, callback);
		}else {
			Http.reply(res, {code: MsgCode.FAILED, msg: "缓存数据中没有该玩家信息"});
		}
	}


	// 创建机器人
	createRobot(req: any, res: any) {
		RobotMgr.shared.createRobotOn(req.query.num,(code,count) => {
			let msg = `以创建机器人:${count}！`;
			Http.reply(res, { code: code, msg: msg });
		});
	}

	// 清理机器人
	clearRobot(req: any, res: any) {
		RobotMgr.shared.remoteAllRobot(req.query.num,(code,count) => {
			let msg = `以清理机器人:${count}！`;
			Http.reply(res, { code: code, msg: msg });
		});
	}

	// 清除玩家每日存档
	clearDay(req: any, res: any) {
		let roleId = req.query.roleId;
		let type: number = parseInt(req.query.type);
		let player = PlayerMgr.shared.getPlayerByRoleId(roleId);
		if (player != null) {
			player.clearDayMap();
			Http.reply(res, { code: MsgCode.SUCCESS });
			return;
		}
		DB.loginByRoleid(roleId, (code: number, data: any) => {
			if (code != MsgCode.SUCCESS || data == null) {
				Http.reply(res, { code: MsgCode.FAILED });
				return;
			}
			let player = new Player();
			player.offline = false;
			player.setDB(data);
			player.clearDayMap();
			player.saveAll((failed: string[]) => {
				player.offline = true;
				if (failed.length > 0) {
					SKLogger.warn(`玩家[${player.roleid}:${player.name}]清除每日存档失败!`);
					Http.reply(res, { code: MsgCode.FAILED });
				} else {
					SKLogger.debug(`玩家[${player.roleid}:${player.name}]清除每日存档成功!`);
					Http.reply(res, { code: MsgCode.SUCCESS });
				}
			});
		})
	}
	// 清理所有的玩家每日存档
	clearAllDay(req: any, res: any) {
		PlayerMgr.shared.clearAllDayCount();
		let msg = `服务器[${GameUtil.serverName}][在线玩家数:${GameUtil.online}]已清空所有玩家每日存档！`;
		Http.reply(res, { code: MsgCode.SUCCESS, msg: msg });
	}
	// 控制
	control(req: any, res: any) {
		let type = (req.query.type ? req.query.type : 0);
		let open = (req.query.open ? req.query.open : 1);
		let msg = `控制完成`;
		if (type == 1) {
			let enabled = (open == 1);
			if (DugMgr.enabled != enabled) {
				DugMgr.enabled = enabled;
				msg = `${DugMgr.enabled ? `开启` : `关闭`}今日挖宝!`
				SKLogger.info(msg);
			}
		}
		Http.reply(res, { code: MsgCode.SUCCESS, msg: msg });
	}
	// 全部存档
	saveAll(req: any, res: any) {
		SKLogger.info(`服务器[${GameUtil.serverName}]正在存档!`);
		Launch.shared.saveAll(() => {
			let msg = `服务器[${GameUtil.serverName}]存档完成:机器人数[${GameUtil.robotCount}]在线玩家数[${GameUtil.online}]失败总数[${GameUtil.saveFailed.length}]存档总数[${GameUtil.saveTotal}]`;
			SKLogger.info(msg)
			let data = {
				server_id: GameUtil.serverId,
				server_name: GameUtil.serverName,
				online: GameUtil.online,
				saveCount: GameUtil.saveCount,
				saveTotal: GameUtil.saveTotal,
				saveFailed: GameUtil.saveFailed
			}
			Http.reply(res, { code: MsgCode.SUCCESS, msg: msg, data: data });
		});
	}

	// 备用存档
	saveAllReserve(req: any, res: any){
		let player_role_list: any = PlayerMgr.shared.player_role_list
		for (let roleId in player_role_list) {
			let player = player_role_list[roleId];
			if (player != null) {
				player.saveAllReserve();
			}
		}
		Http.reply(res, { code: MsgCode.SUCCESS, msg: "备用存档已经在执行中"});
	}

	// 关服
	close(req: any, res: any) {
		if (GameUtil.isClose) {
			let data = {
				server_id: GameUtil.serverId,
				server_name: GameUtil.serverName,
				online: GameUtil.online,
				saveCount: GameUtil.saveCount,
				saveTotal: GameUtil.saveTotal,
				saveFailed: GameUtil.saveFailed
			}
			if (Launch.shared.isClose) {
				let msg = `服务器[${GameUtil.serverName}]已关服:机器人数[${GameUtil.robotCount}]在线玩家数[${GameUtil.online}]失败总数[${GameUtil.saveFailed.length}]存档总数[${GameUtil.saveTotal}]`;
				Http.reply(res, { code: MsgCode.SUCCESS, msg: msg, data: data });
			} else {
				let msg = `服务器[${GameUtil.serverName}]正在关服:机器人数[${GameUtil.robotCount}]在线玩家数[${GameUtil.online}]存档进度[${GameUtil.saveCount}/${GameUtil.saveTotal}]`;
				Http.reply(res, { code: MsgCode.SUCCESS, msg: msg, data: data });
			}
			return;
		}
		GameUtil.isClose = true;
		SKLogger.info(`正在关闭服务器[${GameUtil.serverName}]!`);
		Launch.shared.close(() => {
			let msg = `服务器[${GameUtil.serverName}]关服完成:机器人数[${GameUtil.robotCount}]在线玩家数[${GameUtil.online}]失败总数[${GameUtil.saveFailed.length}]存档总数[${GameUtil.saveTotal}]`;
			SKLogger.info(msg);
			let data = {
				server_id: GameUtil.serverId,
				server_name: GameUtil.serverName,
				online: GameUtil.online,
				saveCount: GameUtil.saveCount,
				saveTotal: GameUtil.saveTotal,
				saveFailed: GameUtil.saveFailed
			}
			Http.reply(res, { code: MsgCode.SUCCESS, msg: msg, data });
		});
	}
	// 发送邮件
	sendMail(req: any, res: any) {
		if(!GameConf.mailEnabled){
			Http.reply(res, { code: MsgCode.FAILED, msg: `发送邮件:邮件功能未开启`});
			return;
		}
		let mail = new MailData();
		let info = mail.parseReq(req);
		if (info.length < 1) {
			MailMgr.shared.addSystemMail(mail);
			let msg = `发送邮件:服务器[${GameUtil.serverName}]发送邮件[${mail.mail_id}:${mail.title}]成功`;
			Http.reply(res, { code: MsgCode.SUCCESS, msg: msg });

			if(mail.role_id == 0){
				PlayerMgr.shared.broadcastEmail()
			}else{
				let player = PlayerMgr.shared.getPlayerByRoleId(mail.role_id)
				if(player){
					player.send("s2c_friend_apply", {});
				}
			}
			return;
		}
		Http.reply(res, { code: MsgCode.FAILED, msg: info });
	}

	//设置中间件， 判断卡死在哪条消息上
	beforeRecv(req: any, res: any, next: any){
		SKLogger.info(req.baseUrl)
		SKLogger.info(req.originalUrl)
		next();
	}

	// 启动Http服务
	start(port: number) {
		// 游戏服务器路由
		let list: { [key: string]: (req: any, res: any) => void } = {
			['login_token']: this.loginToken.bind(this),
			['charge_callback']: this.chargeCallback.bind(this),
			['sys_notice']: this.sysNotice.bind(this),
			['can_speak']: this.can_speak.bind(this),
			['delete_notice']: this.deleteNotice.bind(this),
			['clear_pcache']: this.clearPCache.bind(this),
			['kicked_out']: this.kickedOut.bind(this),
			['set_charge_activity']: this.setChargeActivity.bind(this),
			['close_charge_activity']: this.closeChargeActivity.bind(this),
			['add_jade']: this.addJade.bind(this),
			['add_exp']: this.addExp.bind(this),
			['add_item']: this.addItem.bind(this),
			['add_ofuda']: this.addOfuda.bind(this),
			['add_title']: this.addTitle.bind(this),
			["clear_day"]: this.clearDay.bind(this),
			["clear_all_day"]: this.clearAllDay.bind(this),
			// 全部存档
			["save_all"]: this.saveAll.bind(this),
			// 备用存档
			["save_all_reserve"]: this.saveAllReserve.bind(this),
			["control"]: this.control.bind(this),
			// 恢复数据
			["roll_back_player"]: this.rollbackPlayer.bind(this),
			// 清理玩家任务
			["close_task"]: this.closeTask.bind(this),
			// 关服
			["close"]: this.close.bind(this),
			["send_mail"]: this.sendMail.bind(this),
			// 同步风雨同舟数据
			["sync_dial"]: this.syncDial.bind(this),
			// 同步宝图数据
			["sync_treasure"]: this.syncTreasure.bind(this),
			// 同步签到数据
			["sync_signIn"]: this.syncSignIn.bind(this),
			// 同步新鲜玩意数据
			["sync_fresh"]: this.syncFresh.bind(this),
			// 同步强化材料数据
			["sync_intensify"]: this.syncIntensify.bind(this),
			// 同步限购商店数据
			["sync_quota"]: this.syncQuota.bind(this),
			// 同步限购商店数据
			["sync_recommend"]: this.syncRecommend.bind(this),
			// 同步限购商店数据
			["sync_integral"]: this.syncIntegral.bind(this),
			// 同步绑定商店数据
			["sync_bindjade"]: this.syncBindJade.bind(this),
			// 同步甄不亏商店数据
			["sync_kui_not"]: this.syncKuiNot.bind(this),
			// 同步碎片商城配置
			["sync_debris"]: this.syncDebris.bind(this),
			// 同步在线奖励配置
			["sync_online_rewards"]: this.syncOnlineRewards.bind(this),
			// 更改提现状态
			["withdraw_state"]: this.withdrawState.bind(this),
			// 获得现金
			["obtain_currency"]: this.obtainCurrency.bind(this),
			// 创建机器人数据
			["create_robot"]: this.createRobot.bind(this),
			// 清理机器人数据
			["clear_robot"]: this.clearRobot.bind(this),
			["test_battle"]: this.testBattle.bind(this),
			["test"]: this.testSleep.bind(this)
		};
		for (let key in list) {
			this.app.get('/' + key, [this.beforeRecv.bind(this)], list[key]);
		}
		this.app.listen(port);
	}
}