import { type } from "os";

export default {
 
  /**
   * 获取缓存sessionStorage数据
   * @param {*str} key 
   * @param {* obj||str} val 
   */
  setCache: function (key, val) {
    if (val instanceof Array) {
      let str = JSON.stringify(val);
      window.sessionStorage.setItem(key, str);
    } else {
      window.sessionStorage.setItem(key, val);
    }

  },

  /**
   * 获取缓存sessionStorage数据
   * @param {*str} key 
   */
  getCache: function (key) {
    return window.sessionStorage.getItem(key);
  },
  
  /**
   * 获取缓存localStorage数据
   * @param {*str} key 
   * @param {* obj||str} val 
   */
  setItem: function (key,val) {
    if (val instanceof Array || val instanceof Object) {
      let str = JSON.stringify(val);
      localStorage.setItem(key, str);
    } else {
      localStorage.setItem(key, val);
    }
    //return localStorage.setItem(key,val);
  },
  
  /**
   * 获取缓存localStorage数据
   * @param {*str} key 
   */
  getItem: function (key) {
    return localStorage.getItem(key);
  },

  /**
   * 比赛时间计时器
   * @param {分钟} f 
   * @param {秒} s 
   * @param {回掉方法} fun 
   */
  timer: function (f, s, fun) {
    let timing = setInterval(function () {
      s++;
      if (s < 10) {
        s = "0" + s;
      }
      if (s == 60) {
        f++;
        s = '00';
      }
      fun && fun(f, s);
    }, 1000)
  },

  /**
   * 详情页面玩法投注公共方法
   * @param {obj} betting 玩法组件的选择赔率id数组
   * @param {*obj} bettingInfo 当前玩法赔率及相关数据
   * @param {*obj} data当前玩法赔率数据信息列表
   * @param {*obj} getBettingList Vuex里面的投注列表
   * @param {*str} name 当前组的玩法的title
   * @param {*int} dataNum 判断当前组件是否已有投注
   * @param {*int} limit 投注数量
   * @param {*function} callback 修改当前样式回调方法
   * @param {*function} fun 更新Vuex投注列表
   */
  bettingFunction: function (betting, bettingInfo, data, getBettingList, name, dataNum,limit,callback, fun) {
    let isTrue = true;
    let isAlert = false;
    betting.forEach((e, index) => {
      //删除投注数据
      if (bettingInfo.mark == e.mark) {
        data.forEach((res) => {
          if (bettingInfo.mark == res.mark) {
            callback && callback(res, false);
            betting.splice(index, 1);
          }
        })
        isTrue = false;
      }
    });
    //添加投注数据
    if (isTrue) {
      if(limit >= 10 ) {
        isAlert =true;
      }else{
        betting.push(bettingInfo);
        betting.forEach((e) => {
          if (bettingInfo.mark == e.mark) {
            data.forEach(res => {
              if (bettingInfo.mark == res.mark) {
                callback && callback(res, true);
              }
            })
          }
        })
      }   
    }

    //初始化添加投注数据
    let obj = {
      title: name,
      data: betting
    };
    let array = [];
    if (dataNum != 10000) {
      getBettingList[dataNum] = obj;
    } else {
      if (getBettingList) {
        if (getBettingList.length > 0) {
          getBettingList.push(obj);
        }
      } else {
        array.push(obj);
      }
    }
    fun && fun(getBettingList, array,isAlert);
  },


  /**
   * 获取vuex相对应玩法index下标和投注数据集合
   * @param {组件类所有玩法数据集合} data 
   * @param {组件里玩法别名} title 
   * @param {从Vuex里面的投注列表的匹配对应的投注数据集合} betting 
   * @param {相对应玩法index下标} dataNum 
   */
  getBettingId(data, title, callback) {
    if (data) {
      data.forEach((res, index) => {
        if (res.title == title) {
          callback && callback(res.data, index);
        }
      });
    }
  },
  /**
   * 接口轮询定时器
   * @param {function} callback 定时器回调方法
   */
  ajaxTimerFun(callback,timers=2000){
    //到计时
    let  timing = setInterval(function(){
      callback && callback(timing)
    },timers);
    // },5000);
  },


  /**
   * 复合算法
   * @param {int} data  第几场赛事
   * @param {array} dataList 投注赛事列表
   */
  betPlay(data,dataList){
    let addSum =0;
    let listLenth = dataList.length;
    //调用赔率算法
    addSum = this.oddsAlgorithm(data,dataList);

    //组合算法分母
    function denominator (num){
      let group =1;
      for(let i = listLenth ; i >(listLenth -num);i--){
        let add = group*i
        group  =  add;
      }
      return group;
    }
    //组合算法分子
    function molecule (num){
      let son =1;
      for(let i = num ; i >1;i--){
        let add = son*i;
        son  =  add;
      }
      return son;
    }
    //组合算法
    function algorithm(data) {
      return {
        title:`${data}串1`,//algorithm
        index:denominator(data)/molecule(data),
        odds:addSum,
      };
    }    
    return algorithm(data);
  },

  /**
   * 赔率算法
   * @param {int} index  第几次赛事
   * @param {[]} dataList 赛事列表
   */
  oddsAlgorithm(index,dataList){
    let oddsArray=[];
    let num = index;
    let list = [];
    dataList.forEach((res)=>{
      oddsArray.push(res.odds);
    })
    for (let i=0;i<Math.pow(2, oddsArray.length);i++){
      let a = 0;
      let b = "";
      for (let j=0;j<oddsArray.length;j++){
        if (i>>j&1){
          a++;
          b += oddsArray[j]+',';
        }
      }
      if(a==num){
        let array = b.split(',');
        array.pop();
        list.push(array);
      }
    }
    let odds =0;
    list.forEach(e=>{
      let h =1;
      e.forEach(res=>{
        h = h*(1+res*1)
      })
      odds +=h*1-1;
    })
    return odds;
  }
  

}


