var WXAssetBundleLibrary = {
  $WXFS: {},

  WXFSInit: function (ttl, capacity) {
    function _instanceof(left, right) { if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { return !!right[Symbol.hasInstance](left); } else { return left instanceof right; } }
    function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
    function _classCallCheck(instance, Constructor) { if (!_instanceof(instance, Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
    function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
    function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
    function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
    function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
    var WXMap = /*#__PURE__*/function () {
      function WXMap(hash, rename) {
        _classCallCheck(this, WXMap);
        this.hash = hash;
        this.rename = rename;
        this.size = 0;
      }
      _createClass(WXMap, [{
        key: "get",
        value: function get(key) {
          return this.hash.get(this.rename(key));
        }
      }, {
        key: "set",
        value: function set(key, value) {
          this.delete(key);
          this.size += value;
          return this.hash.set(this.rename(key), value);
        }
      }, {
        key: "has",
        value: function has(key) {
          return this.hash.has(this.rename(key));
        }
      }, {
        key: "delete",
        value: function _delete(key) {
          this.size -= this.hash.get(this.rename(key))|0;
          return this.hash.delete(this.rename(key));
        }
      }]);
      return WXMap;
    }();
    WXFS.WXABErrorSteps = {
      "kWebRequestResponse": 0,
      "kLoadBundleFromFile": 1,
      "kCacheGet" : 2
    };
    WXFS.disk = new WXMap(unityNamespace.WXAssetBundles,unityNamespace.PathInFileOS);
    WXFS.msg = "";
    WXFS.fd2wxStream = new Map;
    WXFS.path2fd = new Map;
    WXFS.fs = wx.getFileSystemManager();
    WXFS.nowfd = FS.MAX_OPEN_FDS + 1;
    WXFS.isWXAssetBundle = function(url){
      if(WXFS._url2path.has(url)||url.startsWith(GameGlobal.unityNamespace.DATA_CDN)||url.startsWith('/vfs_streamingassets')){
        return unityNamespace.isWXAssetBundle(WXFS.url2path(url));
      }
      return unityNamespace.isWXAssetBundle(url);
    }
    WXFS.newfd = function(){
      return WXFS.nowfd++;
    }
    WXFS.doWXAccess = function(path, amode){
      if (amode & ~7) {
        return -28;
      }
      try{
        WXFS.fs.accessSync(path);
      } catch(e){
        return -44;
      }
      return 0
    }
    
    var WXFileCache = /*#__PURE__*/function () {
      function WXFileCache(ttl, capacity) {
        _classCallCheck(this, WXFileCache);
        this.ttl = ttl;
        if (capacity > 0) this.capacity = capacity;
        this.hash = new Map();
        this.size = 0;
        this.maxSize = 0;
        this.obsolete = "";
      }
      // record obsolete file path when file not found
      _createClass(WXFileCache, [{
        key: "record",
        value: function record(path) {
          if (!this.obsolete.includes(path)) {
            if (this.obsolete != "") this.obsolete += ";";
            this.obsolete += path;
          }
        }
      }, {
        key: "get",
        value: function get(key) {
          var temp = this.hash.get(key);
          if (temp !== undefined) {
            if(temp.cleanable && unityNamespace.isAndroid && temp.time + this.ttl * 1000 < Date.now()){
              try {
                var check_path = WXFS.fd2wxStream.get(key).path
                if(!GameGlobal.manager.getCachePath(check_path)){
                  throw new Error("No such file in the wx cache system")
                }
                WXFS.fs.statSync(check_path)
              } catch (e) {
                GameGlobal.manager.reporter.wxAssetBundle.reportEmptyContent({stage: WXFS.WXABErrorSteps['kCacheGet'], path: check_path, error: !!e ? e.toString() : 'unknown'});
                GameGlobal.manager.Logger.pluginLog('[WXAssetBundle]Android statSync path: ' + check_path + ' error: ' + (!!e ? e.toString() : 'unknown'));
              }
            }
            this.hash.delete(key);
            temp.time = Date.now();
            this.hash.set(key, temp);
            return temp.ab;
          }
          return -1;
        }
      }, {
        key: "put",
        value: function put(key, ab, cleanable) {
          if(!ab)return;
          cleanable = cleanable != undefined ? cleanable : true;
          var value = {
            ab: ab,
            time: Date.now(),
            cleanable: cleanable
          };
          var temp = this.hash.get(key);
          if (temp !== undefined) {
            this.size -= temp.ab.byteLength;
            this.hash.delete(key);
            this.hash.set(key, value);
          } else {
            if (this.capacity !== undefined && this.size >= this.capacity) {
              var idx = this.hash.keys().next().value;
              this.size -= idx.ab.byteLength;
              this.hash.delete(idx);
              this.hash.set(key, value);
            } else {
              this.hash.set(key, value);
            }
          }
          this.size += value.ab.byteLength;
          this.maxSize = Math.max(this.size, this.maxSize);
        }
      }, {
        key: "cleanable",
        value: function cleanable(key, _cleanable) {
          _cleanable = _cleanable != undefined ? _cleanable : true;
          var temp = this.hash.get(key);
          if (temp !== undefined) {
            // this.hash.delete(key);
            // temp.time = Date.now();
            temp.cleanable = _cleanable;
            this.hash.set(key, temp);
            return 0;
          } else {
            return -1;
          }
        }
      }, {
        key: "cleanbytime",
        value: function cleanbytime(deadline) {
          var iter = this.hash.keys(),
            key,
            value;
          while ((key = iter.next().value) != undefined && (value = this.hash.get(key)).time < deadline) {
            if (value.cleanable) {
              this.size -= value.ab.byteLength;
              this.hash.delete(key);
            }
          }
        }
      }, {
        key: "RegularCleaning",
        value: function RegularCleaning(kIntervalSecond) {
          var _this = this;
          setInterval(function () {
            _this.cleanbytime(Date.now() - _this.ttl * 1000);
          }, kIntervalSecond * 1000);
        }
      }, {
        key: "delete",
        value: function _delete(key) {
            this.size -= this.hash.get(key).ab.byteLength;
            return this.hash.delete(key)
        }
      }, {
        key: "has",
        value: function _has(key) {
            return this.hash.has(key)
        }
      }
      ]);
      return WXFileCache;
    }();
    
    WXFS.cache = new WXFileCache(ttl, capacity);
    if(!unityNamespace.isAndroid) {
      WXFS.cache.RegularCleaning(1);
    }

    WXFS.wxstat = function(path){
      try {
        var fd = WXFS.path2fd.get(path)
        if (fd !== undefined){
          var stat = {
            mode: 33206,
            size: WXFS.cache.get(fd).byteLength,
            dev: 1,
            ino: 1,
            nlink: 1,
            uid: 0,
            gid: 0,
            rdev: 0,
            atime: new Date(),
            mtime: new Date(0),
            ctime: new Date(),
            blksize: 4096
          }
          stat.blocks = Math.ceil(stat.size / stat.blksize);
          return stat;
        }
        var stat = WXFS.fs.statSync(path);
        // something not in wx.FileSystemManager, just fill in 0/1
        stat.dev = 1;
        stat.ino = 1;
        stat.nlink = 1;
        stat.uid = 0;
        stat.gid = 0;
        stat.rdev = 0;
        stat.atime = new Date(stat.lastAccessedTime * 1000);
        stat.mtime = new Date(0); // if update modified time, wasm will log error "Archive file was modified when opened"
        stat.ctime = new Date(stat.lastModifiedTime * 1000); // time of permission modification, just use mtime to instand
        delete stat.lastAccessedTime;
        delete stat.lastModifiedTime;
        stat.blksize = 4096;
        stat.blocks = Math.ceil(stat.size / stat.blksize);
        return stat;
      } catch (e){
        console.error(e)
        throw e;
      }
    }
    WXFS._url2path = new Map();
    WXFS.url2path = function(url) {
      if(WXFS._url2path.has(url)){
        return WXFS._url2path.get(url);
      }
      url = url.replaceAll(' ', '%20')
      if(url.startsWith('/vfs_streamingassets/')){
        var path = url.replace('/vfs_streamingassets/', wx.env.USER_DATA_PATH + "/__GAME_FILE_CACHE/StreamingAssets/");
      }
      else{
        var path = url.replace(GameGlobal.unityNamespace.DATA_CDN, wx.env.USER_DATA_PATH+'/__GAME_FILE_CACHE/');
      }
      if(path.indexOf('?') > -1){
        path = path.substring(0,path.indexOf("?"));
      }
      WXFS._url2path.set(url, path);
      return path;
    };
    WXFS.LoadBundleFromFile = function(path){
      try {
        var res = WXFS.fs.readFileSync(path);
      } catch(e) {
        var err_msg = !!e ? e.toString() : 'unknown';
      }
      var expected_size = WXFS.disk.get(path);
      if(!res || res.byteLength != expected_size){
        var wxab_error = {
          stage: WXFS.WXABErrorSteps['kLoadBundleFromFile'],
          path: path,
          size: (!!res ? res.byteLength : 0),
          expected_size: expected_size,
          error: err_msg
        };
        GameGlobal.manager.reporter.wxAssetBundle.reportEmptyContent(wxab_error);
        GameGlobal.manager.Logger.pluginLog('[WXAssetBundle]readFileSync at path ' + path + ' return size ' + (!!res?res.byteLength:0) + ', different from expected size ' + expected_size + ' error: ' + err_msg);
        wx.setStorageSync("wxfs_unserviceable",true);
        GameGlobal.onCrash();
        return "";
      }
      return res;
    };
    WXFS.read = function(stream, buffer, offset, length, position){
      var contents = WXFS.cache.get(stream.fd);
      if (contents === -1) {
        var res = WXFS.LoadBundleFromFile(stream.path);
        WXFS.cache.put(stream.fd, res);
        contents = res;
      }
      if (position >= stream.node.usedBytes) return 0;
      var size = Math.min(stream.node.usedBytes - position, length);
      assert(size >= 0);
      buffer.set(new Uint8Array(contents.slice(position, position + size)), offset);
      return size;
    };
  },

  GetObsoleteFilePath: function () {
    var bufferSize = lengthBytesUTF8(WXFS.cache.obsolete) + 1;
    var buffer = _malloc(bufferSize);
    stringToUTF8(WXFS.cache.obsolete, buffer, bufferSize);
    WXFS.cache.obsolete = "";
    return buffer;
  },

  UnCleanbyPath: function (ptr) {
    var url = UTF8ToString(ptr);
    var path = WXFS.url2path(url);
    if(!WXFS.disk.has(path)){
      WXFS.disk.set(path, 0);
    }
  },

  UnloadbyPath: function (ptr) {
    var path = WXFS.url2path(UTF8ToString(ptr));
    var fd = WXFS.path2fd.get(path);
    if(WXFS.cache.has(fd)){
      WXFS.cache.delete(fd);
    }
    if(WXFS.disk.has(path)){
      WXFS.disk.delete(path);
    }
  },

  CheckWXFSReady: function () {
    return WXFS.fs!==undefined;
  },

  WXGetBundleFromXML: function(url, id, callback, needRetry){
    needRetry = needRetry?needRetry:true;
    var _url = UTF8ToString(url);
    var _id = UTF8ToString(id);
    var len = lengthBytesUTF8(_id) + 1;
    var idPtr = _malloc(len);
    stringToUTF8(_id, idPtr, len);
    var xhr = new GameGlobal.unityNamespace.UnityLoader.UnityCache.XMLHttpRequest;
    xhr.open('GET', _url, true);
    xhr.responseType = "arraybuffer";
    xhr.onload = function (e) {
      if (xhr.status >= 400 && needRetry) {
        setTimeout(function () {
          _WXGetBundleFromXML(url, false);
        }, 1000);
        xhr=null;
        return false;
      }
      if (callback) {
        var kWebRequestOK = 0;
        var kNoResponseBuffer = 1111;
        var xhrByteArray = new Uint8Array(xhr.response);
        if (xhrByteArray.length != 0) {
          var arrayBuffer = xhr.response;
          var path = WXFS.url2path(_url);
          var numberfd = WXFS.path2fd.get(path);
          if (numberfd == undefined) {
            numberfd = WXFS.newfd();
            WXFS.path2fd.set(path, numberfd);
          }
          var wxStream = WXFS.fd2wxStream.get(numberfd);
          if (wxStream == undefined) {
            wxStream = {
              fd: numberfd,
              path: path,
              seekable: true,
              position: 0,
              stream_ops: MEMFS.stream_ops,
              ungotten: [],
              node:{mode:32768,usedBytes:xhrByteArray.length},
              error: false
            };
            wxStream.stream_ops.read = WXFS.read;
            WXFS.fd2wxStream.set(numberfd, wxStream);
          }
          WXFS.cache.put(numberfd, arrayBuffer, xhr.isReadFromCache);
          WXFS.disk.set(path, xhrByteArray.length);
          dynCall("viii", callback, [idPtr, kWebRequestOK, 0]);
          if(xhr.isReadFromCache){
            _free(idPtr);
          }
        } else {
          dynCall('viii', callback, [idPtr, kNoResponseBuffer, 0]);
          _free(idPtr);
        }
      }
    };
    xhr.onsave = function xhr_onsave(e){
      WXFS.cache.cleanable(WXFS.path2fd.get(e));
      _free(idPtr);
    }
    function XHRHandleError(err, code) {
      if (needRetry) {
        return setTimeout(function () {
          _WXGetBundleFromXML(url, false);
        }, 1e3);
      }
      if (callback) {
        var len = lengthBytesUTF8(err) + 1;
        var buffer = _malloc(len);
        stringToUTF8(err, buffer, len);
        dynCall("viii", callback, [idPtr, code, buffer]);
        _free(buffer);
        _free(idPtr);
      }
    }
    xhr.onerror = function xhr_onerror(e) {
      var kWebErrorUnknown = 2;
      XHRHandleError("Unknown error.", kWebErrorUnknown);
    };
    xhr.ontimeout = function xhr_onerror(e) {
      var kWebErrorTimeout = 14;
      XHRHandleError("Connection timed out.", kWebErrorTimeout);
    };
    xhr.onabort = function xhr_onerror(e) {
      var kWebErrorAborted = 17;
      XHRHandleError("Aborted.", kWebErrorAborted);
    }
    xhr.send();
  },

  WXGetBundleNumberInMemory: function () { 
    return WXFS&&WXFS.cache&&WXFS.cache.hash&&WXFS.cache.hash.size; 
  },
  WXGetBundleNumberOnDisk: function () { 
    return WXFS&&WXFS.disk&&WXFS.disk.hash&&WXFS.disk.hash.size; 
  },
  WXGetBundleSizeInMemory: function () { 
    return WXFS&&WXFS.cache&&WXFS.cache.size; 
  },
  WXGetBundleSizeOnDisk: function () { 
    return WXFS&&WXFS.disk&&WXFS.disk.size; 
  }
};

autoAddDeps(WXAssetBundleLibrary, '$WXFS');
mergeInto(LibraryManager.library, WXAssetBundleLibrary);