function getQueryString(name) {
    var reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)");
    var r = window.location.search.substr(1).match(reg);
    return r ? decodeURIComponent(r[2]) : '';
}

class GamePlatform {

    constructor() {
        this.name = 'native';
        this.version = "1.0.7";
        this.jcGameId = 1009;
        this.jcChannelId = getQueryString('channel') ? Number(getQueryString('channel')) : 7103;
        console.log('jcchannelid: ' + this.jcChannelId);
        this.isDev = true;
        this.orderIdUrl = `https://game1009proxy${this.isDev ? '-test':''}.kingsome.cn/webapp/index.php?c=Pay&a=preOrder`;
        this.checkRegRewardUrl = `https://game1009proxy${this.isDev ? '-test':''}.kingsome.cn/webapp/index.php?c=GoProxy&a=checkRegisterReward`;
        this.regRewardUrl = `https://game1009proxy${this.isDev ? '-test':''}.kingsome.cn/webapp/index.php?c=GoProxy&a=registerReward`;
        this.svrListUrl = `https://game1009gate${this.isDev ? '-test':''}.kingsome.cn/wjtxgate/common/login.aspx?pid=${this.jcChannelId}`;
        this.wssHost = `game1009game${this.isDev ? '-test' : ''}.kingsome.cn`;
        this.other = new GamePlatformOther();
    }
    login() {
        return new Promise((resolve, reject) => {
            jc.init({
                channelid: this.jcChannelId,
                gameid: this.jcGameId,
                isoffical: !this.isDev,
            });
            console.log('jcfw init finished 2');
            jc.loginUser({
                success: function(res) {
                    console.log('登录成功', JSON.stringify(res));
                    wxUserData.open_id = res.openid;
                    wxUserData.nick_name = res.nickname;
                    wxUserData.avatar_url = res.avatar_url;
                    wxUserData.gender = res.sex;
                    platform.code = res.openid;
                    //res.session_key
                    platform.session = res.session_id;
                    resolve(res);
                },
                fail: function(neterr, logicerr, errmsg) {
                    console.log('登录错误');
                    console.log(neterr, logicerr, errmsg);
                    reject(errmsg);
                }
            });
        });
    }

    getUserInfo() {
        return new Promise((resolve, reject) => {
            platform.login().then(res => {
                console.log("登录成功");
                resolve();

            }).catch(err => {
                reject(err);
            });
        })
    }

    // obj { data, success, fail }

    _getOrderId(pid, uid, sid, callback) {
        var url = jc.gg.extcfg['prePayUrl'] || this.orderIdUrl;
        var reqData = {
            openid: platform.code,
            produce: pid,
            gameid: platform.jcGameId,
            session: platform.session,
            uid: uid,
            server: sid,
            platform: platform.jcChannelId,
            role_name: giant.Core.hero.name,
            role_level: giant.Core.hero.level,
            server_name: giant.Core.serverVO.name
        };

        var loginCount = 0;
        var loginMaxCount = 1;
        console.log('pre order with url: ' + url);
        var request = function () {
            platform.urlRequest({
                url: url,
                method: 'GET',
                data: reqData,
                success: function (res) {
                    console.log("_getOrderId success", JSON.stringify(res));
                    if (res && res.data) {
                        // session检测失败，需要登录
                        if (res.data.sessionCheck != null) {
                            if (loginCount >= loginMaxCount) {
                                callback && callback(false, "session失效，请重新登录");
                                return;
                            }
                            loginCount++;

                            platform.login().then(res => {
                                request();
                            }).catch(err => {
                                callback && callback(false, "session失效，login失败，请重新登录");
                            });
                        }
                        else {
                            callback && callback(true, res.data.prepayId);
                        }
                    }
                    else {
                        callback && callback(false, "接口返回有误，请重试");
                    }
                },
                fail: function (err) {
                    console.log('pay with err: ' + JSON.stringify(err));
                    callback && callback(false, "接口访问失败，请重试");
                }
            })

        }

        request();
    }

    pay(obj) {
        var orderInfo = null;
        console.warn("pay obj", JSON.stringify(obj));

        var onOrderIdResult = function (isOk, data) {
            if (isOk) {
                try {
                    var payData = JSON.parse(data);
                    Object.assign(payData, {count: 1});
                    orderInfo = payData;
                    realPay();
                } catch (err) {
                    obj.fail && obj.fail({ tipMessage: '解析接口数据失败' });
                }

            }
            else {
                obj.fail && obj.fail({ tipMessage: data });
            }
        }

        var realPay = function () {
            console.log("pay orderInfo", orderInfo);
            if (!orderInfo) return;
            jc.plat.pay(orderInfo)
              .then(data => {
                  if (data.errcode === 0) {
                      console.log("[quick]pay success", JSON.stringify(data));
                      obj.success && obj.success();
                  } else {
                      console.warn("pay fail", JSON.stringify(data));
                      obj.fail && obj.fail({ tipMessage: "充值失败" , err: data.errmsg });
                  }
              })
              .catch(err => {
                  console.warn("pay fail", JSON.stringify(err));
                  obj.fail && obj.fail({ tipMessage: "充值失败" , err: err.errmsg });
              })
        }

        platform._getOrderId(obj.data.goodsId, obj.data.uid, obj.data.sid, onOrderIdResult);
    }
    concatServerList(res0, res1) {
        res0.data.lastWorldIds = res1.data.lastWorldIds.concat(res0.data.lastWorldIds);
        if (res1 && res1.data) {
            if (res1.data.servers) {
                for (let data of res1.data.servers) {
                    data.comp = 'jc';
                    res0.data.servers.push(data);
                }
            }
        }
        if (res1 && res1.data && res1.data.notice) {
            res0.data.notice = res1.data.notice;
        }
        return res0;
    }
    requestServerList() {
        var url = this.svrListUrl;
        return this.getServerList(url);
    }

    getServerList(url) {
        return new Promise((resolve, reject) => {
            let data = {
                openId: wxUserData.open_id
            }
            platform.urlRequest({
                url: url,
                method: 'GET',
                data: data,
                success: function (res) {
                    resolve(res);
                },
                fail: function (err) {
                    console.log('getServerList fail with url:', url);
                    resolve({data: {
                            lastWorldIds: [],
                            servers: [],
                        }});
                }
            })
        })
    }

    getWxWebResRoot(configUrl) {
        return new Promise((resolve, reject) => {
            platform.urlRequest({
                url: configUrl,
                method: "GET",
                success: function (res) {
                    let newObj = res.data;
                    constantRes.wxWebResRoot = constantRes.root + newObj.version + "/";
                    resolve();
                }
            });
        });
    }

    urlRequest(obj) {
        var url = obj.url;
        var method = obj.method.toUpperCase();
        var data = obj.data;
        var postDataRaw = obj.postDataRaw === true;
        var success = obj.success;
        var fail = obj.fail;

        var xhr = new XMLHttpRequest();
        xhr.onreadystatechange = function () {
            if (xhr.readyState == 4) {
                if (xhr.status >= 200 && xhr.status < 400) {
                    var retData = xhr.responseText;
                    try {
                        retData = JSON.parse(retData);
                        success && success({
                            data: retData
                        });
                    } catch (err) {
                        fail && fail();
                    }

                } else if (xhr.status >= 400) {
                    fail && fail();
                }
            }
        };

        xhr.onerror = function (e) {
            fail && fail();
        };

        if (method === "POST") {
            var dataStr = null;
            if (postDataRaw) {
                dataStr = data;
            }
            else {
                if (data) {
                    dataStr = "";
                    for (var key in data) {
                        if (dataStr != "") {
                            dataStr += "&";
                        }
                        dataStr += key + "=" + data[key];
                    }
                }
            }
            xhr.open(method, url);
            xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
            xhr.send(dataStr);
        } else {
            var paramStr = "";
            if (data) {
                for (var key in data) {
                    if (paramStr != "") {
                        paramStr += "&";
                    }
                    paramStr += key + "=" + encodeURIComponent(data[key]);
                }
                if (paramStr != "") {
                    paramStr = (url.indexOf("?") == -1 ? "?" : "&") + paramStr;
                }
            }
            url += paramStr;
            url += `&_d=${Date.now()}`
            console.log(url);
            xhr.open(method, url);
            xhr.send();
        }
    }

}

class GamePlatformOther {
    constructor() {
        this.localFileName = 'userData_';
    }
    checkRegisterReward(uid, sid) {
        return new Promise((resolve, reject) => {
            var url = jc.gg.extcfg['checkRegRewardUrl'] || platform.checkRegRewardUrl;
            console.log('checkRegisterReward req', uid, sid, url);
            platform.urlRequest({
                url: url,
                method: 'GET',
                data: {
                    uid: uid,
                    server: sid,
                },
                success: function (res) {
                    console.log("checkRegisterReward res", res);
                    if (res && res.data) {
                        if (res.data.code == 1) {
                            resolve && resolve(true);
                        }
                        else {
                            resolve && resolve(false, "code = " + res.data.code + ", error = " + res.data.error);
                        }
                    }
                    else {
                        reject && reject("接口返回有误，请重试");
                    }
                },
                fail: function (err) {
                    reject && reject("接口访问失败，请重试");
                }
            });
        });
    }

    getRegisterReward(uid, sid, name) {
        return new Promise((resolve, reject) => {
            var url = jc.gg.extcfg['RegRewardUrl'] || platform.regRewardUrl;
            console.log('getRegisterReward req', uid, sid, name, url);

            var count = 0;
            var maxCount = 20;
            var interval = 3;

            var doRequest = function () {
                platform.urlRequest({
                    url: url,
                    method: 'GET',
                    data: {
                        uid: uid,
                        server: sid,
                        name: name
                    },
                    success: function (res) {
                        console.log("getRegisterReward res", res);
                        if (res && res.data) {
                            if (res.data.code == 1) {
                                resolve && resolve(true);
                            }
                            else {
                                count++;
                                if (count <= maxCount) {
                                    setTimeout(doRequest, interval * 1000);
                                }
                                else {
                                    resolve && resolve(false, "code = " + res.data.code + ", error = " + res.data.error);
                                }
                            }
                        }
                        else {
                            reject && reject("接口返回有误，请重试");
                        }
                    },
                    fail: function (err) {
                        reject && reject("接口访问失败，请重试");
                    }
                });
            }

            doRequest();
        });
    }

    reportRoleCreate(isNew) {
        let data = {
            isCreateRole: isNew,
            roleCreateTime: Date.now(),
            serverId: giant.Core.serverVO.id,
            serverName: giant.Core.serverVO.name,
            userRoleId: giant.Core.hero.id,
            userRoleName: giant.Core.hero.name,
            userRoleBalance: giant.Core.hero.coin,
            vipLevel: giant.Core.hero.vipLevel,
            userRoleLevel: giant.Core.hero.level,
            partyId: 0,
            partyName: giant.Core.hero.camp,
            gameRoleGender: giant.Core.hero.gender,
            gameRolePower: giant.Core.hero.power,
        };
        jc.plat.reportRoleInfo(data)
          .then(res => {})
          .catch(err=> {})
    }

    setLocalStorage(key, value) {
        let self = this;
        if (key === 'lastSvr') {
            giant.Core.externalParams.lastWordId = value;
        }
        if (typeof localStorage != "undefined") {
            localStorage.setItem(self.localFileName + key, value);
        }
        else {
            console.warn("localStorage is null, on set");
        }
    }

    getLocalStorage(key) {
        let self = this;
        if (key === 'lastSvr' && giant.Core.externalParams.lastWordId) {
            return giant.Core.externalParams.lastWordId;
        }
        if (typeof localStorage != "undefined") {
            var dataStr = localStorage.getItem(self.localFileName + key);
            if (key === 'lastSvr') {
                giant.Core.externalParams.lastWordId = dataStr;
            }
            return dataStr;
        }
        else {
            console.warn("localStorage is null, on get");
            return null;
        }
    }

    getLiuHaiHeight() {

        var ratioScreen = egret.Capabilities.boundingClientHeight / egret.Capabilities.boundingClientWidth;
        var ratioGameDesign = 1136 / 640;

        console.log("getLiuHaiHeight", ratioScreen, ratioGameDesign);

        // 跟游戏分辨率相比，相等没有刘海
        if (Math.abs(ratioScreen - ratioGameDesign) < 0.01) {
            return 0;
        }
        else {
            // 默认刘海值50
            return 50;
        }
    }
}

class PlatUserData {

    constructor() {
        this.open_id = null;
        this.nick_name = null;
        this.avatar_url = null;
        this.gender = null;
    }

    getOpenId() {
        return this.open_id;
    }

}

class GameConstant {
    constructor() {
        this.root = "";
        this.wxWebResRoot = "";
    }
}

window.platform = new GamePlatform();
window.wxUserData = new PlatUserData();
window.constantRes = new GameConstant();