import './polyfills';
import { differenceInDays } from 'date-fns';
import asyncStorage from '../platform/server/asyncStorage';
import { captureException, captureBreadcrumb } from '../platform/exceptions';
import * as prefs from './prefs';
import fs from '../platform/server/fs';
import * as sqlite from '../platform/server/sqlite';
import logger from '../platform/server/log';
import Platform from './platform';
import * as db from './db';
import * as sheet from './sheet';
import { withUndo, clearUndo, undo, redo } from './undo';
import { updateVersion } from './update';
import { Condition, Action, rankRules } from './accounts/rules';
import * as rules from './accounts/transaction-rules';
import * as mappings from './db/mappings';
import { batchUpdateTransactions } from './accounts/transactions';
import { FIELD_TYPES as ruleFieldTypes } from '../shared/rules';
import {
  getAvailableBackups,
  loadBackup,
  makeBackup,
  startBackupService,
  stopBackupService
} from './backups';
import { amountToInteger, stringToInteger } from '../shared/util';
import * as monthUtils from '../shared/months';
import { fromPlaidAccountType } from '../shared/accounts';
import * as budget from './budget/base';
import * as bankSync from './accounts/sync';
import * as link from './accounts/link';
import { uniqueFileName, idFromFileName } from './util/budget-name';
import { mutator, runHandler } from './mutators';
import * as timestamp from './timestamp';
import * as merkle from './merkle';
import {
  initialFullSync,
  fullSync,
  batchMessages,
  setSyncingMode,
  makeTestMessage,
  clearFullSyncTimeout,
  syncAndReceiveMessages,
  resetSync,
  repairSync
} from './sync';
import * as syncMigrations from './sync/migrate';
import { getStartingBalancePayee } from './accounts/payees';
import { parseFile } from './accounts/parse-file';
import { exportToCSV, exportQueryToCSV } from './accounts/export-to-csv';
import { getServer, setServer } from './server-config';
import installAPI from './api';
import injectAPI from '@actual-app/api/injected';
import * as cloudStorage from './cloud-storage';
import encryption from './encryption';
import * as tracking from './tracking/events';
import { get, post } from './post';
import { APIError, TransactionError, PostError, RuleError } from './errors';
import { createTestBudget } from '../mocks/budget';
import { runQuery as aqlQuery } from './aql/schema/run-query';
import { Query } from '../shared/query';
import q from '../shared/query';
import app from './main-app';

// Apps
import schedulesApp from './schedules/app';
import budgetApp from './budget/app';
import notesApp from './notes/app';
import toolsApp from './tools/app';

const YNAB4 = require('@actual-app/import-ynab4/importer');
const YNAB5 = require('@actual-app/import-ynab5/importer');
const uuid = require('../platform/uuid');
const connection = require('../platform/server/connection');
const { resolveName, unresolveName } = require('./spreadsheet/util');
const SyncPb = require('./sync/proto/sync_pb');

// let indexeddb = require('../platform/server/indexeddb');

let VERSION;
let DEMO_BUDGET_ID = '_demo-budget';
let TEST_BUDGET_ID = '_test-budget';
let UNCONFIGURED_SERVER = 'https://not-configured/';

// util

function onSheetChange({ names }) {
  const nodes = names.map(name => {
    let node = sheet.get()._getNode(name);
    return { name: node.name, value: node.value };
  });
  connection.send('cells-changed', nodes);
}

// handlers

export let handlers = {};

handlers['undo'] = mutator(async function() {
  return undo();
});

handlers['redo'] = mutator(function() {
  return redo();
});

handlers['transactions-batch-update'] = mutator(async function({
  added,
  deleted,
  updated,
  learnCategories
}) {
  return withUndo(async () => {
    let result = await batchUpdateTransactions({
      added,
      updated,
      deleted,
      learnCategories
    });

    // Return all data updates to the frontend
    return result.updated;
  });
});

handlers['transaction-add'] = mutator(async function(transaction) {
  await handlers['transactions-batch-update']({ added: [transaction] });
  return {};
});

handlers['transaction-update'] = mutator(async function(transaction) {
  await handlers['transactions-batch-update']({ updated: [transaction] });
  return {};
});

handlers['transaction-delete'] = mutator(async function(transaction) {
  await handlers['transactions-batch-update']({ deleted: [transaction] });
  return {};
});

handlers['transactions-filter'] = async function({
  term,
  accountId,
  latestDate,
  count,
  notPaged,
  options = {}
}) {
  return db.getTransactions(
    term,
    accountId,
    latestDate,
    notPaged ? null : count == null ? undefined : count,
    options
  );
};

handlers['transactions-parse-file'] = async function({ filepath, options }) {
  return parseFile(filepath, options);
};

handlers['transactions-export'] = async function({
  transactions,
  accounts,
  categoryGroups,
  payees
}) {
  return exportToCSV(transactions, accounts, categoryGroups, payees);
};

handlers['transactions-export-query'] = async function({ query: queryState }) {
  return exportQueryToCSV(new Query(queryState));
};

handlers['get-categories'] = async function() {
  return {
    grouped: await db.getCategoriesGrouped(),
    list: await db.getCategories()
  };
};

handlers['get-earliest-transaction'] = async function() {
  let { data } = await aqlQuery(
    q('transactions')
      .options({ splits: 'none' })
      .orderBy({ date: 'asc' })
      .select('*')
      .limit(1)
  );
  return data[0] || null;
};

handlers['get-budget-bounds'] = async function() {
  return budget.createAllBudgets();
};

handlers['rollover-budget-month'] = async function({ month }) {
  let groups = await db.getCategoriesGrouped();
  let sheetName = monthUtils.sheetForMonth(month);

  function value(name) {
    let v = sheet.getCellValue(sheetName, name);
    return { value: v === '' ? 0 : v, name: resolveName(sheetName, name) };
  }

  let values = [
    value('available-funds'),
    value('last-month-overspent'),
    value('buffered'),
    value('total-budgeted'),
    value('to-budget'),

    value('from-last-month'),
    value('total-income'),
    value('total-spent'),
    value('total-leftover')
  ];

  for (let group of groups) {
    if (group.is_income) {
      values.push(value('total-income'));

      for (let cat of group.categories) {
        values.push(value(`sum-amount-${cat.id}`));
      }
    } else {
      values = values.concat([
        value(`group-budget-${group.id}`),
        value(`group-sum-amount-${group.id}`),
        value(`group-leftover-${group.id}`)
      ]);

      for (let cat of group.categories) {
        values = values.concat([
          value(`budget-${cat.id}`),
          value(`sum-amount-${cat.id}`),
          value(`leftover-${cat.id}`),
          value(`carryover-${cat.id}`)
        ]);
      }
    }
  }

  return values;
};

handlers['report-budget-month'] = async function({ month }) {
  let groups = await db.getCategoriesGrouped();
  let sheetName = monthUtils.sheetForMonth(month);

  function value(name) {
    let v = sheet.getCellValue(sheetName, name);
    return { value: v === '' ? 0 : v, name: resolveName(sheetName, name) };
  }

  let values = [
    value('total-budgeted'),
    value('total-budget-income'),
    value('total-saved'),
    value('total-income'),
    value('total-spent'),
    value('real-saved'),
    value('total-leftover')
  ];

  for (let group of groups) {
    values = values.concat([
      value(`group-budget-${group.id}`),
      value(`group-sum-amount-${group.id}`),
      value(`group-leftover-${group.id}`)
    ]);

    for (let cat of group.categories) {
      values = values.concat([
        value(`budget-${cat.id}`),
        value(`sum-amount-${cat.id}`),
        value(`leftover-${cat.id}`)
      ]);

      if (!group.is_income) {
        values.push(value(`carryover-${cat.id}`));
      }
    }
  }

  return values;
};

handlers['budget-set-type'] = async function({ type }) {
  if (type !== 'rollover' && type !== 'report') {
    throw new Error('Invalid budget type: ' + type);
  }

  // It's already the same; don't do anything
  if (type === prefs.getPrefs().budgetType) {
    return;
  }

  // Save prefs
  return prefs.savePrefs({ budgetType: type });
};

handlers['category-create'] = mutator(async function({
  name,
  groupId,
  isIncome
}) {
  return withUndo(async () => {
    if (!groupId) {
      throw APIError('Creating a category: groupId is required');
    }

    return db.insertCategory({
      name,
      cat_group: groupId,
      is_income: isIncome ? 1 : 0
    });
  });
});

handlers['category-update'] = mutator(async function(category) {
  return withUndo(async () => {
    try {
      await db.updateCategory(category);
    } catch (e) {
      if (e.message.toLowerCase().includes('unique constraint')) {
        return { error: { type: 'category-exists' } };
      }
      throw e;
    }
    return {};
  });
});

handlers['category-move'] = mutator(async function({ id, groupId, targetId }) {
  return withUndo(async () => {
    await batchMessages(async () => {
      await db.moveCategory(id, groupId, targetId);
    });
    return 'ok';
  });
});

handlers['category-delete'] = mutator(async function({ id, transferId }) {
  return withUndo(async () => {
    let result = {};
    await batchMessages(async () => {
      let row = await db.first(
        'SELECT is_income FROM categories WHERE id = ?',
        [id]
      );
      if (!row) {
        result = { error: 'no-categories' };
        return;
      }

      let transfer =
        transferId &&
        (await db.first('SELECT is_income FROM categories WHERE id = ?', [
          transferId
        ]));

      if (!row || (transferId && !transfer)) {
        result = { error: 'no-categories' };
        return;
      } else if (transferId && row.is_income !== transfer.is_income) {
        result = { error: 'category-type' };
        return;
      }

      // Update spreadsheet values if it's an expense category
      // TODO: We should do this for income too if it's a reflect budget
      if (row.is_income === 0) {
        if (transferId) {
          await budget.doTransfer([id], transferId);
        }
      }

      await db.deleteCategory({ id }, transferId);
    });

    return result;
  });
});

handlers['category-group-create'] = mutator(async function({ name, isIncome }) {
  return withUndo(async () => {
    return db.insertCategoryGroup({
      name,
      is_income: isIncome ? 1 : 0
    });
  });
});

handlers['category-group-update'] = mutator(async function(group) {
  return withUndo(async () => {
    return db.updateCategoryGroup(group);
  });
});

handlers['category-group-move'] = mutator(async function({ id, targetId }) {
  return withUndo(async () => {
    await batchMessages(async () => {
      await db.moveCategoryGroup(id, targetId);
    });
    return 'ok';
  });
});

handlers['category-group-delete'] = mutator(async function({ id, transferId }) {
  return withUndo(async () => {
    const groupCategories = await db.all(
      'SELECT id FROM categories WHERE cat_group = ? AND tombstone = 0',
      [id]
    );

    return batchMessages(async () => {
      if (transferId) {
        await budget.doTransfer(groupCategories.map(c => c.id), transferId);
      }
      await db.deleteCategoryGroup({ id }, transferId);
    });
  });
});

handlers['must-category-transfer'] = async function({ id }) {
  const res = await db.runQuery(
    `SELECT count(t.id) as count FROM transactions t
       LEFT JOIN category_mapping cm ON cm.id = t.category
       WHERE cm.transferId = ? AND t.tombstone = 0`,
    [id],
    true
  );

  // If there are transactions with this category, return early since
  // we already know it needs to be tranferred
  if (res[0].count !== 0) {
    return true;
  }

  // If there are any non-zero budget values, also force the user to
  // transfer the category.
  return [...sheet.get().meta().createdMonths].some(month => {
    const sheetName = monthUtils.sheetForMonth(month);
    const value = sheet.get().getCellValue(sheetName, 'budget-' + id);

    return value !== 0;
  });
};

handlers['payee-create'] = mutator(async function({ name }) {
  return withUndo(async () => {
    return db.insertPayee({ name });
  });
});

handlers['payees-get'] = async function() {
  return db.getPayees();
};

handlers['payees-get-rule-counts'] = async function() {
  let payeeCounts = {};
  let allRules = rules.getRules();

  rules.iterateIds(rules.getRules(), 'payee', (rule, id) => {
    if (payeeCounts[id] == null) {
      payeeCounts[id] = 0;
    }
    payeeCounts[id]++;
  });

  return payeeCounts;
};

handlers['payees-merge'] = mutator(async function({ targetId, mergeIds }) {
  return withUndo(
    async () => {
      return db.mergePayees(targetId, mergeIds);
    },
    { targetId, mergeIds }
  );
});

handlers['payees-batch-change'] = mutator(async function({
  added,
  deleted,
  updated
}) {
  return withUndo(async () => {
    return batchMessages(async () => {
      if (deleted) {
        await Promise.all(deleted.map(p => db.deletePayee(p)));
      }

      if (added) {
        await Promise.all(added.map(p => db.insertPayee(p)));
      }

      if (updated) {
        await Promise.all(updated.map(p => db.updatePayee(p)));
      }
    });
  });
});

handlers['payees-check-orphaned'] = async function({ ids }) {
  let orphaned = new Set(await db.getOrphanedPayees());
  return ids.filter(id => orphaned.has(id));
};

handlers['payees-get-rules'] = async function({ id }) {
  return rules.getRulesForPayee(id).map(rule => rule.serialize());
};

handlers['payees-delete-rule'] = mutator(async function({ id, payee_id }) {
  return withUndo(
    async () => {
      return await db.deletePayeeRule({ id });
    },
    { payeeId: payee_id }
  );
});

handlers['payees-update-rule'] = mutator(async function(rule) {
  return withUndo(
    async () => {
      return await db.updatePayeeRule(rule);
    },
    { payeeId: rule.payee_id }
  );
});

handlers['payees-add-rule'] = mutator(async function(rule) {
  return withUndo(
    async () => {
      let id = await db.insertPayeeRule(rule);
      return { ...rule, id };
    },
    { payeeId: rule.payee_id }
  );
});

function validateRule(rule) {
  // Returns an array of errors, the array is the same link as the
  // passed-in `array`, or null if there are no errors
  function runValidation(array, validate) {
    let result = array.map(item => {
      try {
        validate(item);
      } catch (e) {
        if (e instanceof RuleError) {
          console.warn('Invalid rule', e);
          return e.type;
        }
        throw e;
      }
      return null;
    });

    return result.some(Boolean) ? result : null;
  }

  let conditionErrors = runValidation(
    rule.conditions,
    cond =>
      new Condition(
        cond.op,
        cond.field,
        cond.value,
        cond.options,
        ruleFieldTypes
      )
  );

  let actionErrors = runValidation(
    rule.actions,
    action =>
      new Action(
        action.op,
        action.field,
        action.value,
        action.options,
        ruleFieldTypes
      )
  );

  if (conditionErrors || actionErrors) {
    return {
      conditionErrors,
      actionErrors
    };
  }

  return null;
}

handlers['rule-validate'] = async function(rule) {
  let error = validateRule(rule);
  return { error };
};

handlers['rule-add'] = mutator(async function(rule) {
  let error = validateRule(rule);
  if (error) {
    return { error };
  }

  let id = await rules.insertRule(rule);
  return { id };
});

handlers['rule-update'] = mutator(async function(rule) {
  let error = validateRule(rule);
  if (error) {
    return { error };
  }

  await rules.updateRule(rule);
  return {};
});

handlers['rule-delete'] = mutator(async function(rule) {
  return rules.deleteRule(rule);
});

handlers['rule-delete-all'] = mutator(async function(ids) {
  let someDeletionsFailed = false;

  await batchMessages(async () => {
    for (let id of ids) {
      let res = await rules.deleteRule({ id });
      if (res === false) {
        someDeletionsFailed = true;
      }
    }
  });

  return { someDeletionsFailed };
});

handlers['rule-apply-actions'] = mutator(async function({
  transactionIds,
  actions
}) {
  return rules.applyActions(transactionIds, actions, handlers);
});

handlers['rule-add-payee-rename'] = mutator(async function({ fromNames, to }) {
  return rules.updatePayeeRenameRule(fromNames, to);
});

handlers['rules-get'] = async function() {
  return rankRules(rules.getRules()).map(rule => rule.serialize());
};

handlers['rule-get'] = async function({ id }) {
  let rule = rules.getRules().find(rule => rule.id === id);
  return rule ? rule.serialize() : null;
};

handlers['rules-run'] = async function({ transaction }) {
  return rules.runRules(transaction);
};

handlers['rules-migrate'] = async function() {
  await rules.migrateOldRules();
};

handlers['make-filters-from-conditions'] = async function({ conditions }) {
  return rules.conditionsToAQL(conditions);
};

handlers['getCell'] = async function({ sheetName, name }) {
  // Fields is no longer used - hardcode
  let fields = ['name', 'value'];
  let node = sheet.get()._getNode(resolveName(sheetName, name));
  if (fields) {
    let res = {};
    fields.forEach(field => {
      if (field === 'run') {
        res[field] = node._run ? node._run.toString() : null;
      } else {
        res[field] = node[field];
      }
    });
    return res;
  } else {
    return node;
  }
};

handlers['getCells'] = async function({ names }) {
  return names.map(name => ({ value: sheet.get()._getNode(name).value }));
};

handlers['getCellNamesInSheet'] = async function({ sheetName }) {
  let names = [];
  for (let name of sheet
    .get()
    .getNodes()
    .keys()) {
    let { sheet: nodeSheet, name: nodeName } = unresolveName(name);
    if (nodeSheet === sheetName) {
      names.push(nodeName);
    }
  }
  return names;
};

handlers['debugCell'] = async function({ sheetName, name }) {
  let node = sheet.get().getNode(resolveName(sheetName, name));
  return {
    ...node,
    _run: node._run && node._run.toString()
  };
};

handlers['create-query'] = async function({ sheetName, name, query }) {
  // Always run it regardless of cache. We don't know anything has changed
  // between the cache value being saved and now
  sheet.get().createQuery(sheetName, name, query);
  return 'ok';
};

handlers['query'] = async function(query) {
  if (query.table == null) {
    throw new Error('query has no table, did you forgot to call `.serialize`?');
  }

  return aqlQuery(query);
};

handlers['bank-delete'] = async function({ id }) {
  const accts = await db.runQuery(
    'SELECT * FROM accounts WHERE bank = ?',
    [id],
    true
  );

  await db.delete_('banks', id);
  await Promise.all(
    accts.map(async acct => {
      // TODO: This will not sync across devices because we are bypassing
      // the "recorded" functions
      await db.runQuery('DELETE FROM transactions WHERE acct = ?', [acct.id]);
      await db.delete_('accounts', acct.id);
    })
  );
  return 'ok';
};

handlers['account-update'] = mutator(async function({ id, name }) {
  return withUndo(async () => {
    await db.update('accounts', { id, name });
    return {};
  });
});

handlers['accounts-get'] = async function() {
  return db.getAccounts();
};

handlers['account-properties'] = async function({ id }) {
  const { balance } = await db.first(
    'SELECT sum(amount) as balance FROM transactions WHERE acct = ? AND isParent = 0 AND tombstone = 0',
    [id]
  );
  const { count } = await db.first(
    'SELECT count(id) as count FROM transactions WHERE acct = ? AND tombstone = 0',
    [id]
  );

  return { balance: balance || 0, numTransactions: count };
};

handlers['accounts-link'] = async function({
  institution,
  publicToken,
  accountId,
  upgradingId
}) {
  let bankId = await link.handoffPublicToken(institution, publicToken);

  let [[, userId], [, userKey]] = await asyncStorage.multiGet([
    'user-id',
    'user-key'
  ]);

  // Get all the available accounts and find the selected one
  let accounts = await bankSync.getAccounts(userId, userKey, bankId);
  let account = accounts.find(acct => acct.account_id === accountId);

  await db.update('accounts', {
    id: upgradingId,
    account_id: account.account_id,
    official_name: account.official_name,
    type: fromPlaidAccountType(account.type),
    balance_current: amountToInteger(account.balances.current),
    balance_available: amountToInteger(account.balances.available),
    balance_limit: amountToInteger(account.balances.limit),
    mask: account.mask,
    bank: bankId
  });

  await bankSync.syncAccount(
    userId,
    userKey,
    upgradingId,
    account.account_id,
    bankId
  );

  connection.send('sync-event', {
    type: 'success',
    tables: ['transactions']
  });

  return 'ok';
};

handlers['accounts-connect'] = async function({
  institution,
  publicToken,
  accountIds,
  offbudgetIds
}) {
  let bankId = await link.handoffPublicToken(institution, publicToken);
  let ids = await link.addAccounts(bankId, accountIds, offbudgetIds);
  return ids;
};

handlers['account-create'] = mutator(async function({
  name,
  type,
  balance,
  offBudget,
  closed
}) {
  return withUndo(async () => {
    const id = await db.insertAccount({
      name,
      type,
      offbudget: offBudget ? 1 : 0,
      closed: closed ? 1 : 0
    });

    await db.insertPayee({
      name: '',
      transfer_acct: id
    });

    if (balance != null) {
      let payee = await getStartingBalancePayee();

      await db.insertTransaction({
        account: id,
        amount: amountToInteger(balance),
        category: offBudget ? null : payee.category,
        payee: payee.id,
        date: monthUtils.currentDay(),
        cleared: true,
        starting_balance_flag: true
      });
    }

    return id;
  });
});

handlers['account-close'] = mutator(async function({
  id,
  transferAccountId,
  categoryId,
  forced
}) {
  // Unlink the account if it's linked. This makes sure to remove it
  // from Plaid. (This should not be undo-able, as it mutates the
  // remote server and the user will have to link the account again)
  await handlers['account-unlink']({ id });

  return withUndo(async () => {
    let account = await db.first(
      'SELECT * FROM accounts WHERE id = ? AND tombstone = 0',
      [id]
    );

    // Do nothing if the account doesn't exist or it's already been
    // closed
    if (!account || account.closed === 1) {
      return;
    }

    const { balance, numTransactions } = await handlers['account-properties']({
      id
    });

    // If there are no transactions, we can simply delete the account
    if (numTransactions === 0) {
      await db.deleteAccount({ id });
    } else if (forced) {
      let rows = await db.runQuery(
        'SELECT id, transfer_id FROM v_transactions WHERE account = ?',
        [id],
        true
      );

      let { id: payeeId } = await db.first(
        'SELECT id FROM payees WHERE transfer_acct = ?',
        [id]
      );

      await batchMessages(() => {
        // TODO: what this should really do is send a special message that
        // automatically marks the tombstone value for all transactions
        // within an account... or something? This is problematic
        // because another client could easily add new data that
        // should be marked as deleted.

        rows.forEach(row => {
          if (row.transfer_id) {
            db.updateTransaction({
              id: row.transfer_id,
              payee: null,
              transfer_id: null
            });
          }

          db.deleteTransaction({ id: row.id });
        });

        db.deleteAccount({ id });
        db.deleteTransferPayee({ id: payeeId });
      });
    } else {
      if (balance !== 0 && transferAccountId == null) {
        throw APIError('balance is non-zero: transferAccountId is required');
      }

      await db.update('accounts', { id, closed: 1 });

      // If there is a balance we need to transfer it to the specified
      // account (and possibly categorize it)
      if (balance !== 0) {
        let { id: payeeId } = await db.first(
          'SELECT id FROM payees WHERE transfer_acct = ?',
          [transferAccountId]
        );

        await handlers['transaction-add']({
          id: uuid.v4Sync(),
          payee: payeeId,
          amount: -balance,
          account: id,
          date: monthUtils.currentDay(),
          notes: 'Closing account',
          category: categoryId || null
        });
      }
    }
  });
});

handlers['account-reopen'] = mutator(async function({ id }) {
  return withUndo(async () => {
    await db.update('accounts', { id, closed: 0 });
  });
});

handlers['account-move'] = mutator(async function({ id, targetId }) {
  return withUndo(async () => {
    await db.moveAccount(id, targetId);
  });
});

let stopPolling = false;

handlers['poll-web-token'] = async function({ token }) {
  let [[, userId], [, key]] = await asyncStorage.multiGet([
    'user-id',
    'user-key'
  ]);

  let startTime = Date.now();
  stopPolling = false;

  async function getData(cb) {
    if (stopPolling) {
      return;
    }

    if (Date.now() - startTime >= 1000 * 60 * 10) {
      cb('timeout');
      return;
    }

    let data = await post(
      getServer().PLAID_SERVER + '/get-web-token-contents',
      {
        userId,
        key,
        token
      }
    );

    if (data) {
      if (data.error) {
        cb('unknown');
      } else {
        cb(null, data);
      }
    } else {
      setTimeout(() => getData(cb), 3000);
    }
  }

  return new Promise(resolve => {
    getData((error, data) => {
      if (error) {
        resolve({ error });
      } else {
        resolve({ data });
      }
    });
  });
};

handlers['poll-web-token-stop'] = async function() {
  stopPolling = true;
  return 'ok';
};

handlers['accounts-sync'] = async function({ id }) {
  let [[, userId], [, userKey]] = await asyncStorage.multiGet([
    'user-id',
    'user-key'
  ]);
  let accounts = await db.runQuery(
    `SELECT a.*, b.id as bankId FROM accounts a
         LEFT JOIN banks b ON a.bank = b.id
         WHERE a.tombstone = 0 AND a.closed = 0`,
    [],
    true
  );

  if (id) {
    accounts = accounts.filter(acct => acct.id === id);
  }

  let errors = [];
  let newTransactions = [];
  let matchedTransactions = [];
  let updatedAccounts = [];

  let { groupId } = prefs.getPrefs();

  for (var i = 0; i < accounts.length; i++) {
    const acct = accounts[i];
    if (acct.bankId) {
      try {
        const res = await bankSync.syncAccount(
          userId,
          userKey,
          acct.id,
          acct.account_id,
          acct.bankId
        );
        let { added, updated } = res;

        newTransactions = newTransactions.concat(added);
        matchedTransactions = matchedTransactions.concat(updated);

        if (added.length > 0 || updated.length > 0) {
          updatedAccounts = updatedAccounts.concat(acct.id);
        }
      } catch (err) {
        if (err.type === 'BankSyncError') {
          errors.push({
            type: 'SyncError',
            accountId: acct.id,
            message: 'Failed syncing account "' + acct.name + '".',
            category: err.category,
            code: err.code
          });
        } else if (err instanceof PostError && err.reason !== 'internal') {
          errors.push({
            accountId: acct.id,
            message: `Account "${
              acct.name
            }" is not linked properly. Please link it again`
          });
        } else {
          errors.push({
            accountId: acct.id,
            message:
              'There was an internal error. Please email help@actualbudget.com for support.',
            internal: err.stack
          });

          err.message = 'Failed syncing account: ' + err.message;

          captureException(err);
        }
      }
    }
  }

  if (updatedAccounts.length > 0) {
    connection.send('sync-event', {
      type: 'success',
      tables: ['transactions']
    });
  }

  return { errors, newTransactions, matchedTransactions, updatedAccounts };
};

handlers['transactions-import'] = mutator(function({
  accountId,
  transactions
}) {
  return withUndo(async () => {
    if (typeof accountId !== 'string') {
      throw APIError('transactions-import: accountId must be an id');
    }

    try {
      return await bankSync.reconcileTransactions(accountId, transactions);
    } catch (err) {
      if (err instanceof TransactionError) {
        return { errors: [{ message: err.message }], added: [], updated: [] };
      }

      throw err;
    }
  });
});

handlers['account-unlink'] = mutator(async function({ id }) {
  let { bank: bankId } = await db.first(
    'SELECT bank FROM accounts WHERE id = ?',
    [id]
  );

  if (!bankId) {
    return 'ok';
  }

  await db.updateAccount({
    id,
    account_id: null,
    bank: null,
    balance_current: null,
    balance_available: null,
    balance_limit: null
  });

  let { count } = await db.first(
    'SELECT COUNT(*) as count FROM accounts WHERE bank = ?',
    [bankId]
  );

  if (count === 0) {
    // No more accounts are associated with this bank. We can remove
    // it from Plaid.

    let [[, userId], [, key]] = await asyncStorage.multiGet([
      'user-id',
      'user-key'
    ]);

    await post(getServer().PLAID_SERVER + '/remove-access-token', {
      userId,
      key,
      item_id: bankId
    });
  }

  return 'ok';
});

handlers['make-plaid-public-token'] = async function({ bankId }) {
  let [[, userId], [, userKey]] = await asyncStorage.multiGet([
    'user-id',
    'user-key'
  ]);

  let data = await post(getServer().PLAID_SERVER + '/make-public-token', {
    userId: userId,
    key: userKey,
    item_id: '' + bankId
  });

  if (data.error_code) {
    return { error: '', code: data.error_code, type: data.error_type };
  }

  return { linkToken: data.link_token };
};

handlers['save-global-prefs'] = async function(prefs) {
  if ('maxMonths' in prefs) {
    await asyncStorage.setItem('max-months', '' + prefs.maxMonths);
  }
  if ('trackUsage' in prefs) {
    tracking.toggle(prefs.trackUsage);
    await asyncStorage.setItem('track-usage', '' + prefs.trackUsage);
  }
  if ('autoUpdate' in prefs) {
    await asyncStorage.setItem('auto-update', '' + prefs.autoUpdate);
    process.send({ type: 'shouldAutoUpdate', flag: prefs.autoUpdate });
  }
  if ('documentDir' in prefs) {
    if (await fs.exists(prefs.documentDir)) {
      await asyncStorage.setItem('document-dir', prefs.documentDir);
    }
  }
  if ('floatingSidebar' in prefs) {
    await asyncStorage.setItem('floating-sidebar', '' + prefs.floatingSidebar);
  }
  return 'ok';
};

handlers['load-global-prefs'] = async function() {
  let [
    [, floatingSidebar],
    [, seenTutorial],
    [, maxMonths],
    [, trackUsage],
    [, autoUpdate],
    [, documentDir],
    [, encryptKey]
  ] = await asyncStorage.multiGet([
    'floating-sidebar',
    'seen-tutorial',
    'max-months',
    'track-usage',
    'auto-update',
    'document-dir',
    'encrypt-key'
  ]);
  return {
    floatingSidebar: floatingSidebar === 'true' ? true : false,
    seenTutorial: seenTutorial === 'true' ? true : false,
    maxMonths: stringToInteger(maxMonths || ''),
    // Default to true
    trackUsage: trackUsage == null || trackUsage === 'true' ? true : false,
    autoUpdate: autoUpdate == null || autoUpdate === 'true' ? true : false,
    documentDir: documentDir || getDefaultDocumentDir(),
    keyId: encryptKey && JSON.parse(encryptKey).id
  };
};

handlers['save-prefs'] = async function(prefsToSet) {
  let { cloudFileId } = prefs.getPrefs();

  // Need to sync the budget name on the server as well
  if (prefsToSet.budgetName && cloudFileId) {
    let userToken = await asyncStorage.getItem('user-token');

    await post(getServer().SYNC_SERVER + '/update-user-filename', {
      token: userToken,
      fileId: cloudFileId,
      name: prefsToSet.budgetName
    });
  }

  await prefs.savePrefs(prefsToSet);
  return 'ok';
};

handlers['load-prefs'] = async function() {
  return prefs.getPrefs();
};

handlers['sync-reset'] = async function() {
  return await resetSync();
};

handlers['sync-repair'] = async function() {
  await repairSync();
};

// A user can only enable/change their key with the file loaded. This
// will change in the future: during onboarding the user should be
// able to enable encryption. (Imagine if they are importing data from
// another source, they should be able to encrypt first)
handlers['key-make'] = async function({ password }) {
  if (!prefs.getPrefs()) {
    throw new Error('user-set-key must be called with file loaded');
  }

  let cloudFileId = prefs.getPrefs().cloudFileId;

  let salt = encryption.randomBytes(32).toString('base64');
  let id = uuid.v4Sync();
  let key = await encryption.createKey({ id, password, salt });

  // Load the key
  await encryption.loadKey(key);

  // Make some test data to use if the key is valid or not
  let testContent = await makeTestMessage(key.getId());

  // Changing your key necessitates a sync reset as well. This will
  // clear all existing encrypted data from the server so you won't
  // have a mix of data encrypted with different keys.
  return await resetSync({
    key,
    salt,
    testContent: JSON.stringify({
      ...testContent,
      value: testContent.value.toString('base64')
    })
  });
};

// This can be called both while a file is already loaded or not. This
// will see if a key is valid and if so save it off.
handlers['key-test'] = async function({ fileId, password }) {
  let userToken = await asyncStorage.getItem('user-token');

  if (fileId == null) {
    fileId = prefs.getPrefs().cloudFileId;
  }

  let res;
  try {
    res = await post(getServer().SYNC_SERVER + '/user-get-key', {
      token: userToken,
      fileId
    });
  } catch (e) {
    console.log(e);
    return { error: { reason: 'network' } };
  }

  let { id, salt, test } = res;

  if (test == null) {
    return { error: { reason: 'old-key-style' } };
  }

  test = JSON.parse(test);

  let key = await encryption.createKey({ id, password, salt });
  encryption.loadKey(key);

  try {
    await encryption.decrypt(Buffer.from(test.value, 'base64'), test.meta);
  } catch (e) {
    console.log(e);

    // Unload the key, it's invalid
    encryption.unloadKey(key);
    return { error: { reason: 'decrypt-failure' } };
  }

  // Persist key in async storage
  let keys = JSON.parse((await asyncStorage.getItem(`encrypt-keys`)) || '{}');
  keys[fileId] = key.serialize();
  await asyncStorage.setItem('encrypt-keys', JSON.stringify(keys));

  // Save the key id in prefs if the are loaded. If they aren't, we
  // are testing a key to download a file and when the file is
  // actually downloaded it will update the prefs with the latest key id
  if (prefs.getPrefs()) {
    await prefs.savePrefs({ encryptKeyId: key.getId() });
  }

  return {};
};

handlers['should-pitch-subscribe'] = async function() {
  let seenSubscribe = await asyncStorage.getItem('seenSubscribe');
  return seenSubscribe !== 'true';
};

handlers['has-pitched-subscribe'] = async function() {
  await asyncStorage.setItem('seenSubscribe', 'true');
  return 'ok';
};

handlers['subscribe-needs-bootstrap'] = async function({ url } = {}) {
  if (getServer(url).BASE_SERVER === UNCONFIGURED_SERVER) {
    return { bootstrapped: true };
  }

  let res;
  try {
    res = await get(getServer(url).SIGNUP_SERVER + '/needs-bootstrap');
  } catch (err) {
    return { error: 'network-failure' };
  }

  try {
    res = JSON.parse(res);
  } catch (err) {
    return { error: 'parse-failure' };
  }

  if (res.status === 'error') {
    return { error: res.reason };
  }

  return { bootstrapped: res.data.bootstrapped };
};

handlers['subscribe-bootstrap'] = async function({ password }) {
  let res;
  try {
    res = await post(getServer().SIGNUP_SERVER + '/bootstrap', { password });
  } catch (err) {
    return { error: err.reason || 'network-failure' };
  }

  if (res.token) {
    await asyncStorage.setItem('user-token', res.token);
    return {};
  }
  return { error: 'internal' };
};

handlers['subscribe-set-user'] = async function({ token }) {
  await asyncStorage.setItem('user-token', token);
};

handlers['subscribe-get-user'] = async function() {
  if (getServer() && getServer().BASE_SERVER === UNCONFIGURED_SERVER) {
    return { offline: false };
  }

  let userToken = await asyncStorage.getItem('user-token');

  if (userToken) {
    try {
      let res = await get(getServer().SIGNUP_SERVER + '/validate', {
        headers: {
          'X-ACTUAL-TOKEN': userToken
        }
      });
      res = JSON.parse(res);

      if (res.status === 'error') {
        if (res.reason === 'unauthorized') {
          return null;
        }
        return { offline: true };
      }

      return { offline: false };
    } catch (e) {
      console.log(e);
      return { offline: true };
    }
  }

  return null;
};

handlers['subscribe-change-password'] = async function({ password }) {
  let userToken = await asyncStorage.getItem('user-token');
  let res;
  try {
    res = await post(getServer().SIGNUP_SERVER + '/change-password', {
      token: userToken,
      password
    });
  } catch (err) {
    return { error: err.reason || 'network-failure' };
  }

  return {};
};

handlers['subscribe-sign-in'] = async function({ password }) {
  let res = await post(getServer().SIGNUP_SERVER + '/login', {
    password
  });

  if (res.token) {
    await asyncStorage.setItem('user-token', res.token);
    return {};
  }

  return { error: 'invalid-password' };
};

handlers['subscribe-sign-out'] = async function() {
  encryption.unloadAllKeys();
  await asyncStorage.multiRemove([
    'user-token',
    'encrypt-keys',
    'lastBudget',
    'readOnly'
  ]);
  return 'ok';
};

handlers['get-server-url'] = async function() {
  return getServer() && getServer().BASE_SERVER;
};

handlers['set-server-url'] = async function({ url }) {
  if (url != null) {
    // Validate the server is running
    let { error } = await runHandler(handlers['subscribe-needs-bootstrap'], {
      url
    });
    if (error) {
      return { error };
    }
  } else {
    // When the server isn't configured, we just use a placeholder
    url = UNCONFIGURED_SERVER;
  }

  asyncStorage.setItem('server-url', url);
  setServer(url);
  return {};
};

handlers['sync'] = async function() {
  return fullSync();
};

handlers['get-version'] = async function() {
  return { version: VERSION };
};

handlers['get-budgets'] = async function() {
  const paths = await fs.listDir(fs.getDocumentDir());
  const budgets = (await Promise.all(
    paths.map(async name => {
      const prefsPath = fs.join(fs.getDocumentDir(), name, 'metadata.json');
      if (await fs.exists(prefsPath)) {
        let prefs;
        try {
          prefs = JSON.parse(await fs.readFile(prefsPath));
        } catch (e) {
          console.log('Error parsing metadata:', e.stack);
          return;
        }

        // We treat the directory name as the canonical id so that if
        // the user moves it around/renames/etc, nothing breaks. The
        // id is stored in prefs just for convenience (and the prefs
        // will always update to the latest given id)
        if (name !== DEMO_BUDGET_ID) {
          return {
            id: name,
            cloudFileId: prefs.cloudFileId,
            groupId: prefs.groupId,
            name: prefs.budgetName || '(no name)'
          };
        }
      }

      return null;
    })
  )).filter(x => x);

  return budgets;
};

handlers['get-ynab4-files'] = async function() {
  return YNAB4.findBudgets();
};

handlers['get-remote-files'] = async function() {
  return cloudStorage.listRemoteFiles();
};

handlers['reset-budget-cache'] = mutator(async function() {
  // Recomputing everything will update the cache
  await sheet.loadUserBudgets(db);
  sheet.get().recomputeAll();
  await sheet.waitOnSpreadsheet();
});

handlers['upload-budget'] = async function({ id } = {}) {
  if (id) {
    if (prefs.getPrefs()) {
      throw new Error('upload-budget: id given but prefs already loaded');
    }

    await prefs.loadPrefs(id);
  }

  try {
    await cloudStorage.upload();
  } catch (e) {
    console.log(e);
    if (e.type === 'FileUploadError') {
      return { error: e };
    }
    captureException(e);
    return { error: { reason: 'internal' } };
  } finally {
    if (id) {
      prefs.unloadPrefs();
    }
  }

  return {};
};

handlers['download-budget'] = async function({ fileId, replace }) {
  let result;
  try {
    result = await cloudStorage.download(fileId, replace);
  } catch (e) {
    if (e.type === 'FileDownloadError') {
      if (e.reason === 'file-exists' && e.meta.id) {
        await prefs.loadPrefs(e.meta.id);
        let name = prefs.getPrefs().budgetName;
        prefs.unloadPrefs();

        e.meta = { ...e.meta, name };
      }

      return { error: e };
    } else {
      captureException(e);
      return { error: { reason: 'internal' } };
    }
  }

  let id = result.id;

  // Load the budget and do a full sync
  result = await loadBudget(result.id, VERSION, { showUpdate: true });
  if (result.error) {
    return { error: { reason: result.error } };
  }

  setSyncingMode('enabled');
  await initialFullSync();

  await handlers['close-budget']();

  return { id };
};

handlers['load-budget'] = async function({ id }) {
  let currentPrefs = prefs.getPrefs();

  if (currentPrefs) {
    if (currentPrefs.id === id) {
      // If it's already loaded, do nothing
      return {};
    } else {
      // Otherwise, close the currently loaded budget
      await handlers['close-budget']();
    }
  }

  let res = await loadBudget(id, VERSION, { showUpdate: true });

  async function trackSizes() {
    let getFileSize = async name => {
      let dbFile = fs.join(fs.getBudgetDir(id), name);
      try {
        return await fs.size(dbFile);
      } catch (err) {
        return null;
      }
    };

    try {
      let dbSize = await getFileSize('db.sqlite');
      let cacheSize = await getFileSize('cache.sqlite');
      tracking.track('app:load-budget', { size: dbSize, cacheSize });
    } catch (err) {
      console.warn(err);
    }
  }
  trackSizes();

  return res;
};

handlers['create-demo-budget'] = async function() {
  // Make sure the read only flag isn't leftover (normally it's
  // reset when signing in, but you don't have to sign in for the
  // demo budget)
  await asyncStorage.setItem('readOnly', '');

  return handlers['create-budget']({
    budgetName: 'Demo Budget',
    testMode: true,
    testBudgetId: DEMO_BUDGET_ID
  });
};

handlers['close-budget'] = async function() {
  captureBreadcrumb({ message: 'Closing budget' });

  // The spreadsheet may be running, wait for it to complete
  await sheet.waitOnSpreadsheet();
  sheet.unloadSpreadsheet();

  clearFullSyncTimeout();
  await app.stopServices();

  await db.closeDatabase();

  try {
    await asyncStorage.setItem('lastBudget', '');
  } catch (e) {
    // This might fail if we are shutting down after failing to load a
    // budget. We want to unload whatever has already been loaded but
    // be resilient to anything failing
  }

  prefs.unloadPrefs();
  stopBackupService();
  return 'ok';
};

handlers['delete-budget'] = async function({ id, cloudFileId }) {
  // If it's a cloud file, you can delete it from the server by
  // passing its cloud id
  if (cloudFileId && !process.env.IS_BETA) {
    await cloudStorage.removeFile(cloudFileId).catch(err => {});
  }

  // If a local file exists, you can delete it by passing its local id
  if (id) {
    let budgetDir = fs.getBudgetDir(id);
    await fs.removeDirRecursively(budgetDir);
  }

  return 'ok';
};

handlers['create-budget'] = async function({
  budgetName,
  avoidUpload,
  testMode,
  testBudgetId
} = {}) {
  let id;
  if (testMode) {
    budgetName = budgetName || 'Test Budget';
    id = testBudgetId || TEST_BUDGET_ID;

    if (await fs.exists(fs.getBudgetDir(id))) {
      await fs.removeDirRecursively(fs.getBudgetDir(id));
    }
  } else {
    // Generate budget name if not given
    if (!budgetName) {
      // Unfortunately we need to load all of the existing files first
      // so we can detect conflicting names.
      let files = await handlers['get-budgets']();
      budgetName = await uniqueFileName(files);
    }

    id = await idFromFileName(budgetName);
  }

  let budgetDir = fs.getBudgetDir(id);
  await fs.mkdir(budgetDir);

  // Create the initial database
  await fs.copyFile(fs.bundledDatabasePath, fs.join(budgetDir, 'db.sqlite'));

  // Create the initial prefs file
  await fs.writeFile(
    fs.join(budgetDir, 'metadata.json'),
    JSON.stringify(prefs.getDefaultPrefs(id, budgetName))
  );

  // Load it in
  let { error } = await loadBudget(id, VERSION);
  if (error) {
    console.log('Error creating budget: ' + error);
    return { error };
  }

  if (!avoidUpload && !testMode) {
    try {
      await cloudStorage.upload();
    } catch (e) {
      // Ignore any errors uploading. If they are offline they should
      // still be able to create files.
    }
  }

  if (testMode) {
    await createTestBudget(handlers);
  }

  return {};
};

handlers['set-tutorial-seen'] = async function() {
  await asyncStorage.setItem('seen-tutorial', 'true');
  return 'ok';
};

handlers['import-budget'] = async function({ filepath, type }) {
  try {
    if (!(await fs.exists(filepath))) {
      throw new Error(`File not found at the provided path: ${filepath}`);
    }

    let buffer = Buffer.from(await fs.readFile(filepath, 'binary'));

    switch (type) {
      case 'ynab4':
        try {
          await YNAB4.importBuffer(filepath, buffer);
        } catch (e) {
          let msg = e.message.toLowerCase();
          if (
            msg.includes('not a ynab4') ||
            msg.includes('could not find file')
          ) {
            return { error: 'not-ynab4' };
          }
        }
        break;
      case 'ynab5':
        let data;
        try {
          data = JSON.parse(buffer.toString());
        } catch (e) {
          return { error: 'parse-error' };
        }

        try {
          await YNAB5.importYNAB5(data);
        } catch (e) {
          return { error: 'not-ynab5' };
        }
        break;
      case 'actual':
        // We should pull out import/export into its own app so this
        // can be abstracted out better. Importing Actual files is a
        // special case because we can directly write down the files,
        // but because it doesn't go through the API layer we need to
        // duplicate some of the workflow
        await handlers['close-budget']();

        let { id } = await cloudStorage.importBuffer(
          { cloudFileId: null, groupId: null },
          buffer
        );

        // We never want to load cached data from imported files, so
        // delete the cache
        let sqliteDb = await sqlite.openDatabase(
          fs.join(fs.getBudgetDir(id), 'db.sqlite')
        );
        sqlite.execQuery(
          sqliteDb,
          `
          DELETE FROM kvcache;
          DELETE FROM kvcache_key;
        `
        );
        sqlite.closeDatabase(sqliteDb);

        // Load the budget, force everything to be computed, and try
        // to upload it as a cloud file
        await handlers['load-budget']({ id });
        await handlers['get-budget-bounds']();
        await sheet.waitOnSpreadsheet();
        await cloudStorage.upload().catch(err => {});

        break;
      default:
    }
  } catch (err) {
    err.message = 'Error importing budget: ' + err.message;
    captureException(err);
    return { error: 'internal-error' };
  }

  return {};
};

handlers['export-budget'] = async function() {
  return await cloudStorage.exportBuffer();
};

async function loadBudget(id, appVersion, { showUpdate } = {}) {
  let dir;
  try {
    dir = fs.getBudgetDir(id);
  } catch (e) {
    captureException(
      new Error('`getBudgetDir` failed in `loadBudget`: ' + e.message)
    );
    return { error: 'budget-not-found' };
  }

  captureBreadcrumb({ message: 'Loading budget ' + dir });

  if (!(await fs.exists(dir))) {
    captureException(new Error('budget directory does not exist'));
    return { error: 'budget-not-found' };
  }

  try {
    await prefs.loadPrefs(id);
    await db.openDatabase(id);
  } catch (e) {
    captureBreadcrumb({ message: 'Error loading budget ' + id });
    captureException(e);
    await handlers['close-budget']();
    return { error: 'opening-budget' };
  }

  // Older versions didn't tag the file with the current user, so do
  // so now
  if (!prefs.getPrefs().userId) {
    let [[, userId]] = await asyncStorage.multiGet(['user-token']);
    prefs.savePrefs({ userId });
  }

  let { budgetVersion, budgetId } = prefs.getPrefs();

  try {
    await updateVersion(budgetVersion, showUpdate);
  } catch (e) {
    console.warn('Error updating', e);
    let result;
    if (e.message.includes('out-of-sync-migrations')) {
      result = { error: 'out-of-sync-migrations' };
    } else if (e.message.includes('out-of-sync-data')) {
      result = { error: 'out-of-sync-data' };
    } else {
      captureException(e);
      logger.info('Error updating budget ' + id, e);
      console.log('Error updating budget', e);
      result = { error: 'loading-budget' };
    }

    await handlers['close-budget']();
    return result;
  }

  await db.loadClock();

  if (prefs.getPrefs().resetClock) {
    // If we need to generate a fresh clock, we need to generate a new
    // client id. This happens when the database is transferred to a
    // new device.
    //
    // TODO: The client id should be stored elsewhere. It shouldn't
    // work this way, but it's fine for now.
    timestamp.getClock().timestamp.setNode(timestamp.makeClientId());
    await db.runQuery(
      'INSERT OR REPLACE INTO messages_clock (id, clock) VALUES (1, ?)',
      [timestamp.serializeClock(timestamp.getClock())]
    );

    await prefs.savePrefs({ resetClock: false });
  }

  if (!Platform.isWeb && !Platform.isMobile && !global.__TESTING__) {
    startBackupService(id);
  }

  try {
    await sheet.loadSpreadsheet(db, onSheetChange);
  } catch (e) {
    captureException(e);
    await handlers['close-budget']();
    return { error: 'opening-budget' };
  }

  // This is a bit leaky, but we need to set the initial budget type
  sheet.get().meta().budgetType = prefs.getPrefs().budgetType;
  await budget.createAllBudgets();

  // Load all the in-memory state
  await mappings.loadMappings();
  await rules.loadRules();
  await syncMigrations.listen();
  await app.startServices();

  clearUndo();

  // Ensure that syncing is enabled
  if (!global.__TESTING__) {
    if (process.env.IS_BETA || id === DEMO_BUDGET_ID) {
      setSyncingMode('disabled');
    } else if (id === TEST_BUDGET_ID) {
      await asyncStorage.setItem('lastBudget', id);
    } else {
      setSyncingMode('enabled');

      await asyncStorage.setItem('lastBudget', id);

      // Only upload periodically on desktop
      if (!Platform.isMobile) {
        await cloudStorage.possiblyUpload();
      }
    }
  }

  app.events.emit('load-budget', { id });

  return {};
}

handlers['get-upgrade-notifications'] = async function() {
  let { id } = prefs.getPrefs();
  if (id === TEST_BUDGET_ID || id === DEMO_BUDGET_ID) {
    return [];
  }

  let types = ['schedules', 'repair-splits'];
  let unseen = [];

  for (let type of types) {
    let key = `notifications.${type}`;
    if (prefs.getPrefs()[key] == null) {
      unseen.push(type);
    }
  }

  return unseen;
};

handlers['seen-upgrade-notification'] = async function({ type }) {
  let key = `notifications.${type}`;
  prefs.savePrefs({ [key]: true });
};

handlers['upload-file-web'] = async function({ filename, contents }) {
  if (!Platform.isWeb) {
    return null;
  }

  await fs.writeFile('/uploads/' + filename, contents);
  return 'ok';
};

handlers['backups-get'] = async function({ id }) {
  return getAvailableBackups(id);
};

handlers['backup-load'] = async function({ id, backupId }) {
  await loadBackup(id, backupId);
};

handlers['backup-make'] = async function({ id }) {
  await makeBackup(id);
};

handlers['get-last-opened-backup'] = async function() {
  const id = await asyncStorage.getItem('lastBudget');
  if (id && id !== '') {
    const budgetDir = fs.getBudgetDir(id);

    // We never want to give back a budget that does not exist on the
    // filesystem anymore, so first check that it exists
    if (await fs.exists(budgetDir)) {
      return id;
    }
  }
  return null;
};

handlers['app-focused'] = async function() {
  if (prefs.getPrefs() && prefs.getPrefs().id) {
    // First we sync
    fullSync();
  }
};

handlers['track'] = async function({ name, props }) {
  tracking.track(name, props);
};

handlers = installAPI(handlers);

injectAPI.send = (name, args) => runHandler(app.handlers[name], args);

// A hack for now until we clean up everything
app.handlers = handlers;
app.combine(schedulesApp, budgetApp, notesApp, toolsApp);

function getDefaultDocumentDir() {
  if (Platform.isMobile) {
    // On mobile, unfortunately we need to be backwards compatible
    // with the old folder structure which does not store files inside
    // of an `Actual` directory. In the future, if we really care, we
    // can migrate them, but for now just return the documents dir
    return process.env.ACTUAL_DOCUMENT_DIR;
  }
  return fs.join(process.env.ACTUAL_DOCUMENT_DIR, 'Actual');
}

async function setupDocumentsDir() {
  async function ensureExists(dir) {
    // Make sure the document folder exists
    if (!(await fs.exists(dir))) {
      await fs.mkdir(dir);
    }
  }

  let documentDir = await asyncStorage.getItem('document-dir');

  // Test the existing documents directory to make sure it's a valid
  // path that exists, and if it errors fallback to the default one
  if (documentDir) {
    try {
      await ensureExists(documentDir);
    } catch (e) {
      documentDir = null;
    }
  }

  if (!documentDir) {
    documentDir = getDefaultDocumentDir();
  }

  await ensureExists(documentDir);
  fs._setDocumentDir(documentDir);
}

export async function initApp(version, isDev, socketName) {
  VERSION = version;

  await sqlite.init();
  await Promise.all([asyncStorage.init(), fs.init()]);
  await tracking.init();
  await setupDocumentsDir();

  let keysStr = await asyncStorage.getItem('encrypt-keys');
  if (keysStr) {
    try {
      let keys = JSON.parse(keysStr);

      // Load all the keys
      await Promise.all(
        Object.keys(keys).map(fileId => {
          return encryption.loadKey(keys[fileId]);
        })
      );
    } catch (e) {
      console.log('Error loading key', e);
      throw new Error('load-key-error');
    }
  }

  if (isDev) {
    const lastBudget = await asyncStorage.getItem('lastBudget');
    // if (lastBudget) {
    //   loadBudget(lastBudget, VERSION);
    // }
  }

  const url = await asyncStorage.getItem('server-url');
  if (url) {
    setServer(url);
  }

  connection.init(socketName, app.handlers);

  tracking.track('app:init', {
    platform: Platform.isMobile ? 'mobile' : Platform.isWeb ? 'web' : 'desktop'
  });

  if (!isDev && !Platform.isMobile && !Platform.isWeb) {
    let autoUpdate = await asyncStorage.getItem('auto-update');
    process.send({
      type: 'shouldAutoUpdate',
      flag: autoUpdate == null || autoUpdate === 'true'
    });
  }

  if (isDev || process.env.IS_BETA) {
    global.$send = (name, args) => runHandler(app.handlers[name], args);
    global.$query = aqlQuery;
    global.$q = q;
    global.$db = db;
    global.$setSyncingMode = setSyncingMode;
  }
}

export async function init({ budgetId, config }) {
  // Get from build
  // eslint-disable-next-line
  VERSION = ACTUAL_APP_VERSION;

  let dataDir, serverURL;
  if (config) {
    dataDir = config.dataDir;
    serverURL = config.serverURL;
  } else {
    dataDir = process.env.ACTUAL_DATA_DIR;
    serverURL = process.env.ACTUAL_SERVER_URL;
  }

  await sqlite.init();
  await Promise.all([asyncStorage.init({ persist: false }), fs.init()]);
  fs._setDocumentDir(dataDir || process.cwd());

  if (serverURL) {
    setServer(serverURL);
  } else {
    // This turns off all server URLs. In this mode we don't want any
    // access to the server, we are doing things locally
    setServer(null);

    app.events.on('load-budget', () => {
      setSyncingMode('offline');
    });
  }

  if (budgetId) {
    await runHandler(handlers['load-budget'], { id: budgetId });
  }

  return lib;
}

// Export a few things required for the platform
export const lib = {
  getDataDir: fs.getDataDir,
  sendMessage: (msg, args) => connection.send(msg, args),
  send: async (name, args) => {
    let res = await runHandler(app.handlers[name], args);
    return res;
  },
  on: (name, func) => app.events.on(name, func),
  syncAndReceiveMessages,
  q,
  db,

  // Expose CRDT mechanisms so server can use them
  merkle,
  timestamp,
  SyncProtoBuf: SyncPb
};

if (process.env.NODE_ENV === 'development' && Platform.isWeb) {
  // Support reloading the backend
  self.addEventListener('message', async e => {
    if (e.data.type === '__actual:shutdown') {
      await sheet.waitOnSpreadsheet();
      await app.stopServices();
      await db.closeDatabase();
      asyncStorage.shutdown();
      fs.shutdown();

      setTimeout(() => {
        // Give everything else some time to process shutdown events
        self.close();
      }, 100);
    }
  });
}