/**
 *
 * IP 管理（ip信息或，动态选点)
 * */

import Emiter from 'Emiter';
import Loger from 'Loger';
import MD5 from "md5";
import iphunter from 'iphunter';
import fetchJsonp from 'fetch-jsonp';
import Server from "config/Server";

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

const TIME_OUT = 2000;//选点超时
const MS_DEFAULT_PORT = "1935";//默认流媒体端口
const MCU_DEFAULT_PORT = "7777";//默认的mcu端口
const SPEED_TEST_PORT = '5555';//测速端口(MCU/MS)

class IpManager extends Emiter {
    constructor() {
        super();
    }
    //获取本地Server JSON
    loadServerJosn(_callback){
        let serverInfo = {
            ret: -1
        };
        let timestamp=new Date().getTime();
        let url = `server.json?v=${timestamp}`;
        loger.log("获取Server信息->", url);
        let _this = this;
        fetch(url, {
            timeout: 3000
        })
            .then(ret => {
                if (ret.ok) {
                    return ret.json();
                } else {
                    loger.error(`获取Server信息-网络异常.状态码:${ret.status}`);
                    if (_callback) {
                        _callback(serverInfo);
                    }
                    return;
                }
            })
            .then(ret => {
                if (ret) {
                    Server.serverListData=ret||{};
                    serverInfo.data=ret;
                }
                loger.log('获取Server信息->完成->', ret);
                if (_callback) {
                    _callback(serverInfo);
                }
            })
            .catch(err => {
                loger.error(`获取Server信息-异常.状态码:${err}`);
                if (_callback) {
                    _callback(serverInfo);
                }
            });
    }
    //根据userIp获取ip相关的信息，参数是userIp
    getUserIpInfo(token, userIp, _callback, _timeOutDelay) {
        let userIpInfo = {
            ret: -1
        };
        // //("addr=" + ip + "&token=b657c3507b324353e09c1958ee956a98efceb3e3")，转成MD5
        let md5Str = MD5("addr=" + userIp + "&token=b657c3507b324353e09c1958ee956a98efceb3e3");
        let timestamp = new Date().getTime();
        let url = `http://ipapi.ipip.net/find?addr=${userIp}&sid=14&uid=5237&sig=${md5Str}&_=${timestamp}`;
        loger.log("获取IP信息->", url);
        let _this = this;
        fetchJsonp(url, {
            timeout: _timeOutDelay || TIME_OUT,
        }).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];//运营商
            }
            loger.warn('获取IP信息->完成->', userIpInfo);
            if (_callback) {
                _callback(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();
                 }*/
            }
        }).catch(function (ex) {
            loger.warn('获取IP信息->失败->', ex.message);
            if (_callback) {
                _callback(userIpInfo);
            }
        });
    }

    //获取最快的MCU服务器地址,参数是一个ip数组
    getFastestMcuServer(_ipList, _callback, _timeOutDelay) {
        loger.log('开始MCU选点-> ', _ipList);
        let callbackData = {ip: ""};
        if (_ipList == null || _ipList.length < 1) {
            if (_callback) {
                _callback(callbackData);
            }
            return;
        }
        //对传入的ip数组进行组织
        let newList = new Object();
        let listLen = _ipList.length;
        for (let i = 0; i < listLen; i++) {
            let msItem = _ipList[i];
            if (msItem && msItem.ip) {
                //测速的时候，ip地址要拼接成带端口的完整地址，测速的端口是固定的
                //newList.add((msItem.ip + ':' + SPEED_TEST_PORT));
                newList[msItem.ip + ':' + SPEED_TEST_PORT]=msItem.ip + ':' + SPEED_TEST_PORT;
            }
        }
        //过滤完重复ip
        //let ipListArr = Array.from(newList);
        let ipListArr =new Array();
        for(let k in newList){
            ipListArr.push(k);
        }

        loger.log('MCU选点->列表', ipListArr);
        if (ipListArr == null || ipListArr.length < 1) {
            if (_callback) {
                _callback(callbackData);
            }
            return;
        }
        try {
            iphunter(ipListArr, function (fatest_ip_response) {
                if (!fatest_ip_response) {
                    loger.warn('MCU选点-> nothing!');
                    if (_callback) {
                        _callback(callbackData);
                    }
                } else {
                    loger.log('MCU选点->done -> ', fatest_ip_response);
                    let fastestIp = fatest_ip_response.replace((':' + SPEED_TEST_PORT), '') || ""
                    callbackData.ip = fastestIp;
                    callbackData.port = '';

                    //根据ip从原来的ip列表中查找端口
                    let listLen = _ipList.length;
                    for (let i = 0; i < listLen; i++) {
                        let msItem = _ipList[i];
                        if (msItem && msItem.ip) {
                            if (fastestIp == msItem.ip) {
                                callbackData.port = msItem.port || MCU_DEFAULT_PORT;
                                break;
                            }
                        }
                    }

                    //返回数据
                    if (_callback) {
                        _callback(callbackData);
                    }
                }
            }, _timeOutDelay || TIME_OUT);
        } catch (err) {
            loger.log('MCU选点->失败', err.message);
        }
    }

    //获取最快的MS服务器地址，参数是一个ip数组
    getFastestMsServer(_ipList, _callback, _timeOutDelay) {
        loger.log('开始MS选点->', _ipList);
        let callbackData = {ip: ""};
        if (_ipList == null || _ipList.length < 1) {
            if (_callback) {
                _callback(callbackData);
            }
            return;
        }
        //对传入的ip数组进行组织
        let newList = new Object();
        let listLen = _ipList.length;
        for (let i = 0; i < listLen; i++) {
            let msItem = _ipList[i];
            if (msItem && msItem.ip) {
                //测速的时候，ip地址要拼接成带端口的完整地址，测速的端口是固定的
                newList[msItem.ip + ':' + SPEED_TEST_PORT]=msItem.ip + ':' + SPEED_TEST_PORT;
            }
        }
        //过滤完重复ip
        let ipListArr =new Array();
        for(let k in newList){
            ipListArr.push(k);
        }

        if (ipListArr == null || ipListArr.length < 1) {
            if (_callback) {
                _callback(callbackData);
            }
            return;
        }
        loger.log('MS选点->列表', ipListArr);
        try {
            iphunter(ipListArr, function (fatest_ip_response) {
                if (!fatest_ip_response) {
                    loger.warn('MS选点-> nothing!');
                    if (_callback) {
                        _callback(callbackData);
                    }
                } else {
                    loger.log('MS选点->done -> ', fatest_ip_response);
                    let fastestIp = fatest_ip_response.replace((':' + SPEED_TEST_PORT), '') || ""
                    callbackData.ip = fastestIp;
                    callbackData.port = '';

                    //根据ip从原来的ip列表中查找端口
                    let listLen = _ipList.length;
                    for (let i = 0; i < listLen; i++) {
                        let msItem = _ipList[i];
                        if (msItem && msItem.ip) {
                            if (fastestIp == msItem.ip) {
                                callbackData.port = msItem.port || MS_DEFAULT_PORT;
                                break;
                            }
                        }
                    }
                    //返回数据
                    if (_callback) {
                        _callback(callbackData);
                    }
                }
            }, _timeOutDelay || TIME_OUT);
        } catch (err) {
            loger.warn('MS选点->ERROR -> ', err.message);
            if (_callback) {
                _callback(callbackData);
            }
        }

    }

    //根据user信息从配置文件中MCU连接地址
    getServerMcuList(country, province, ctiy, isp, jsona) {
        let countryData = jsona.MCU[country];
        //按country没有查找到就返回default
        if (!countryData) {
            countryData = jsona.MCU.default || [];
            return countryData;
        }
        if (country != "中国") {
            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 [];
    }

    //根据user信息从配置文件中MS连接地址
    getServerMsList(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 [];
    }

}
export default  IpManager;