import localforage from 'localforage';
import log from './logger.js';
import { instantiateAny } from './wasm-utils.js';

import td_wasm_release from './prebuilt/release/td_wasm.wasm';
import td_asmjs_mem_release from './prebuilt/release/td_asmjs.js.mem';

const tdlibVersion = 6;
const localForageDrivers = [
  localforage.INDEXEDDB,
  localforage.LOCALSTORAGE,
  'memoryDriver'
];

async function initLocalForage() {
  // Implement the driver here.
  const memoryDriver = {
    _driver: 'memoryDriver',
    _initStorage: function(options) {
      const dbInfo = {};
      if (options) {
        for (const i in options) {
          dbInfo[i] = options[i];
        }
      }
      this._dbInfo = dbInfo;
      this._map = new Map();
    },
    clear: async function() {
      this._map.clear();
    },
    getItem: async function(key) {
      const value = this._map.get(key);
      console.log('getItem', this._map, key, value);
      return value;
    },
    iterate: async function(iteratorCallback) {
      log.error('iterate is not supported');
    },
    key: async function(n) {
      log.error('key n is not supported');
    },
    keys: async function() {
      return this._map.keys();
    },
    length: async function() {
      return this._map.size();
    },
    removeItem: async function(key) {
      this._map.delete(key);
    },
    setItem: async function(key, value) {
      const originalValue = this._map.get(key);
      console.log('setItem', this._map, key, value);
      this._map.set(key, value);
      return originalValue;
    }
  };

  // Add the driver to localForage.
  localforage.defineDriver(memoryDriver);
}

async function loadTdlibWasm(onFS, wasmUrl) {
  console.log('loadTdlibWasm');
  const td_module = await import('./prebuilt/release/td_wasm.js');
  const createTdwebModule = td_module.default;
  log.info('got td_wasm.js', td_module, createTdwebModule);
  let td_wasm = td_wasm_release;
  if (wasmUrl) {
    td_wasm = wasmUrl;
  }
  let module = createTdwebModule({
    onRuntimeInitialized: () => {
      log.info('runtime intialized');
      onFS(module.FS);
    },
    instantiateWasm: (imports, successCallback) => {
      log.info('start instantiateWasm', td_wasm, imports);
      const next = instance => {
        log.info('finish instantiateWasm');
        successCallback(instance);
      };
      instantiateAny(tdlibVersion, td_wasm, imports).then(next);
      return {};
    },
    ENVIROMENT: 'WORKER'
  });
  log.info('Wait module');
  module = await module;
  log.info('Got module', module);
  //onFS(module.FS);
  return module;
}

async function loadTdlibAsmjs(onFS) {
  console.log('loadTdlibAsmjs');
  const createTdwebModule = (await import('./prebuilt/release/td_asmjs.js'))
    .default;
  console.log('got td_asm.js', createTdwebModule);
  const fromFile = 'td_asmjs.js.mem';
  const toFile = td_asmjs_mem_release;
  let module = createTdwebModule({
    onRuntimeInitialized: () => {
      console.log('runtime intialized');
      onFS(module.FS);
    },
    locateFile: name => {
      if (name === fromFile) {
        return toFile;
      }
      return name;
    },
    ENVIROMENT: 'WORKER'
  });
  log.info('Wait module');
  module = await module;
  log.info('Got module', module);
  //onFS(module.FS);
  return module;
}

async function loadTdlib(mode, onFS, wasmUrl) {
  const wasmSupported = (() => {
    try {
      if (
        typeof WebAssembly === 'object' &&
        typeof WebAssembly.instantiate === 'function'
      ) {
        const module = new WebAssembly.Module(
          Uint8Array.of(0x0, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00)
        );
        if (module instanceof WebAssembly.Module)
          return (
            new WebAssembly.Instance(module) instanceof WebAssembly.Instance
          );
      }
    } catch (e) {}
    return false;
  })();
  if (!wasmSupported) {
    if (mode === 'wasm') {
      log.error('WebAssembly is not supported, trying to use it anyway');
    } else {
      log.warn('WebAssembly is not supported, trying to use asm.js');
      mode = 'asmjs';
    }
  }

  if (mode === 'asmjs') {
    return loadTdlibAsmjs(onFS);
  }
  return loadTdlibWasm(onFS, wasmUrl);
}

class OutboundFileSystem {
  constructor(root, FS) {
    this.root = root;
    this.nextFileId = 0;
    this.FS = FS;
    this.files = new Set();
    FS.mkdir(root);
  }
  blobToPath(blob, name) {
    const dir = this.root + '/' + this.nextFileId;
    if (!name) {
      name = 'blob';
    }
    this.nextFileId++;
    this.FS.mkdir(dir);
    this.FS.mount(
      this.FS.filesystems.WORKERFS,
      {
        blobs: [{ name: name, data: blob }]
      },
      dir
    );
    const path = dir + '/' + name;
    this.files.add(path);
    return path;
  }

  forgetPath(path) {
    if (this.files.has(path)) {
      this.FS.unmount(path);
      this.files.delete(path);
    }
  }
}

class InboundFileSystem {
  static async create(dbName, root, FS_promise) {
    const start = performance.now();
    try {
      const ifs = new InboundFileSystem();
      ifs.pending = [];
      ifs.pendingHasTimeout = false;
      ifs.persistCount = 0;
      ifs.persistSize = 0;
      ifs.pendingI = 0;
      ifs.inPersist = false;
      ifs.totalCount = 0;

      ifs.root = root;

      //ifs.store = localforage.createInstance({
      //name: dbName,
      //driver: localForageDrivers
      //});
      log.debug('IDB name: ' + dbName);
      ifs.idb = new Promise((resolve, reject) => {
        const request = indexedDB.open(dbName);
        request.onsuccess = () => resolve(request.result);
        request.onerror = () => reject(request.error);
        request.onupgradeneeded = () => {
          request.result.createObjectStore('keyvaluepairs');
        };
      });

      ifs.load_pids();

      const FS = await FS_promise;
      await ifs.idb;
      ifs.FS = FS;
      ifs.FS.mkdir(root);
      const create_time = (performance.now() - start) / 1000;
      log.debug('InboundFileSystem::create ' + create_time);
      return ifs;
    } catch (e) {
      log.error('Failed to init Inbound FileSystem: ', e);
    }
  }

  async load_pids() {
    const keys_start = performance.now();
    log.debug('InboundFileSystem::create::keys start');
    //const keys = await this.store.keys();

    let idb = await this.idb;
    let read = idb
      .transaction(['keyvaluepairs'], 'readonly')
      .objectStore('keyvaluepairs');
    const keys = await new Promise((resolve, reject) => {
      const request = read.getAllKeys();
      request.onsuccess = () => resolve(request.result);
      request.onerror = () => reject(request.error);
    });

    const keys_time = (performance.now() - keys_start) / 1000;
    log.debug(
      'InboundFileSystem::create::keys ' + keys_time + ' ' + keys.length
    );
    this.pids = new Set(keys);
  }

  has(pid) {
    if (!this.pids) {
      return true;
    }

    return this.pids.has(pid);
  }

  forget(pid) {
    if (this.pids) {
      this.pids.delete(pid);
    }
  }

  async doPersist(pid, path, arr, resolve, reject, write) {
    this.persistCount++;
    let size = arr.length;
    this.persistSize += size;
    try {
      //log.debug('persist.do start', pid, path, arr.length);
      //await this.store.setItem(pid, new Blob([arr]));
      await new Promise((resolve, reject) => {
        const request = write.put(new Blob([arr]), pid);
        request.onsuccess = () => resolve(request.result);
        request.onerror = () => reject(request.error);
      });
      if (this.pids) {
        this.pids.add(pid);
      }
      this.FS.unlink(path);
    } catch (e) {
      log.error('Failed persist ' + path + ' ', e);
    }
    //log.debug('persist.do finish', pid, path, arr.length);
    this.persistCount--;
    this.persistSize -= size;
    resolve();

    this.tryFinishPersist();
  }

  async flushPersist() {
    if (this.inPersist) {
      return;
    }
    log.debug('persist.flush');
    this.inPersist = true;
    let idb = await this.idb;
    this.writeBegin = performance.now();
    let write = idb
      .transaction(['keyvaluepairs'], 'readwrite')
      .objectStore('keyvaluepairs');
    while (
      this.pendingI < this.pending.length &&
      this.persistCount < 20 &&
      this.persistSize < 50 << 20
    ) {
      var q = this.pending[this.pendingI];
      this.pending[this.pendingI] = null;
      // TODO: add to transaction
      this.doPersist(q.pid, q.path, q.arr, q.resolve, q.reject, write);
      this.pendingI++;
      this.totalCount++;
    }
    log.debug(
      'persist.flush transaction cnt=' +
        this.persistCount +
        ', size=' +
        this.persistSize
    );
    this.inPersist = false;
    this.tryFinishPersist();
  }

  async tryFinishPersist() {
    if (this.inPersist) {
      return;
    }
    if (this.persistCount !== 0) {
      return;
    }
    log.debug('persist.finish ' + (performance.now() - this.writeBegin) / 1000);
    if (this.pendingI === this.pending.length) {
      this.pending = [];
      this.pendingHasTimeout = false;
      this.pendingI = 0;
      log.debug('persist.finish done');
      return;
    }
    log.debug('persist.finish continue');
    this.flushPersist();
  }

  async persist(pid, path, arr) {
    if (!this.pendingHasTimeout) {
      this.pendingHasTimeout = true;
      log.debug('persist set timeout');
      setTimeout(() => {
        this.flushPersist();
      }, 1);
    }
    await new Promise((resolve, reject) => {
      this.pending.push({
        pid: pid,
        path: path,
        arr: arr,
        resolve: resolve,
        reject: reject
      });
    });
  }

  async unlink(pid) {
    log.debug('Unlink ' + pid);
    try {
      this.forget(pid);
      //await this.store.removeItem(pid);
      let idb = await this.idb;
      await new Promise((resolve, reject) => {
        let write = idb
          .transaction(['keyvaluepairs'], 'readwrite')
          .objectStore('keyvaluepairs');
        const request = write.delete(pid);
        request.onsuccess = () => resolve(request.result);
        request.onerror = () => reject(request.error);
      });
    } catch (e) {
      log.error('Failed unlink ' + pid + ' ', e);
    }
  }
}

class DbFileSystem {
  static async create(root, FS_promise, readOnly = false) {
    const start = performance.now();
    try {
      const dbfs = new DbFileSystem();
      dbfs.root = root;
      const FS = await FS_promise;
      dbfs.FS = FS;
      dbfs.syncfs_total_time = 0;
      dbfs.readOnly = readOnly;
      dbfs.syncActive = 0;
      FS.mkdir(root);
      FS.mount(FS.filesystems.IDBFS, {}, root);

      await new Promise((resolve, reject) => {
        FS.syncfs(true, err => {
          resolve();
        });
      });

      const rmrf = path => {
        log.debug('rmrf ', path);
        let info;
        try {
          info = FS.lookupPath(path);
        } catch (e) {
          return;
        }
        log.debug('rmrf ', path, info);
        if (info.node.isFolder) {
          for (const key in info.node.contents) {
            rmrf(info.path + '/' + info.node.contents[key].name);
          }
          log.debug('rmdir ', path);
          FS.rmdir(path);
        } else {
          log.debug('unlink ', path);
          FS.unlink(path);
        }
      };
      //const dirs = ['thumbnails', 'profile_photos', 'secret', 'stickers', 'temp', 'wallpapers', 'secret_thumbnails', 'passport'];
      const dirs = [];
      const root_dir = FS.lookupPath(root);
      for (const key in root_dir.node.contents) {
        const value = root_dir.node.contents[key];
        log.debug('node ', key, value);
        if (!value.isFolder) {
          continue;
        }
        dirs.push(root_dir.path + '/' + value.name);
      }
      for (const i in dirs) {
        const dir = dirs[i];
        rmrf(dir);
        //FS.mkdir(dir);
        //FS.mount(FS.filesystems.MEMFS, {}, dir);
      }
      dbfs.syncfsInterval = setInterval(() => {
        dbfs.sync();
      }, 5000);
      const create_time = (performance.now() - start) / 1000;
      log.debug('DbFileSystem::create ' + create_time);
      return dbfs;
    } catch (e) {
      log.error('Failed to init DbFileSystem: ', e);
    }
  }
  async sync(force) {
    if (this.readOnly) {
      return;
    }
    if (this.syncActive > 0 && !force) {
      log.debug('SYNC: skip');
      return;
    }
    this.syncActive++;
    const start = performance.now();
    await new Promise((resolve, reject) => {
      this.FS.syncfs(false, () => {
        const syncfs_time = (performance.now() - start) / 1000;
        this.syncfs_total_time += syncfs_time;
        log.debug('SYNC: ' + syncfs_time);
        log.debug('SYNC total: ' + this.syncfs_total_time);
        resolve();
      });
    });
    this.syncActive--;
  }
  async close() {
    clearInterval(this.syncfsInterval);
    await this.sync(true);
  }
  async destroy() {
    clearInterval(this.syncfsInterval);
    if (this.readOnly) {
      return;
    }
    this.FS.unmount(this.root);
    const req = indexedDB.deleteDatabase(this.root);
    await new Promise((resolve, reject) => {
      req.onsuccess = function(e) {
        log.info('SUCCESS');
        resolve(e.result);
      };
      req.onerror = function(e) {
        log.info('ONERROR');
        reject(e.error);
      };
      req.onblocked = function(e) {
        log.info('ONBLOCKED');
        reject('blocked');
      };
    });
  }
}

class TdFileSystem {
  static async init_fs(prefix, FS_promise) {
    const FS = await FS_promise;
    FS.mkdir(prefix);
    return FS;
  }
  static async create(instanceName, FS_promise, readOnly = false) {
    try {
      const tdfs = new TdFileSystem();
      const prefix = '/' + instanceName;
      tdfs.prefix = prefix;
      FS_promise = TdFileSystem.init_fs(prefix, FS_promise);

      //MEMFS. Store to IDB and delete files as soon as possible
      const inboundFileSystem = InboundFileSystem.create(
        instanceName,
        prefix + '/inboundfs',
        FS_promise
      );

      //IDBFS. MEMFS which is flushed to IDB from time to time
      const dbFileSystem = DbFileSystem.create(
        prefix + '/dbfs',
        FS_promise,
        readOnly
      );

      const FS = await FS_promise;
      tdfs.FS = FS;

      //WORKERFS. Temporary stores Blobs for outbound files
      tdfs.outboundFileSystem = new OutboundFileSystem(
        prefix + '/outboundfs',
        tdfs.FS
      );

      tdfs.inboundFileSystem = await inboundFileSystem;
      tdfs.dbFileSystem = await dbFileSystem;
      return tdfs;
    } catch (e) {
      log.error('Failed to init TdFileSystem: ', e);
    }
  }
  async destroy() {
    await this.dbFileSystem.destroy();
  }
}

class TdClient {
  constructor(callback) {
    log.info('Start worker');
    this.pendingQueries = [];
    this.isPending = true;
    this.callback = callback;
    this.wasInit = false;
  }

  async testLocalForage() {
    await initLocalForage();
    const DRIVERS = [
      localforage.INDEXEDDB,
      'memoryDriver',
      localforage.LOCALSTORAGE,
      localforage.WEBSQL,
      localForageDrivers
    ];
    for (const driverName of DRIVERS) {
      console.log('Test ', driverName);
      try {
        await localforage.setDriver(driverName);
        console.log('A');
        await localforage.setItem('hello', 'world');
        console.log('B');
        const x = await localforage.getItem('hello');
        console.log('got ', x);
        await localforage.clear();
        console.log('C');
      } catch (error) {
        console.log('Error', error);
      }
    }
  }

  async init(options) {
    if (this.wasInit) {
      return;
    }
    //await this.testLocalForage();
    log.setVerbosity(options.jsLogVerbosityLevel);
    this.wasInit = true;

    options = options || {};
    const mode = options.mode || 'wasm';

    const FS_promise = new Promise(resolve => {
      this.onFS = resolve;
    });

    const tdfs_promise = TdFileSystem.create(
      options.instanceName,
      FS_promise,
      options.readOnly
    );

    this.useDatabase = true;
    if ('useDatabase' in options) {
      this.useDatabase = options.useDatabase;
    }

    log.info('load TdModule');
    this.TdModule = await loadTdlib(mode, this.onFS, options.wasmUrl);
    log.info('got TdModule');
    this.td_functions = {
      td_create: this.TdModule.cwrap(
        'td_emscripten_create_client_id',
        'number',
        []
      ),
      td_send: this.TdModule.cwrap('td_emscripten_send', null, [
        'number',
        'string'
      ]),
      td_execute: this.TdModule.cwrap('td_emscripten_execute', 'string', [
        'string'
      ]),
      td_receive: this.TdModule.cwrap('td_emscripten_receive', 'string', []),
      td_set_verbosity: verbosity => {
        this.td_functions.td_execute(
          JSON.stringify({
            '@type': 'setLogVerbosityLevel',
            new_verbosity_level: verbosity
          })
        );
      },
      td_get_timeout: this.TdModule.cwrap(
        'td_emscripten_get_timeout',
        'number',
        []
      )
    };
    //this.onFS(this.TdModule.FS);
    this.FS = this.TdModule.FS;
    this.TdModule['websocket']['on']('error', error => {
      this.scheduleReceiveSoon();
    });
    this.TdModule['websocket']['on']('open', fd => {
      this.scheduleReceiveSoon();
    });
    this.TdModule['websocket']['on']('listen', fd => {
      this.scheduleReceiveSoon();
    });
    this.TdModule['websocket']['on']('connection', fd => {
      this.scheduleReceiveSoon();
    });
    this.TdModule['websocket']['on']('message', fd => {
      this.scheduleReceiveSoon();
    });
    this.TdModule['websocket']['on']('close', fd => {
      this.scheduleReceiveSoon();
    });

    // wait till it is allowed to start
    this.callback({ '@type': 'inited' });
    await new Promise(resolve => {
      this.onStart = resolve;
    });
    this.isStarted = true;

    log.info('may start now');
    if (this.isClosing) {
      return;
    }
    log.info('FS start init');
    this.tdfs = await tdfs_promise;
    log.info('FS inited');
    this.callback({ '@type': 'fsInited' });

    // no async initialization after this point
    if (options.logVerbosityLevel === undefined) {
      options.logVerbosityLevel = 2;
    }
    this.td_functions.td_set_verbosity(options.logVerbosityLevel);
    this.client_id = this.td_functions.td_create();

    this.savingFiles = new Map();
    this.send({
      '@type': 'setOption',
      name: 'store_all_files_in_files_directory',
      value: {
        '@type': 'optionValueBoolean',
        value: true
      }
    });
    this.send({
      '@type': 'setOption',
      name: 'language_pack_database_path',
      value: {
        '@type': 'optionValueString',
        value: this.tdfs.dbFileSystem.root + '/language'
      }
    });
    this.send({
      '@type': 'setOption',
      name: 'ignore_background_updates',
      value: {
        '@type': 'optionValueBoolean',
        value: !this.useDatabase
      }
    });

    this.flushPendingQueries();

    this.receive();
  }

  prepareQueryRecursive(query) {
    if (query['@type'] === 'inputFileBlob') {
      return {
        '@type': 'inputFileLocal',
        path: this.tdfs.outboundFileSystem.blobToPath(query.data, query.name)
      };
    }
    for (const key in query) {
      const field = query[key];
      if (field && typeof field === 'object') {
        query[key] = this.prepareQueryRecursive(field);
      }
    }
    return query;
  }

  prepareQuery(query) {
    if (query['@type'] === 'setTdlibParameters') {
      query.database_directory = this.tdfs.dbFileSystem.root;
      query.files_directory = this.tdfs.inboundFileSystem.root;

      const useDb = this.useDatabase;
      query.use_file_database = useDb;
      query.use_chat_info_database = useDb;
      query.use_message_database = useDb;
      query.use_secret_chats = useDb;
    }
    if (query['@type'] === 'getLanguagePackString') {
      query.language_pack_database_path =
        this.tdfs.dbFileSystem.root + '/language';
    }
    return this.prepareQueryRecursive(query);
  }

  onStart() {
    //nop
    log.info('ignore on_start');
  }

  deleteIdbKey(query) {
    try {
    } catch (e) {
      this.callback({
        '@type': 'error',
        '@extra': query['@extra'],
        code: 400,
        message: e
      });
      return;
    }
    this.callback({
      '@type': 'ok',
      '@extra': query['@extra']
    });
  }

  readFilePart(query) {
    let res;
    try {
      //const file_size = this.FS.stat(query.path).size;
      const stream = this.FS.open(query.path, 'r');
      const buf = new Uint8Array(query.count);
      this.FS.read(stream, buf, 0, query.count, query.offset);
      this.FS.close(stream);
      res = buf;
    } catch (e) {
      this.callback({
        '@type': 'error',
        '@extra': query['@extra'],
        code: 400,
        message: e.toString()
      });
      return;
    }
    this.callback(
      {
        '@type': 'filePart',
        '@extra': query['@extra'],
        data: res
      },
      [res.buffer]
    );
  }

  send(query) {
    if (this.isClosing) {
      return;
    }
    if (this.wasFatalError) {
      if (query['@type'] === 'destroy') {
        this.destroy({ '@type': 'ok', '@extra': query['@extra'] });
      }
      return;
    }
    if (query['@type'] === 'init') {
      this.init(query.options);
      return;
    }
    if (query['@type'] === 'start') {
      log.info('on_start');
      this.onStart();
      return;
    }
    if (query['@type'] === 'setJsLogVerbosityLevel') {
      log.setVerbosity(query.new_verbosity_level);
      return;
    }
    if (this.isPending) {
      this.pendingQueries.push(query);
      return;
    }
    if (
      query['@type'] === 'setLogVerbosityLevel' ||
      query['@type'] === 'getLogVerbosityLevel' ||
      query['@type'] === 'setLogTagVerbosityLevel' ||
      query['@type'] === 'getLogTagVerbosityLevel' ||
      query['@type'] === 'getLogTags'
    ) {
      this.execute(query);
      return;
    }
    if (query['@type'] === 'readFilePart') {
      this.readFilePart(query);
      return;
    }
    if (query['@type'] === 'deleteIdbKey') {
      this.deleteIdbKey(query);
      return;
    }
    query = this.prepareQuery(query);
    this.td_functions.td_send(this.client_id, JSON.stringify(query));
    this.scheduleReceiveSoon();
  }

  execute(query) {
    try {
      const res = this.td_functions.td_execute(JSON.stringify(query));
      const response = JSON.parse(res);
      this.callback(response);
    } catch (error) {
      this.onFatalError(error);
    }
  }
  receive() {
    this.cancelReceive();
    if (this.wasFatalError) {
      return;
    }
    try {
      while (true) {
        const msg = this.td_functions.td_receive();
        if (!msg) {
          break;
        }
        const response = this.prepareResponse(JSON.parse(msg));
        if (
          response['@type'] === 'updateAuthorizationState' &&
          response.authorization_state['@type'] === 'authorizationStateClosed'
        ) {
          this.close(response);
          break;
        }
        this.callback(response);
      }

      this.scheduleReceive();
    } catch (error) {
      this.onFatalError(error);
    }
  }

  cancelReceive() {
    if (this.receiveTimeout) {
      clearTimeout(this.receiveTimeout);
      delete this.receiveTimeout;
    }
    delete this.receiveSoon;
  }
  scheduleReceiveSoon() {
    if (this.receiveSoon) {
      return;
    }
    this.cancelReceive();
    this.receiveSoon = true;
    this.scheduleReceiveIn(0.001);
  }
  scheduleReceive() {
    if (this.receiveSoon) {
      return;
    }
    this.cancelReceive();
    const timeout = this.td_functions.td_get_timeout();
    this.scheduleReceiveIn(timeout);
  }
  scheduleReceiveIn(timeout) {
    //return;
    log.debug('Scheduler receive in ' + timeout + 's');
    this.receiveTimeout = setTimeout(() => this.receive(), timeout * 1000);
  }

  onFatalError(error) {
    this.wasFatalError = true;
    this.asyncOnFatalError(error);
  }

  async close(last_update) {
    // close db and cancell all timers
    this.isClosing = true;
    if (this.isStarted) {
      log.debug('close worker: start');
      await this.tdfs.dbFileSystem.close();
      this.cancelReceive();
      log.debug('close worker: finish');
    }
    this.callback(last_update);
  }

  async destroy(result) {
    try {
      log.info('destroy tdfs ...');
      await this.tdfs.destroy();
      log.info('destroy tdfs ok');
    } catch (e) {
      log.error('Failed destroy', e);
    }
    this.callback(result);
    this.callback({
      '@type': 'updateAuthorizationState',
      authorization_state: {
        '@type': 'authorizationStateClosed'
      }
    });
  }

  async asyncOnFatalError(error) {
    await this.tdfs.dbFileSystem.sync();
    this.callback({ '@type': 'updateFatalError', error: error });
  }

  saveFile(pid, file) {
    const isSaving = this.savingFiles.has(pid);
    this.savingFiles.set(pid, file);
    if (isSaving) {
      return file;
    }
    try {
      const arr = this.FS.readFile(file.local.path);
      if (arr) {
        file = Object.assign({}, file);
        file.arr = arr;
        this.doSaveFile(pid, file, arr);
      }
    } catch (e) {
      log.error('Failed to readFile: ', e);
    }
    return file;
  }

  async doSaveFile(pid, file, arr) {
    await this.tdfs.inboundFileSystem.persist(pid, file.local.path, arr);
    file = this.savingFiles.get(pid);
    file.idb_key = pid;
    this.callback({ '@type': 'updateFile', file: file });

    this.savingFiles.delete(pid);
  }

  prepareFile(file) {
    const pid = file.remote.unique_id ? file.remote.unique_id : file.remote.id;
    if (!pid) {
      return file;
    }

    if (file.local.is_downloading_active) {
      this.tdfs.inboundFileSystem.forget(pid);
    } else if (this.tdfs.inboundFileSystem.has(pid)) {
      file.idb_key = pid;
      return file;
    }

    if (file.local.is_downloading_completed) {
      file = this.saveFile(pid, file);
    }
    return file;
  }

  prepareResponse(response) {
    if (response['@type'] === 'file') {
      return this.prepareFile(response);
    }
    for (const key in response) {
      const field = response[key];
      if (field && typeof field === 'object') {
        response[key] = this.prepareResponse(field);
      }
    }
    return response;
  }

  flushPendingQueries() {
    this.isPending = false;
    for (const query of this.pendingQueries) {
      this.send(query);
    }
  }
}

const client = new TdClient((e, t = []) => postMessage(e, t));

onmessage = function(e) {
  try {
    client.send(e.data);
  } catch (error) {
    client.onFatalError(error);
  }
};