import Msg from '../utils/msg'; // 确保路径是正确的
import QuickAsy from '../utils/quickAsy';
import { parseString } from 'xml2js';
import {
    RefreshToken,
    PackageName,
    ProductId,
    IosUrl,
    SandboxIosUrl,
    Account,
    ClientSecret,
    ClientId,
    AppSecret360
} from '../config/thirdParams'
import {
    compareVersions,
    generateOrderNumber,
    formatDate,
    getServerList
} from '../utils/common'

const CryptoJS = require("crypto-js");
const Order = require('../model/OrderModel')
const Server = require('../model/ServerModel')
const Version = require('../model/VersionModel')
const CDK = require("../model/CDK")
const notice = require("../json/notice.json")
const th_notice = require("../json/th_notice.json")
const xky_notice = require("../json/xky_notice.json")
const logger = require('../utils/log')
const axios = require('axios');

const googleCallPay = async (ctx) => {

    let ret = {
        code: 0,
        msg: '发货失败'
    }

    let data = ctx.request.body
    let orderId = data.orderId
    let googleToken = data.purchaseToken
    let out_trade_no = ''
    logger.info("pay callback params:", { "url": ctx.href, "params": data })

    const res = await Order.updateOrderToken(
        orderId,
        googleToken,
        'google',
    );

    const redisClient = ctx.redis.client;
    let access_token = await redisClient.get('access_token');

    if (!access_token) {
        console.log('请求api获取token')
        const apiData = {
            "grant_type": "refresh_token",
            "client_id": ClientId,
            "client_secret": ClientSecret,
            "refresh_token": RefreshToken
        }

        const response = await axios.post('https://accounts.google.com/o/oauth2/token', apiData, {
            headers: {
                'Content-Type': 'application/x-www-form-urlencoded'
            }
        });

        logger.info("token params:", { "data": response.data, "params": apiData })

        if (!response.data.access_token) {
            return ret
        }

        access_token = response.data.access_token
        await redisClient.set('access_token', response.data.access_token);
        await redisClient.expire('access_token', 1800);
    }

    if (!access_token) {
        return ret;
    }

    const orderInfo = (await Order.getOrder(orderId))[0]

    if (!orderInfo) {
        logger.info(`订单${orderId}不存在`)
        ret.msg = `订单${orderId}不存在`
        return ret
    }

    if (orderInfo.status == 2) {
        logger.info(`订单${orderId}已经重复发货`)
        ret.code = 1
        ret.msg = `订单${orderId}已经重复发货`
        return ret
    }

    let url = await getServerList(orderInfo.server_id, 'default')
    if (!url) {
        logger.info(`区服id错误: serverId ${orderInfo.server_id}`)
        ret.msg = `区服id错误: serverId ${orderInfo.server_id}`
        return ret
    }

    const productId = ProductId + orderInfo.product_id
    let apiUrl = `https://androidpublisher.googleapis.com/androidpublisher/v3/applications/${PackageName}/purchases/products/${productId}/tokens/${googleToken}?access_token=${access_token}`
    let maxRetries = 3;
    let currentRetry = 0;
    let isCheck = false;

    // 使用 while 循环进行重试
    while (currentRetry < maxRetries) {
        try {

            // // 尝试执行的操作
            const googleRes = await axios.get(apiUrl, {
                headers: {
                    'Content-Type': 'application/x-www-form-urlencoded'
                }
            })

            console.log(googleRes.data)

            // 如果操作成功，退出循环
            if (googleRes.data.purchaseState == 0) {
                out_trade_no = googleRes.data.orderId
                isCheck = true
                break;
            }

        } catch (error) {
            // 捕获请求中的错误
            if (error.response) {
                // 请求已发出，服务器用状态码响应
                console.error(error.response.data);
                console.error(error.response.status);
                console.error(error.response.headers);
            } else if (error.request) {
                // 请求已发出但没有收到响应
                // 这通常是网络错误
                console.error(error.request);
            } else {
                // 在设置请求时出现错误
                console.error('Error', error.message);
            }
        }

        currentRetry++;
    }

    if (!isCheck) {
        return ret;
    }

    let sendMsg = new Msg()
    sendMsg.connect(url, Account);
    let orgMemId = orderInfo.uid
    let orgOderId = orderId
    let orgProductId = orderInfo.product_id
    let orgProductPrice = orderInfo.amount

    // 在适当的时机，调用 CG_ASK_LOGIN 方法
    let params = `{"account":"${orgMemId}","order":"${orgOderId}","id":${orgProductId},"cnt":100,"money":${orgProductPrice}}`
    return new Promise((resolve) => {
        setTimeout(async () => {

            const send_res = sendMsg.CG_ASK_LOGIN(Account, 0, "", 'cn', 'CN', ctx.request.ip, params);
            if (!send_res) {
                resolve(ret);
                return;
            }

            try {
                let acknowledgeUrl = `https://androidpublisher.googleapis.com/androidpublisher/v3/applications/${PackageName}/purchases/products/${productId}/tokens/${googleToken}:acknowledge?access_token=${access_token}`
                const acknowledgeRes = await axios.post(acknowledgeUrl,
                    {
                        developerPayload: ""
                    }
                    ,
                    {
                        headers: {

                            'Content-Type': 'application/json'
                        }
                    })

            } catch (error) {
                // 捕获请求中的错误
                if (error.response) {
                    // 请求已发出，服务器用状态码响应
                    console.error(error.response.data);
                    console.error(error.response.status);
                    console.error(error.response.headers);
                } else if (error.request) {
                    // 请求已发出但没有收到响应
                    // 这通常是网络错误
                    console.error(error.request);
                } else {
                    // 在设置请求时出现错误
                    console.error('Error', error.message);
                }
                ret.msg = '请求第三方失败'
                resolve(ret);
            }

            try {
                let consumeUrl = `https://androidpublisher.googleapis.com/androidpublisher/v3/applications/${PackageName}/purchases/products/${productId}/tokens/${googleToken}:consume?access_token=${access_token}`
                const consumeRes = await axios.post(consumeUrl,
                    {
                        developerPayload: ""
                    }
                    ,
                    {
                        headers: {

                            'Content-Type': 'application/json'
                        }
                    })
            } catch (error) {
                // 捕获请求中的错误
                if (error.response) {
                    // 请求已发出，服务器用状态码响应
                    console.error(error.response.data);
                    console.error(error.response.status);
                    console.error(error.response.headers);
                } else if (error.request) {
                    // 请求已发出但没有收到响应
                    // 这通常是网络错误
                    console.error(error.request);
                } else {
                    // 在设置请求时出现错误
                    console.error('Error', error.message);
                }
                ret.msg = '请求第三方失败'
                resolve(ret);
            }

            logger.info("谷歌 pass :", { "orderId": orderId })

            const update_time = formatDate(new Date())
            const res = await Order.updateOrderStats(
                orderId,
                2,
                out_trade_no,
                update_time
            );

            if (res.affectedRows <= 0) {
                logger.info(`订单${orderId} 发货失败`)
                ret.msg = '发货失败'
                resolve(ret);
                return;
            }

            ret.code = 1
            ret.msg = '发货成功'
            resolve(ret);
        }, 1000);
    });
}

const appleCallPay = async (ctx) => {
    let ret = {
        code: 0,
        msg: '发货失败'
    }

    let data = ctx.request.body
    logger.info("pay callback params:", { "url": ctx.href, "params": data })

    if (!data.purchaseToken || !data.orderId) {
        return ret;
    }

    let receipt_data = data.purchaseToken.replace(/ /g, '+')
    let orderId = data.orderId
    let maxRetries = 5;
    let currentRetry = 0;
    let isCheck = false;
    let out_trade_no = orderId

    const res = await Order.updateOrderToken(
        orderId,
        receipt_data,
        'apple',
    );

    // 使用 while 循环进行重试
    while (currentRetry < maxRetries) {
        try {

            const apiData = {
                "receipt-data": receipt_data,
            }

            const response = await axios.post(IosUrl, apiData, {
                headers: {
                    'Content-Type': 'application/json'
                }
            });

            logger.info(`苹果返回的状态:${response.data.status}`)
            // 如果操作成功，退出循环
            if (response.data.status == 0) {
                isCheck = true
                break;
            }

        } catch (error) {
            // 如果操作失败，记录错误并继续尝试
            console.log(error)
        }

        currentRetry++;
    }

    if (!isCheck) {
        logger.info(`票据验证失败！`)
        ret.msg = `票据验证失败！`
        return ret;
    }

    const orderInfo = (await Order.getOrder(orderId))[0]

    if (!orderInfo) {
        logger.info(`订单${orderId}不存在`)
        ret.msg = `订单${orderId}不存在`
        return ret
    }

    if (orderInfo.status == 2) {
        logger.info(`订单${orderId}已经重复发货`)
        ret.code = 1
        ret.msg = `订单${orderId}已经重复发货`
        return ret
    }

    let url = await getServerList(orderInfo.server_id, 'default')
    if (!url) {
        logger.info(`区服id错误: serverId ${orderInfo.server_id}`)
        ret.msg = `区服id错误: serverId ${orderInfo.server_id}`
        return ret
    }

    let sendMsg = new Msg()
    sendMsg.connect(url, Account);
    let orgMemId = orderInfo.uid
    let orgOderId = orderId
    let orgProductId = orderInfo.product_id
    let orgProductPrice = orderInfo.amount

    // 在适当的时机，调用 CG_ASK_LOGIN 方法
    let params = `{"account":"${orgMemId}","order":"${orgOderId}","id":${orgProductId},"cnt":100,"money":${orgProductPrice}}`
    return new Promise((resolve) => {
        setTimeout(async () => {

            logger.info(`订单${orderId}通知游戏发货开始`)

            const send_res = sendMsg.CG_ASK_LOGIN(Account, 0, "", 'cn', 'CN', ctx.request.ip, params);
            if (!send_res) {
                resolve(ret);
                return;
            }

            logger.info(`订单${orderId}通知游戏发货结束`)

            const update_time = formatDate(new Date())
            const res = await Order.updateOrderStats(
                orderId,
                2,
                out_trade_no,
                update_time
            );

            if (res.affectedRows <= 0) {
                logger.info(`订单${orderId} 发货失败`)
                ret.msg = '发货失败'
                resolve(ret);
                return;
            }

            ret.code = 1
            ret.msg = '发货成功'
            resolve(ret);

        }, 1000);
    });
}

//qucik发货
//扩展参数格式为${serverId};${productId}
const CallPayQuick = async (ctx) => {
    let ret = {
        code: 0,
        msg: '发货失败'
    }
    //sdk参数
    let md5Key = "gaug5awijz5kdqfkzdmikjfrt4jbpv5f"
    let callbackKey = "19404462610366331550315911887318"

    let data = ctx.request.body
    logger.info("qucik 回调参数", { "data": data })
    let md5Sign = data.md5Sign
    let ntData = data.nt_data
    let verifySignData = QuickAsy.getSign(data, md5Key)
    if (verifySignData != md5Sign) {
        logger.error("quick 调用md5Sign错误", { '$verifySignData': verifySignData, 'md5Sign': md5Sign })
        return ret
    }
    let xmlData = QuickAsy.decode(ntData, callbackKey)
    const result = await new Promise((resolve, reject) => {
        parseString(xmlData, (err, result) => {
            if (err) {
                return reject(err);
            }
            resolve(result);
        });
    });
    const message = (result as any).quicksdk_message.message[0];
    const channel = message.channel[0];
    const orgMemId = message.channel_uid[0];
    const channelOrder = message.channel_order[0];
    const orderId = message.game_order[0];//cp单号
    const orderNo = message.order_no[0];//sdk订单号
    const payTime = message.pay_time[0];
    const orgProductPrice = message.amount[0]; //充值成功的金额
    const status = message.status[0];//0成功
    const extrasParams = message.extras_params[0];
    if (status == 1) {
        return
    }

    const orderInfo = (await Order.getOrder(orderId))[0]

    if (!orderInfo) {
        logger.info(`订单${orderId}不存在`)
        ret.msg = `订单${orderId}不存在`
        return ret
    }

    let serverId = orderInfo.server_id//区服id
    let orgProductId = orderInfo.product_id//商品id

    if (orderInfo.status == 2) {
        logger.info(`订单${orderId}已经重复发货`)
        ret.code = 1
        ret.msg = `订单${orderId}已经重复发货`
        return ret
    }
    let url = await getServerList(serverId, 'default')
    if (!url) {
        logger.info(`区服id错误: serverId ${serverId}`)
        ret.msg = `区服id错误: serverId ${serverId}`
        return ret
    }
    // 使用 Msg 类的 connect 方法连接到 WebSocket 服务器
    let sendMsg = new Msg()
    sendMsg.connect(url, Account);
    logger.info(`订单${orderId} ${url}`)
    // 在适当的时机，调用 CG_ASK_LOGIN 方法
    let params = `{"account":"${orgMemId}","order":"${orderId}","id":${orgProductId},"cnt":100,"money":${orgProductPrice}}`
    return new Promise((resolve) => {
        setTimeout(async () => {
            console.log("这个消息将在3秒后打印出来");
            const send_res = sendMsg.CG_ASK_LOGIN(Account, 0, "", 'cn', 'CN', ctx.request.ip, params);
            if (!send_res) {
                resolve(ret);
                return;
            }

            const update_time = formatDate(new Date())
            const res = await Order.updateOrderStats(
                orderId,
                2,
                orderNo,
                update_time
            );

            if (res.affectedRows <= 0) {
                logger.info(`订单${orderId} 发货失败`)
                ret.msg = '发货失败'
                resolve(ret);
                return;
            }

            ret.code = 1
            ret.msg = '发货成功'
            resolve(ret);

        }, 1000);
    });

}

const CallPay360 = async (ctx) => {
    let ret = {
        code: 0,
        msg: '发货失败'
    }
    let data = ctx.request.body
    let sign = data.sign
    let serverId = data.serverId
    let orderId = data.cpOrder
    let out_trade_no = data.orderId
    logger.info("pay callback params:", { "url": ctx.href, "params": data })

    const orderInfo = (await Order.getOrder(orderId))[0]

    if (!orderInfo) {
        logger.info(`订单${orderId}不存在`)
        ret.msg = `订单${orderId}不存在`
        return ret
    }

    if (orderInfo.status == 2) {
        logger.info(`订单${orderId}已经重复发货`)
        ret.code = 1
        ret.msg = `订单${orderId}已经重复发货`
        return ret
    }

    //签名参数
    let signData = Object.keys(data).sort().filter(key => key !== 'sign');
    let signStr = signData.map(key => `${data[key]}`).join('');
    signStr += AppSecret360

    let newSign = CryptoJS.MD5(signStr).toString();
    console.log("signStr:", signStr)
    console.log("newSign:", newSign)
    if (sign != newSign) {
        logger.info(`签名错误: 签名串 ${signStr} newSign ${newSign} sign ${sign}`)
        ret.msg = `签名错误`
        return ret
    }

    let url = await getServerList(serverId, 'default')
    if (!url) {
        logger.info(`区服id错误: serverId ${serverId}`)
        ret.msg = `区服id错误: serverId ${serverId}`
        return ret
    }
    //发货
    // 使用 Msg 类的 connect 方法连接到 WebSocket 服务器
    let sendMsg = new Msg()
    sendMsg.connect(url, Account);
    logger.info(`订单${orderId} ${url}`)

    let orgMemId = data.uid
    let orgOderId = data.cpOrder
    let orgProductId = orderInfo.product_id
    let orgExt = data.cText
    let orgProductPrice = data.skuPrice
    // 在适当的时机，调用 CG_ASK_LOGIN 方法
    let params = `{"account":"${orgMemId}","order":"${orgOderId}","id":${orgProductId},"cnt":100,"money":${orgProductPrice}}`
    return new Promise((resolve) => {
        setTimeout(async () => {
            console.log("这个消息将在3秒后打印出来");
            const send_res = sendMsg.CG_ASK_LOGIN(Account, 0, "", 'cn', 'CN', ctx.request.ip, params);
            if (!send_res) {
                resolve(ret);
                return;
            }

            const update_time = formatDate(new Date())
            const res = await Order.updateOrderStats(
                orderId,
                2,
                out_trade_no,
                update_time
            );

            if (res.affectedRows <= 0) {
                logger.info(`订单${orderId} 发货失败`)
                ret.msg = '发货失败'
                resolve(ret);
                return;
            }

            ret.code = 1
            ret.msg = '发货成功'
            resolve(ret);

        }, 1000);
    });

}

const testGoogleCallPay = async (ctx) => {
    let ret = {
        code: 0,
        msg: '消费失败'
    }

    let data = ctx.request.body

    logger.info("pay callback params:", { "url": ctx.href, "params": data })

    const redisClient = ctx.redis.client;
    let access_token = await redisClient.get('access_token');

    if (!access_token) {
        console.log('请求api获取token')
        const apiData = {
            "grant_type": "refresh_token",
            "client_id": ClientId,
            "client_secret": ClientSecret,
            "refresh_token": RefreshToken
        }

        const response = await axios.post('https://accounts.google.com/o/oauth2/token', apiData, {
            headers: {
                'Content-Type': 'application/x-www-form-urlencoded'
            }
        });

        logger.info("token params:", { "data": response.data, "params": apiData })

        if (!response.data.access_token) {
            return ret
        }

        access_token = response.data.access_token
        await redisClient.set('access_token', response.data.access_token);
        await redisClient.expire('access_token', 1800);
    }

    if (!access_token) {
        return ret;
    }

    let googleToken = data.purchaseToken
    let product_id = data.orderId

    const productId = ProductId + product_id
    let apiUrl = `https://androidpublisher.googleapis.com/androidpublisher/v3/applications/${PackageName}/purchases/products/${productId}/tokens/${googleToken}?access_token=${access_token}`
    let maxRetries = 5;
    let currentRetry = 0;
    let isCheck = false;

    // 使用 while 循环进行重试
    while (currentRetry < maxRetries) {
        try {

            // // 尝试执行的操作
            const googleRes = await axios.get(apiUrl, {
                headers: {
                    'Content-Type': 'application/x-www-form-urlencoded'
                }
            })

            console.log(googleRes.data)

            // 如果操作成功，退出循环
            if (googleRes.data.purchaseState == 0) {
                isCheck = true
                break;
            }

        } catch (error) {
            // 如果操作失败，记录错误并继续尝试
            console.log(error)
        }

        currentRetry++;
    }

    if (!isCheck) {
        return ret;
    }

    return new Promise(async (resolve) => {
        let acknowledgeUrl = `https://androidpublisher.googleapis.com/androidpublisher/v3/applications/${PackageName}/purchases/products/${productId}/tokens/${googleToken}:acknowledge?access_token=${access_token}`
        console.log(acknowledgeUrl)
        const acknowledgeRes = await axios.post(acknowledgeUrl,
            {
                developerPayload: ""
            }
            ,
            {
                headers: {

                    'Content-Type': 'application/json'
                }
            })

        let consumeUrl = `https://androidpublisher.googleapis.com/androidpublisher/v3/applications/${PackageName}/purchases/products/${productId}/tokens/${googleToken}:consume?access_token=${access_token}`
        const consumeRes = await axios.post(consumeUrl,
            {
                developerPayload: ""
            }
            ,
            {
                headers: {

                    'Content-Type': 'application/json'
                }
            })

        ret.code = 1
        ret.msg = '发货成功'
        resolve(ret);

    });
}

const checkVersion = async (ctx) => {
    let ret = {
        code: 0,
        msg: '无需更新',
        url: '',
    }
    let data = ctx.request.body
    let version = data.version
    let tag = data.tag || 'default'
    logger.info("checkVersion params:", { "url": ctx.href, "params": data })

    const versionInfo = (await Version.getGameVersion(tag))[0]

    if (!versionInfo) {
        return ret
    }

    if (compareVersions(versionInfo.version, version) === 1) {

        if (versionInfo.download_url) {
            ret.code = 1
            ret.msg = '需要更新'
            ret.url = versionInfo.download_url
        }
    }
    return ret
}

//验证账号
const checkUserToken = async (ctx) => {
}


class ApiController {
    async createOrder(ctx) {
        let {
            uid,
            level,
            amount,
            role_id,
            role_name,
            product_id,
            server_id
        } = ctx.request.body

        logger.info("create params:", { "params": ctx.request.body })

        if (!product_id || !server_id || !role_name || !role_id || !amount || !uid) {
            ctx.body = { code: -1, message: '参数错误,创建订单失败!!', data: '' }
            return
        }

        const orderId = generateOrderNumber(); // 生成一个长度为8的订单号
        const create_time = formatDate(new Date())
        const res = await Order.createOrder(
            orderId,
            uid,
            level,
            amount,
            role_id,
            role_name,
            product_id,
            server_id,
            create_time
        );

        if (res.affectedRows > 0) {
            ctx.body = { code: 0, message: '创建订单成功', data: orderId }
        } else {
            ctx.body = { code: -1, message: '创建订单失败', data: '' }
        }

        logger.info("创建订单返回结果:", { "params": ctx.body })
    }

    async checkUserToken(ctx) {
        // const result = await checkUserToken(ctx);
        // let data = { "status": false, "sign": "" }
        // if (result) {
        //     data.status = true
        //     data.sign = result
        // }
        // ctx.body = data
    }

    //quick登陆
    async quickUserLogin(ctx) {
        //sdk参数
        let productCode = "68402796563185068148745974229755"

        let data = ctx.request.body
        let uid = data.uid
        let token = data.token
        let reqUrl = "http://checkuser.quickapi.net/v2/checkUserInfo?token=" + token + "&uid=" + uid + "product_code=" + productCode
        logger.info("quick登陆验证请求", { 'params': data, 'url': reqUrl })
        const res = await axios.get(reqUrl)
        logger.info("quick req", { "res": res.data })
        if (res.data == '1') {
            ctx.body = {
                code: 200,
                msg: 'success'
            }
        } else {
            ctx.body = {
                code: 0,
                msg: 'fail'
            }
        }
    }

    async callPay(ctx) {
        console.log(234234234)
        let data = ctx.request.body
        let platform = '360'  // 默认360

        if (ctx.query.platform) {
            platform = ctx.query.platform
        }

        if (data.platform) {
            platform = data.platform
        }

        switch (platform) {
            case 'google':
                var result = await googleCallPay(ctx)
                console.log('发货结果', result)
                ctx.body = result
                break;
            case 'apple':
                var result = await appleCallPay(ctx)
                console.log('发货结果', result)
                ctx.body = result
                break;
            case '360':
                var result = await CallPay360(ctx)
                console.log('发货结果', result)
                ctx.body = result
                break;
            // case 'testGoogle':
            // var result = await testGoogleCallPay(ctx)
            // console.log('发货结果', result)
            // ctx.body = result
            // break;
            case 'quick':
                var result = await CallPayQuick(ctx)
                console.log('发货结果', result)
                if((result as any).code == 1){
                    ctx.body = 'SUCCESS'
                }else{
                    ctx.body = 'Fail'
                }
                break;
            default:
                ctx.body = {
                    code: 0,
                    msg: '渠道错误'
                }
        }
    }

    async checkVersion(ctx) {
        var result = await checkVersion(ctx)
        console.log('校验版本', result)
        ctx.body = result
    }

    async getServerList(ctx) {
        let tag = ctx.query.tag || 'default'
        const servers = (await Server.getServerList(tag))
        let data = []
        let ip = ctx.request.ip
        if (ip.startsWith('::ffff:')) {
            ip = ip.substring('::ffff:'.length);
        }

        logger.info("区服接口", { "ip": ctx.request.ip })
        if (servers.length > 0) {
            servers.forEach(function (element) {
                let status = element.status
                if ((status == 0 || status == 3) && element.white_list) {
                    const list = element.white_list.split(",");

                    if (list.length > 0) {
                        if (list.includes(ip)) {
                            status = 1
                        }
                    }
                }

                data.push({
                    "id": element.id,
                    "name": element.name,
                    "ip": element.ip,
                    "port": element.port,
                    "tips": element.tips,
                    "status": status,
                })
            });
        }

        ctx.body = data
    }
    async getAllServerList(ctx) {
        let tag = ctx.query.tag || 'default'
        let ip = ctx.request.ip
        if (ip.startsWith('::ffff:')) {
            ip = ip.substring('::ffff:'.length);
        }
        logger.info("getAllServerList 区服接口", { "ip": ctx.request.ip })
        const servers = (await Server.getAllServerList(tag, ip))
        ctx.body = servers
    }

    async enterServer(ctx) {
        let ret = {
            code: 0,
            msg: '请求失败'
        }

        let {
            uid,
            server_id
        } = ctx.request.body

        let url = await getServerList(server_id, 'default')
        if (!url) {
            ctx.body = { code: -1, message: `区服id错误: serverId ${server_id}`, data: '' }
            return
        }

        logger.info("create params:", { "params": ctx.request.body })

        if (!server_id || !uid) {
            ctx.body = { code: -1, message: '参数错误!!', data: '' }
            return
        }

        const create_time = formatDate(new Date())
        const serverInfo = (await Server.checkEnterServerByUid(uid, server_id))[0]
        let res = null

        if (serverInfo) {

            res = await Server.updateEnterServer(
                serverInfo.id,
                create_time
            );

        } else {
            res = await Server.enterServer(
                uid,
                server_id,
                create_time
            );
        }

        if (res.affectedRows > 0) {
            ctx.body = { code: 0, message: '请求成功', data: '' }
        } else {
            ctx.body = { code: -1, message: '请求失败', data: '' }
        }
    }

    async getLastServerList(ctx) {
        let {
            uid,
        } = ctx.request.body

        let tag = 'default'
        let data = [];
        let isNewAccount = 1
        let enterServerList = (await Server.getEnterServerListByUid(uid))
        let ip = ctx.request.ip
        if (ip.startsWith('::ffff:')) {
            ip = ip.substring('::ffff:'.length);
        }
        logger.info("getLastServerList 区服接口", { "ip": ctx.request.ip })

        if (enterServerList.length > 0) {
            isNewAccount = 0
            // const servers = (await Server.getServerList(tag, 1))
            const servers = (await Server.getAllServerList(tag, ip))
            enterServerList.forEach(function (element) {
                data.push({
                    "channel": "Thailand", //渠道固定
                    "minSid": 1,            //最小服务器
                    "maxSid": servers.length,         //最大服务器 这里会控制 服务器列表显示的数量
                    "isNewAccount": isNewAccount, //1为新号 会弹出用户协议
                    //以下是最近登陆的服务器 (不可为空 如果没有参数可以填最后一个区)
                    "sid": element.server_id || 1,
                    "id": element.server_id || 1,
                    "name": element.name || "1区",
                    "tips": element.tips || "",
                    "server": element.ip ? `ws://${element.ip}:${element.port}` : "",
                    "status": element.status || 0,
                })
            });

        } else {
            // const servers = (await Server.getServerList(tag, 1))
            const servers = (await Server.getAllServerList(tag, ip))
            if (servers.length > 0) {
                const serverInfo = servers[servers.length - 1]
                data.push({
                    "channel": "Thailand", //渠道固定
                    "minSid": 1,            //最小服务器
                    "maxSid": servers.length,         //最大服务器 这里会控制 服务器列表显示的数量
                    "isNewAccount": isNewAccount, //1为新号 会弹出用户协议
                    //以下是最近登陆的服务器 (不可为空 如果没有参数可以填最后一个区)
                    "sid": serverInfo.id || 1,
                    "id": serverInfo.id || 1,
                    "name": serverInfo.name || "1区",
                    "tips": serverInfo.tips || "",
                    "server": serverInfo.ip ? `ws://${serverInfo.ip}:${serverInfo.port}` : "",
                    "status": serverInfo.status || 0,
                })
            } else {

                data.push({
                    "channel": "Thailand", //渠道固定
                    "minSid": 1,            //最小服务器
                    "maxSid": 10,         //最大服务器 这里会控制 服务器列表显示的数量
                    "isNewAccount": isNewAccount, //1为新号 会弹出用户协议
                    //以下是最近登陆的服务器 (不可为空 如果没有参数可以填最后一个区)
                    "sid": 1,
                    "id": 1,
                    "name": "1区",
                    "tips": "",
                    "server": "",
                    "status": 0,
                })
            }

        }

        ctx.body = data
    }

    async getNotice(ctx) {
        let data = ctx.request.body
        let platform = 'th'
        if (ctx.query.platform) {
            platform = ctx.query.platform
        }

        switch (platform) {
            case 'th':
                ctx.body = th_notice
                break;
            case '360':
                ctx.body = notice
                break;
            case 'xky':
                ctx.body = xky_notice
                break;
            default:
                ctx.body = notice
        }
    }

    async genCDK(ctx) {
        /*
        data = {
            cnt : number -- 生成数量
            useCnt : number -- 当前批次最大使用数量
            serverList : string -- 区服列表Json字符串
            itemList : string -- CDK对应物品列表Json字符串
        }
        */
        let data = ctx.request.body
        await CDK.genCDK(ctx, data.cnt, data.useCnt, data.serverList, data.itemList)
        ctx.body = {
            code: 0,
            msg: 'success'
        }
        return
    }

    async getCDK(ctx) {
        let data = ctx.request.body
        let ret = await CDK.getCDK(ctx, data.batch)
        if (ret.length <= 0) {
            ctx.body = {
                code: 1,
                msg: "batch invalid"
            }
            return
        }
        ctx.body = {
            code: 0,
            msg: ret
        }
    }
    async useCDK(ctx) {
        let data = ctx.request.body
        let url = await getServerList(data.serverId, 'default')
        let err = ""
        if (!url) {

            ctx.body = {
                code: 1,
                msg: `区服id错误: serverId ${data.serverId}`
            }
            err = "server id invalid"
        }
        let param: string = ""
        // 验证CDK
        if (err.length == 0) {
            let batchInfo = await CDK.getCDKItemList(ctx, data.code)
            if (batchInfo.length <= 0) {
                err = "cdk not found"
            } else {
                err = await CDK.checkCDK(ctx, data.code, data.serverId)
                param = JSON.stringify({
                    type: "UseCDK",
                    err: err,
                    batchInfo: batchInfo
                })
            }
        }
        // 固定码
        if (err == "cdk not found" || err == "server id invalid") {
            param = JSON.stringify({
                code: data.code,
                type: "UseFixCDK"
            })
        }
        // 测试是否可以调用过去
        // 通知给服务器，发放道具
        // "ws://43.143.193.23:18192"
        // Msg.connect(url, Account);
        try {
            let sendMsg = new Msg()
            sendMsg.connect(url, Account);
            logger.info(`code ${data.code} id ${data.serverId} ${url}`)
            new Promise((resolve) => {
                setTimeout(async () => {
                    sendMsg.CG_TEST_PROTO(data.account, param)
                    CDK.useCDK(ctx, data.code)
                }, 1000);
                
            });
        } catch (error) {
            console.log(error)
        }
        ctx.body = {
            code: 0,
            msg: "success"
        }
    }

    async validCDK(ctx) {
        let data = ctx.request.body
        if (data.code.length == 10) {
            let ret = await CDK.useCDK(ctx, data.code)
            if (ret != "success") {
                ctx.body = {
                    code: 1,
                    msg: ret
                }
                return
            }
        }
        ctx.body = {
            code: 0,
            msg: "success"
        }
    }

    // 维护服务器，踢掉所有玩家
    async maintenance(ctx) {
        let data = ctx.request.body
        let url = await getServerList(data.serverId, 'default')
        if (!url) {
            ctx.body = {
                code: 1,
                msg: `区服id错误: serverId ${data.serverId}`
            }
            return
        }
        let param = JSON.stringify({
            type: "kickAllUser"
        })
        // Msg.connect(url, Account);
        let sendMsg = new Msg()
        sendMsg.connect(url, Account);
        new Promise((resolve) => {
            setTimeout(async () => {
                sendMsg.CG_TEST_PROTO("test", param)
            }, 1000);
        });
        ctx.body = {
            code: 0,
            msg: "success"
        }
    }

    async maintenanceAll(ctx) {
        let data = ctx.request.body

        const servers = (await Server.getServerList('default'))

        servers.forEach(function (element) {

            let url = 'ws://' + element.ip + ':' + element.port
            if (!url) {
                ctx.body = {
                    code: 1,
                    msg: `区服id错误: serverId ${element.server_id}`
                }
                return
            }


        let param = JSON.stringify({
            type: "kickAllUser"
        })
        // Msg.connect(url, Account);
        let sendMsg = new Msg()
        sendMsg.connect(url, Account);
        new Promise((resolve) => {
            setTimeout(async () => {
                sendMsg.CG_TEST_PROTO("test", param)
            }, 1000);
        });
  
        });

        ctx.body = {
            code: 0,
            msg: "success"
        }
    }

    async sendMail(ctx) {
        let data = ctx.request.body
        let url = await getServerList(data.serverId, 'default')
        if (!url) {
            ctx.body = {
                code: 1,
                msg: `区服id错误: serverId ${data.serverId}`
            }
            return
        }
        let param = JSON.stringify({
            type: "sendMail",
            mail: JSON.stringify({
                uuid: data.uuid,
                title: data.title,
                content: data.content,
                items: JSON.parse(data.items),
                expire: data.expire
            })
        })
        // Msg.connect(url, Account);
        let sendMsg = new Msg()
        sendMsg.connect(url, Account);
        new Promise((resolve) => {
            setTimeout(async () => {
                sendMsg.CG_TEST_PROTO("test", param)
            }, 1000);
        });
        ctx.body = {
            code: 0,
            msg: "success"
        }
    }
}

module.exports = new ApiController()