import Emiter from 'src/Emiter';
import Loger from 'src/Loger';
import MessageTypes from 'src/MessageTypes';
import GlobalConfig from 'src/GlobalConfig';
import MD5 from "md5";
import ApeConsts from 'src/apes/ApeConsts';
import iphunter from 'iphunter';
import Server from "src/config/Server";
import fetchJsonp from 'fetch-jsonp';

// 日志对象
const loger = Loger.getLoger('ServerCheck');

//ip选点流程的状态
let isRequestMcuCallback = false;//是否获取最佳mcu返回
let isRequestMsCallback = false;//是否获取ms最佳返回
let isTestFromSass = false;
let isTestFromServer = false;

let tempMcuIp = "";
let tempMcuPort = "";
let tempMsIp = "";
let tempMsPort = "";
let msDefaultPort = "1935";
let mcuDefaultPort = "7777";
let speedTestPort = ':5555';//测速端口统一

let checkMcuIpGroup = [];//储存MCU需要查询的ip数组
let checkMsIpGroup = [];//储存MCU需要查询的ip数组
const timeOutDelay = 1000;//选点超时

class ServerCheck extends Emiter {
    constructor() {
        super();

    }

    //根据userIp获取ip相关的信息，参数是userIp
    getUserIpInfo(token, userIp) {
        //重置ip选点流程状态
        isRequestMcuCallback = false;
        isRequestMsCallback = false;
        isTestFromSass = false;
        isTestFromServer = false;
        checkMcuIpGroup = [];
        checkMsIpGroup = [];
        let userIpInfo = new Object;
        userIpInfo.ret = -1;

        let ip = userIp;
        let md5Str = MD5("addr=" + ip + "&token=b657c3507b324353e09c1958ee956a98efceb3e3");
        // /("addr=" + ip + "&token=b657c3507b324353e09c1958ee956a98efceb3e3")，转成MD5
        let timestamp = new Date().getTime();
        let location = `http://ipapi.ipip.net/find?addr=${ip}&sid=14&uid=5237&sig=${md5Str}&_=${timestamp}`;

        fetchJsonp(location, {
            timeout: timeOutDelay,
        }).then(function (response) {
            return response.json()
        }).then(function (json) {
            // loger.log('获取IP信息返回', json)
            if (json) {
                userIpInfo.ret = json.ret;
                userIpInfo.country = json.data[0];//国家
                userIpInfo.province = json.data[1];//省份
                userIpInfo.city = json.data[2];//城市
                userIpInfo.isp = json.data[4];//运营商
            }
            this.serverGetUserIpInfoCallback(userIpInfo);
        }.bind(this)).catch(function (ex) {
            // loger.log('获取IP信息失败', ex.message)
            this.serverGetUserIpInfoCallback(userIpInfo);
        }.bind(this));
    }

    //获取ip信息返回
    serverGetUserIpInfoCallback(userIpInfo) {
        // loger.log("获取IP详情，开始处理", userIpInfo);
        if (userIpInfo.ret == "ok") {
            GlobalConfig.country = userIpInfo.country;//国家
            GlobalConfig.city = userIpInfo.city;//城市
            GlobalConfig.province = userIpInfo.province;//服务商
            GlobalConfig.isp = userIpInfo.isp;//服务商
            // loger.log("获取ip详情成功,country:" + GlobalConfig.country + ",city:" + GlobalConfig.city + ",isp:" + GlobalConfig.isp);
            this._chooseBestIpFromServer();
        }
        else {
            // loger.log("获取ip详情失败");
            this._chooseBestIpFromSassParam();
        }
    }

    //从IPIP服务列表中选择最快的IP
    _chooseBestIpFromServer() {
        // loger.log("从Server服务列表中选择最快的IP");
        isRequestMcuCallback = false;
        isRequestMsCallback = false;
        isTestFromServer = true;
        isTestFromSass = false;

        //country, province, ctiy, isp, jsona
        checkMcuIpGroup = this._returnServerMCU(
            GlobalConfig.country,
            GlobalConfig.province,
            GlobalConfig.city,
            GlobalConfig.isp,
            Server.serverList);

        checkMsIpGroup = this._returnServerMS(
            GlobalConfig.country,
            GlobalConfig.province,
            GlobalConfig.city,
            GlobalConfig.isp,
            Server.serverList);

        let mcuArr = [];
        let msArr = [];
        for (let i in checkMcuIpGroup) {
            if (checkMcuIpGroup[i]) {
                mcuArr.push(checkMcuIpGroup[i].ip + speedTestPort);
            }
        }
        for (let k in checkMsIpGroup) {
            if (checkMsIpGroup[k]) {
                msArr.push(checkMsIpGroup[k].ip + speedTestPort);
            }
        }
        this.getBestMcuServer(mcuArr);
        this.getBestMsServer(msArr);
    }

    //从Sass返回的msList   mcuList中选点
    _chooseBestIpFromSassParam() {
        // loger.log("从Sass服务列表中选择最快的IP");
        isRequestMcuCallback = false;
        isRequestMsCallback = false;
        isTestFromSass = false;
        isTestFromServer = false;
        checkMcuIpGroup = GlobalConfig.mcuList;
        checkMsIpGroup = GlobalConfig.msList;
        //MCU
        let mcuIpGroup = [];
        for (let i = 0; i < checkMcuIpGroup.length; i++) {
            let ipPort = checkMcuIpGroup[i].ip + speedTestPort;
            mcuIpGroup.push(ipPort)
        }
        this.getBestMcuServer(mcuIpGroup);

        //MS
        let msIpGroup = [];
        for (let k = 0; k < checkMsIpGroup.length; k++) {
            let ipPort = checkMsIpGroup[k].ip + speedTestPort;
            msIpGroup.push(ipPort)
        }
        this.getBestMsServer(msIpGroup);
    }


    //获取最快的MCU服务器地址,参数是一个ip数组
    getBestMcuServer(_param) {
        // loger.log('开始MCU选点 ', _param);
        if (_param == null || _param.length < 1) {
            this._getBestMcuServerCallbackHandler("");
            return;
        }
        iphunter(_param, function (fatest_ip_response) {
            if (!fatest_ip_response) {
                loger.warn('getBestMcuServer -> nothing!');
                this._getBestMcuServerCallbackHandler("");
            } else {
                loger.log('getBestMcuServer done -> ', fatest_ip_response);
                this._getBestMcuServerCallbackHandler(fatest_ip_response);
            }
        }.bind(this), timeOutDelay);
    }

    //获取最快的MS服务器地址，参数是一个ip数组
    getBestMsServer(_param) {
        // loger.log('开始MS选点 ', _param);
        if (_param == null || _param.length < 1) {
            this._getBestMsServerCallbackHandler("")
            return;
        }
        iphunter(_param, function (fatest_ip_response) {
            if (!fatest_ip_response) {
                loger.warn('getBestMsServer -> nothing!');
                this._getBestMsServerCallbackHandler("");
            } else {
                loger.log('getBestMsServer done -> ', fatest_ip_response);
                this._getBestMsServerCallbackHandler(fatest_ip_response);
            }
        }.bind(this), timeOutDelay);
    }

    _getBestMcuServerCallbackHandler(_data) {
        // loger.log("MCU选点返回1", _data);
        if (isRequestMcuCallback) {
            // loger.log("MCU选点,已经有返回");
            return;
        }
        isRequestMcuCallback = true;
        if (_data) {
            let server = _data.split(":");
            if (server[0]) {
                tempMcuIp = server[0];
            }
            tempMcuPort = mcuDefaultPort;
            for (let i = 0; i < checkMcuIpGroup.length; i++) {
                if (tempMcuIp == checkMcuIpGroup[i].ip) {
                    tempMcuPort = checkMcuIpGroup[i].port || mcuDefaultPort;
                    break;
                }
            }
        }
        // loger.log("MCU选点返回2",tempMcuIp,tempMcuPort);
        this._startConnectMcu();
    }

    _getBestMsServerCallbackHandler(_data) {
        // loger.log("MS选点返回1", _data);
        if (isRequestMsCallback) {
            // loger.log("_getBestMsServerCallbackHandler,已经有返回");
            return;
        }
        isRequestMsCallback = true;
        if (_data) {
            let server = _data.split(":");
            if (server[0]) {
                tempMsIp = server[0];
            }
            tempMsPort = msDefaultPort;
            for (let i = 0; i < checkMsIpGroup.length; i++) {
                if (tempMsIp == checkMsIpGroup[i].ip) {
                    tempMsPort = checkMsIpGroup[i].port || msDefaultPort;
                    break;
                }
            }
        }
        // loger.log("MS选点返回2", tempMsIp,tempMsPort);
        this._startConnectMcu();
    }

    //ip选点结束，开始连接MCU
    _startConnectMcu() {
        if (isRequestMcuCallback && isRequestMsCallback) {
            if (isTestFromServer && !isTestFromSass) {
                //从Server服务列表中选点结束，如果没有选到合适的，从Sass的列表中获取
                if (!tempMcuIp || !tempMsIp) {
                    this._chooseBestIpFromSassParam();
                } else {
                    GlobalConfig.MCUServerIP = tempMcuIp;
                    GlobalConfig.MCUServerPort = tempMcuPort;
                    GlobalConfig.MS_PUBLISH_IP = tempMsIp;
                    GlobalConfig.MS_PUBLISH_PORT = tempMsPort;
                    // loger.log("Server选点完成", "mcu-->",GlobalConfig.MCUServerIP,GlobalConfig.MCUServerPort,"ms---->",GlobalConfig.MSServerIP,GlobalConfig.MSServerPort);
                    this._emit(ServerCheck.SEVER_CHECK_BEST_IP_SUCCESS);
                }
            } else {
                //从Sass返回的服务列表中选点结束
                if (tempMcuIp) {
                    GlobalConfig.MCUServerIP = tempMcuIp;
                    GlobalConfig.MCUServerPort = tempMcuPort;
                }
                if (tempMsIp) {
                    GlobalConfig.MS_PUBLISH_IP = tempMsIp;
                    GlobalConfig.MS_PUBLISH_PORT = tempMsPort;
                }
                loger.log("Sass选点完成", "mcu-->", GlobalConfig.MCUServerIP, GlobalConfig.MCUServerPort, "ms---->", GlobalConfig.MS_PUBLISH_IP, GlobalConfig.MS_PUBLISH_PORT);
                this._emit(ServerCheck.SEVER_CHECK_BEST_IP_SUCCESS);
            }
        } else {
            loger.warn("_startConnectMcu->正在选点", isRequestMcuCallback, isRequestMsCallback);
        }
    }

    //检测MCU连接地址
    _returnServerMCU(country, province, ctiy, isp, jsona) {
        let countryData = jsona.MCU[country];
        //按country没有查找到就返回default
        if (!countryData) {
            countryData = jsona.MCU.default;
            // loger.log("_returnServerMCU->countryData->default",countryData);
            return countryData;
        }

        if (country != "中国") {
            // loger.log("_returnServerMCU->countryData",countryData);
            return countryData;
        }

        //中国的需要细分
        //按isp查找
        let ispData = countryData.isp[isp];
        //isp查找到就返回
        if (ispData) {
            // loger.log("_returnServerMCU->ispData",ispData);
            return ispData;
        }

        //isp没查找到，用province
        let provinceData = countryData.province[province];
        //用province查找到就返回
        if (provinceData) {
            // loger.log("_returnServerMCU->provinceData",provinceData);
            return provinceData;
        }


        //isp province都没有，使用default
        let defaultData = countryData.default
        if (defaultData) {
            // loger.log("_returnServerMCU->defaultData",defaultData);
            return defaultData;
        } else {
            // loger.log("_returnServerMCU->defaultData","");
            return [];
        }
        return [];
    }

    //检测MS连接地址
    //Config.ipInfo
    _returnServerMS(country, province, ctiy, isp, jsona) {
        let countryData = jsona.MS[country];
        //按country没有查找到就返回default
        if (!countryData) {
            countryData = jsona.MS.default;
            // loger.log("_returnServerMS->countryData->default",countryData);
            return countryData;
        }

        if (country != "中国") {
            // loger.log("_returnServerMS->countryData",countryData);
            return countryData;
        }

        //中国的需要细分
        //按isp查找
        let ispData = countryData.isp[isp];
        //isp查找到就返回
        if (ispData) {
            // loger.log("_returnServerMS->ispData",ispData);
            return ispData;
        }

        //isp没查找到，用province
        let provinceData = countryData.province[province];
        //用province查找到就返回
        if (provinceData) {
            // loger.log("_returnServerMS->provinceData",provinceData);
            return provinceData;
        }


        //isp province都没有，使用default
        let defaultData = countryData.default
        if (defaultData) {
            // loger.log("_returnServerMS->defaultData",defaultData);
            return defaultData;
        } else {
            // loger.log("_returnServerMS->defaultData","");
            return [];
        }

        return [];
    }
}

ServerCheck.prototype.SEVER_CHECK_BEST_IP_SUCCESS = ServerCheck.SEVER_CHECK_BEST_IP_SUCCESS = 'severCheck_checkBestIpSuccess_message';//获取最快的MS地址
export default new ServerCheck;