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

import Emiter from 'Emiter';
import Loger from 'Loger';
import MD5 from "md5";
import iphunter from 'iphunter';
import fetchJsonp from 'fetch-jsonp';
import ServerConfig from "config/ServerConfig";
import GlobalConfig from "GlobalConfig";
// 日志对象
const loger = Loger.getLoger('IpManager');

const TIME_OUT = 2000;//选点超时
const MS_DEFAULT_PORT = "1935";//默认流媒体端口
const MCU_DEFAULT_PORT = "";//默认的mcu端口 //7777
const SPEED_TEST_PORT = '5555';//测速端口(MS)
const MCU_SPEED_TEST_PORT = '5556';//测速端口(MCU)
class IpManager extends Emiter {
    constructor() {
        super();
    }
    //获取本地白板配置json
    loadWhiteboardJosn(_callback){
        //-------------加载本地数据的代码-------------------
        let callbackInfo = {
            ret: -1
        };
        let timestamp=new Date().getTime();
        let url = `${GlobalConfig.locationProtocol+GlobalConfig.whiteboardJsonPath}?v=${timestamp}`;
        loger.log("获取白板配置信息->", url);
        fetch(url, {
            timeout: 3000
        })
          .then(ret => {
              if (ret.ok) {
                  return ret.json();
              } else {
                  loger.error(`获取白板配置信息-网络异常.状态码:${ret.status}`);
                  if (_callback) {
                      _callback(callbackInfo);
                  }
                  return;
              }
          })
          .then(ret => {
              if (ret) {
                  callbackInfo.data=ret;
                  callbackInfo.ret=1;
              }
              loger.log('获取白板配置信息->完成->');
              if (_callback) {
                  _callback(callbackInfo);
              }
          })
          .catch(err => {
              loger.error(`获取白板配置信息-异常.状态码:${err}`);
              if (_callback) {
                  _callback(callbackInfo);
              }
          });
    }

    //获取本地Server JSON
    loadServerJosn(_callback){
        //20170803-不再加载本地的server.json数据，以后都从Sass获取
        if (_callback) {
            _callback(serverInfo);
            return;
        }
        return;

        //-------------加载本地数据的代码-------------------
        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) {
                    //ServerConfig.serverListData=ret||{};
                    serverInfo.data=ret;
                    serverInfo.ret=1;
                }
                loger.log('获取Server信息->完成->');
                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}`;
        let url = `${GlobalConfig.locationProtocol}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 + ':' + MCU_SPEED_TEST_PORT]=msItem.ip + ':' + MCU_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((':' + MCU_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);
            }
        }

    }

    //服务器列表测速，参数是一个ip数组，返回一个ip
    testFastestIpFromServer(_ipList, _callback, _timeOutDelay) {
        loger.log('开始测试->', _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('测速地址列表->', ipListArr);
        try {
            iphunter(ipListArr, function (fatest_ip_response) {
                if (!fatest_ip_response) {
                    loger.warn('测速返回-> nothing!');
                    if (_callback) {
                        _callback(callbackData);
                    }
                } else {
                    loger.log('测速返回->完成 -> ', 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('测速失败->ERROR -> ', err.message);
            if (_callback) {
                _callback(callbackData);
            }
        }

    }
    static getUserIp(){
      try{
        let head= document.getElementsByTagName('head')[0];
        let script= document.createElement('script');
        script.type= 'text/javascript';
        script.src= 'https://pv.sohu.com/cityjson?ie=utf-8';
        head.appendChild(script);
        window.onload=function(){
          loger.warn('获取本机IP->',window.returnCitySN);
          GlobalConfig.returnCitySN=window.returnCitySN;
          //用户IP，优先使用从
          if(GlobalConfig.returnCitySN){
            GlobalConfig.userIp=GlobalConfig.returnCitySN["cip"]||"";
          }
        }
      }catch (err){
        loger.warn('获取IP失败 ', err.message);
      }

    }
    //根据user信息从server配置文件中获取服务列表信息
    // _type()
    /* "MS":{},
    "RTMP_PULL":{},
    "HLS_PULL":{},
    "RS_PULL":{},
    "MCU":{}*/
    getServerListForUserInfo(_type,_country, province, ctiy, isp, jsona) {
        if(!jsona){
            return [];
        }
        if(! jsona[_type]){
            return []
        }
        let countryData = jsona[_type][_country];
        //按country没有查找到就返回default
        if (!countryData) {
            countryData = jsona[_type].default || [];
            // loger.log("_returnServerMS->countryData->default",countryData);
            return countryData;
        }

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

        //中国的需要细分
        //按isp查找
        let ispData =null;
        if(countryData.isp){
            ispData= countryData.isp[isp];
        }

        //isp查找到就返回
        if (ispData) {
            // loger.log("_returnServerMS->ispData",ispData);
            return ispData;
        }

        //isp没查找到，用province
        let provinceData =null;
        if( countryData.province){
            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;