import store from '@/store';

export function WebSocketFunc(ws, wsUrl, callback, callback1) {
  var lockReconnect = false; // 避免重复连接
  function createWebSocket(url) {
    try {
      console.log('wsUrl', wsUrl);
      if ('WebSocket' in window) {
        ws = new WebSocket(url);
      } else if ('MozWebSocket' in window) {
        ws = new MozWebSocket(url);
      } else {
        ws = new SockJS(url);
      }
      callback1 && callback1(ws);
      initEventHandle();
    } catch (e) {
      reconnect(wsUrl);
    }
  }

  function initEventHandle() {
    ws.onclose = function (evnt) {
      // console.log('websocket服务关闭了');
      console.log(
        'websocket 断开: ' +
          'code:' +
          evnt.code +
          ' ' +
          'reason:' +
          evnt.reason +
          ' ' +
          'wasClean:' +
          evnt.wasClean
      );
      // reconnect(evnt.target.url);
      // 1.前端主动关闭连接 2.运营商关闭连接
      // if (evnt.url === wsUrl) {
      //   console.log('前端主动连接中断');
      // } else {
      //   // 可能是运营商关闭连接
      //   reconnect(evnt.target.url);
      //   console.log('心跳重连...');
      // }
      if (store.state.websocket.isClose) {
        console.log('前端主动连接中断');
        store.dispatch('websocket/getWsClose', false);
      } else {
        reconnect(evnt.target.url);
        console.log('心跳重连...');
      }
    };
    ws.onerror = function () {
      console.log('websocket服务出错了');
      reconnect(wsUrl);
    };
    ws.onopen = function () {
      console.log('send device sn: ', store.getters['user/curDevice'].sn);
      ws.send(store.getters['user/curDevice'].sn);
      // 心跳检测重置
      heartCheck.reset().start();
    };
    ws.onmessage = function (evnt) {
      // 如果获取到消息，心跳检测重置
      // 拿到任何消息都说明当前连接是正常的
      // console.log('websocket服务获得数据了')
      // 接受消息后的UI变化
      doWithMsg(evnt.data);
      heartCheck.reset().start();
    };

    // 收到消息推送
    function doWithMsg(msg) {
      console.log(
        "websocket's msg",
        msg.indexOf('成功建立websocket连接') == 0 ||
          !msg.indexOf('Pong') ||
          msg.indexOf('设备') != -1 ||
          msg.indexOf('连接成功') != -1
          ? msg
          : JSON.parse(msg)
      );
      callback && callback(msg);
    }
  }

  function reconnect(url) {
    console.log('正在重连...');
    if (lockReconnect) return;
    lockReconnect = true;
    // 没连接上会一直重连，设置延迟避免请求过多
    setTimeout(function () {
      createWebSocket(url);
      lockReconnect = false;
    }, 2000);
  }

  // 心跳检测
  var heartCheck = {
    timeout: 10000, // 5秒
    timeoutObj: null,
    serverTimeoutObj: null,
    reset: function () {
      clearTimeout(this.timeoutObj);
      clearTimeout(this.serverTimeoutObj);
      return this;
    },
    start: function () {
      var self = this;
      this.timeoutObj = setTimeout(function () {
        // 这里发送一个心跳，后端收到后，返回一个心跳消息
        // onmessage拿到返回的心跳就说明连接正常
        ws.send('Ping');
        console.log('Ping');
        self.serverTimeoutObj = setTimeout(function () {
          // 如果超过一定时间还没重置，说明后端主动断开了
          ws.close(); // 如果onclose会执行reconnect，我们执行ws.close()就行了.如果直接执行reconnect 会触发onclose导致重连两次
        }, self.timeout);
      }, this.timeout);
    }
  };

  // 初始化websocket
  createWebSocket(wsUrl);
}

import Blob from './Excel/Blob'
import Export2Excel from './Excel/Export2Excel.js'

//导出的方法
exportExcel() {
  require.ensure([], () => {
    const { export_json_to_excel } = require('../Excel/Export2Excel');//注意这个Export2Excel路径
    const tHeader = ['序号', '昵称', '姓名'];   // 上面设置Excel的表格第一行的标题
    const filterVal = ['index', 'nickName', 'name']; // 上面的index、nickName、name是tableData里对象的属性key值
    const list = this.tableData;  //把要导出的数据tableData存到list
    const data = this.formatJson(filterVal, list);
    export_json_to_excel(tHeader, data, '列表excel');//最后一个是表名字
  })
},
formatJson(filterVal, jsonData) {
  return jsonData.map(v => filterVal.map(j => v[j]))
}

/* eslint-disable */
/*  Blob.js
 * A Blob implementation.
 * 2014-05-27
 *
 * By Eli Grey, http://eligrey.com
 * By Devin Samarin, https://github.com/eboyjr
 * License: X11/MIT
 *   See LICENSE.md
 */

/*global self, unescape */
/*jslint bitwise: true, regexp: true, confusion: true, es5: true, vars: true, white: true,
 plusplus: true */

/*! @source http://purl.eligrey.com/github/Blob.js/blob/master/Blob.js */

(function (view) {
  "use strict";

  view.URL = view.URL || view.webkitURL;

  if (view.Blob && view.URL) {
      try {
          new Blob;
          return;
      } catch (e) {}
  }

  // Internally we use a BlobBuilder implementation to base Blob off of
  // in order to support older browsers that only have BlobBuilder
  var BlobBuilder = view.BlobBuilder || view.WebKitBlobBuilder || view.MozBlobBuilder || (function(view) {
          var
              get_class = function(object) {
                  return Object.prototype.toString.call(object).match(/^\[object\s(.*)\]$/)[1];
              }
              , FakeBlobBuilder = function BlobBuilder() {
                  this.data = [];
              }
              , FakeBlob = function Blob(data, type, encoding) {
                  this.data = data;
                  this.size = data.length;
                  this.type = type;
                  this.encoding = encoding;
              }
              , FBB_proto = FakeBlobBuilder.prototype
              , FB_proto = FakeBlob.prototype
              , FileReaderSync = view.FileReaderSync
              , FileException = function(type) {
                  this.code = this[this.name = type];
              }
              , file_ex_codes = (
                  "NOT_FOUND_ERR SECURITY_ERR ABORT_ERR NOT_READABLE_ERR ENCODING_ERR "
                  + "NO_MODIFICATION_ALLOWED_ERR INVALID_STATE_ERR SYNTAX_ERR"
              ).split(" ")
              , file_ex_code = file_ex_codes.length
              , real_URL = view.URL || view.webkitURL || view
              , real_create_object_URL = real_URL.createObjectURL
              , real_revoke_object_URL = real_URL.revokeObjectURL
              , URL = real_URL
              , btoa = view.btoa
              , atob = view.atob

              , ArrayBuffer = view.ArrayBuffer
              , Uint8Array = view.Uint8Array
              ;
          FakeBlob.fake = FB_proto.fake = true;
          while (file_ex_code--) {
              FileException.prototype[file_ex_codes[file_ex_code]] = file_ex_code + 1;
          }
          if (!real_URL.createObjectURL) {
              URL = view.URL = {};
          }
          URL.createObjectURL = function(blob) {
              var
                  type = blob.type
                  , data_URI_header
                  ;
              if (type === null) {
                  type = "application/octet-stream";
              }
              if (blob instanceof FakeBlob) {
                  data_URI_header = "data:" + type;
                  if (blob.encoding === "base64") {
                      return data_URI_header + ";base64," + blob.data;
                  } else if (blob.encoding === "URI") {
                      return data_URI_header + "," + decodeURIComponent(blob.data);
                  } if (btoa) {
                      return data_URI_header + ";base64," + btoa(blob.data);
                  } else {
                      return data_URI_header + "," + encodeURIComponent(blob.data);
                  }
              } else if (real_create_object_URL) {
                  return real_create_object_URL.call(real_URL, blob);
              }
          };
          URL.revokeObjectURL = function(object_URL) {
              if (object_URL.substring(0, 5) !== "data:" && real_revoke_object_URL) {
                  real_revoke_object_URL.call(real_URL, object_URL);
              }
          };
          FBB_proto.append = function(data/*, endings*/) {
              var bb = this.data;
              // decode data to a binary string
              if (Uint8Array && (data instanceof ArrayBuffer || data instanceof Uint8Array)) {
                  var
                      str = ""
                      , buf = new Uint8Array(data)
                      , i = 0
                      , buf_len = buf.length
                      ;
                  for (; i < buf_len; i++) {
                      str += String.fromCharCode(buf[i]);
                  }
                  bb.push(str);
              } else if (get_class(data) === "Blob" || get_class(data) === "File") {
                  if (FileReaderSync) {
                      var fr = new FileReaderSync;
                      bb.push(fr.readAsBinaryString(data));
                  } else {
                      // async FileReader won't work as BlobBuilder is sync
                      throw new FileException("NOT_READABLE_ERR");
                  }
              } else if (data instanceof FakeBlob) {
                  if (data.encoding === "base64" && atob) {
                      bb.push(atob(data.data));
                  } else if (data.encoding === "URI") {
                      bb.push(decodeURIComponent(data.data));
                  } else if (data.encoding === "raw") {
                      bb.push(data.data);
                  }
              } else {
                  if (typeof data !== "string") {
                      data += ""; // convert unsupported types to strings
                  }
                  // decode UTF-16 to binary string
                  bb.push(unescape(encodeURIComponent(data)));
              }
          };
          FBB_proto.getBlob = function(type) {
              if (!arguments.length) {
                  type = null;
              }
              return new FakeBlob(this.data.join(""), type, "raw");
          };
          FBB_proto.toString = function() {
              return "[object BlobBuilder]";
          };
          FB_proto.slice = function(start, end, type) {
              var args = arguments.length;
              if (args < 3) {
                  type = null;
              }
              return new FakeBlob(
                  this.data.slice(start, args > 1 ? end : this.data.length)
                  , type
                  , this.encoding
              );
          };
          FB_proto.toString = function() {
              return "[object Blob]";
          };
          FB_proto.close = function() {
              this.size = this.data.length = 0;
          };
          return FakeBlobBuilder;
      }(view));

  view.Blob = function Blob(blobParts, options) {
      var type = options ? (options.type || "") : "";
      var builder = new BlobBuilder();
      if (blobParts) {
          for (var i = 0, len = blobParts.length; i < len; i++) {
              builder.append(blobParts[i]);
          }
      }
      return builder.getBlob(type);
  };
}(typeof self !== "undefined" && self || typeof window !== "undefined" && window || this.content || this));

localforage.getItem('somekey').then(function(value) {
    // 当离线仓库中的值被载入时，此处代码运行
    console.log(value);
}).catch(function(err) {
    // 当出错时，此处代码运行
    console.log(err);
});

// 回调版本：
localforage.getItem('somekey', function(err, value) {
    // 当离线仓库中的值被载入时，此处代码运行
    console.log(value);
});

const store = localforage.createInstance({
    name: "nameHere"
});

const otherStore = localforage.createInstance({
    name: "otherName"
});

// 设置某个数据仓库 key 的值不会影响到另一个数据仓库
store.setItem("key", "value");
otherStore.setItem("key", "value2");

// 调用时，若不传参，将删除当前实例的 “数据仓库” 。
localforage.dropInstance().then(function() {
  console.log('Dropped the store of the current instance').
});

// 调用时，若参数为一个指定了 name 和 storeName 属性的对象，会删除指定的 “数据仓库”。
localforage.dropInstance({
  name: "otherName",
  storeName: "otherStore"
}).then(function() {
  console.log('Dropped otherStore').
});

// 调用时，若参数为一个仅指定了 name 属性的对象，将删除指定的 “数据库”（及其所有数据仓库）。
localforage.dropInstance({
  name: "otherName"
}).then(function() {
  console.log('Dropped otherName database').
});

// 全部引入
import idbKeyval from 'idb-keyval';

idbKeyval.set('hello', 'world')
  .then(() => console.log('It worked!'))
  .catch((err) => console.log('It failed!', err));
  
// 按需引入会摇树
import { get, set } from 'idb-keyval';

set('hello', 'world')
  .then(() => console.log('It worked!'))
  .catch((err) => console.log('It failed!', err));
  
get('hello').then((val) => console.log(val));

function reveal() {
   let dataDiv = document.getElementById('data-attr');
    let value = dataDiv.dataset['customAttr'];
   document.getElementById('msg').innerHTML = `<mark>${value}</mark>`;
}

function Person() {

}
let person = new Person();
person.name = 'jimmy';
console.log(person.name) // jimmy

function Person() {

}
// **prototype 是函数才会有的属性**
Person.prototype.name = 'Kevin';
var person1 = new Person();
var person2 = new Person();
console.log(person1.name) // Kevin
console.log(person2.name) // Kevin

function Person() {

}
var person = new Person();
console.log(person.__proto__ === Person.prototype); // true

function Person() {

}
console.log(Person === Person.prototype.constructor); // true

function Person() {

}

var person = new Person();

console.log(person.__proto__ === Person.prototype) // true
console.log(Person.prototype.constructor === Person) // true
// 顺便学习一个ES5的方法,可以获得对象的原型
console.log(Object.getPrototypeOf(person) === Person.prototype) // true

function Person() {

}

Person.prototype.name = 'jimmy';
let person = new Person();
person.name = 'chimmy';
console.log(person.name) // chimmy
delete person.name;
console.log(person.name) // jimmy

let obj = new Object();
obj.name = 'jimmy'
console.log(obj.name) // jimmy

console.log(Object.prototype.__proto__ === null) // true

function Person() {

}
var person = new Person();
console.log(person.constructor === Person); // true

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(nums, target) {
   for (let i = 0; i < nums.length; i ++) {
       for (let k = i + 1; k <= nums.length; k ++) {
           if (nums[i] + nums[k] == target) {
               return [i, k]
           }
       }
   }
};

/**
 * @param {number} x
 * @return {number}
 */
var reverse = function(x) {
    x = String(x);
    let target = [];
    if (Number(x) < 0) {
        target[0] = x.split("")[0];
        target.push(x.split("").splice(1).reverse().join(""));
        target = target.join('')
    } else {
        target = x.split("").reverse().join("");
    }
    if (Number(target) <= 2147483648 && Number(target) >= -2147483648) {
        return target;
    } else {
        return 0;
    }
};

/**
 * @param {number} x
 * @return {boolean}
 */
var isPalindrome = function (x) {
    x1 = String(x);
    x2 = String(x).split('').reverse().join("")
    return x1 == x2
};

/**
 * @param {string[]} strs
 * @return {string}
 */
var longestCommonPrefix = function (strs) {
    var re = ''
    if (!strs.length || strs.includes('')) return re;
    if (strs.length == 1) return strs[0]
    for (let i = 0; i < strs[0].length; i++) {
        for (let j = 0; j < strs.length; j++) {
            if (strs[j][i] != strs[0][i]) return re;
        }
        re += strs[0][i]
    }
    return re
};

/**
 * @param {string} s
 * @return {boolean}
 */
var isValid = function(s) {
  if (s.length == 1) {
    return false;
  }

  let mapList = new Map([
    [')', '('],
    ['}', '{'],
    [']', '[']
  ])

  let stk = []

  for (let ch of s) {
    if (mapList.has(ch)) {
      if (!stk.length || stk[stk.length - 1] !== mapList.get(ch)) {
        return false;
      }
      stk.pop()
    } else {
      stk.push(ch)
    }
  }

  return !stk.length
};