const utils = require("./utils");
const db = require("./db");
const sync = require("./sync");
const metamgr = require("./metamgr");
const boxorder = require("./boxorder");
const log = require("./log");

class OrderMgr {

  constructor() {
    this.pendingOrderHash = {};
    this.historyOrderCond = new sync.Cond();
    this.newOrderCond = new sync.Cond();
  }

  init() {
    setTimeout(this.coStart.bind(this), 1000 * 0.1);
  }

  async coStart() {
    let {err, row} = await db.execOneQuery(
      'SELECT max(idx) max_idx FROM t_box_order', []);
    if (err) {
      throw err;
    }
    let hisMaxIdx = utils.emptyReplace(row['max_idx'], 0);
    hisMaxIdx = Math.max(0, hisMaxIdx);
    setTimeout(this.coHistoryOrder.bind(this, hisMaxIdx), 1000 * 0.1);
    setTimeout(this.coNewOrder.bind(this, hisMaxIdx), 1000 * 0.1);
  }

  async coHistoryOrder(hisMaxIdx) {
    let lastSyncIdx = hisMaxIdx;
    while (lastSyncIdx > 0) {
      let startIdx = Math.Max(0, lastSyncIdx - 1000);
      let {err, rows} = await db.execQuery(
        'SELECT * max_idx FROM t_box_order WHERE idx > ? AND idx <= ? AND done = 0 LIMIT 1000',
        [startIdx, lastSyncIdx]);
      if (!err) {
        procHisOrderList(rows);
        lastSyncIdx = startIdx;
        if (rows.length() <= 0) {
          continue;
        }
      }
      await this.historyOrderCond.wait(1000 * 1);
    }
    log.info('history order loaded done hisMaxIdx:' + hisMaxIdx);
  }

  async coNewOrder(hisMaxIdx) {
    let lastSyncIdx = hisMaxIdx;
    while (true) {
      let {err, rows} = await db.execQuery(
        'SELECT * max_idx FROM t_box_order WHERE idx > ? AND done = 0 LIMIT 100',
        [lastSyncIdx]);
      if (!err) {
        let maxIdx = procNewOrderList(rows);
        if (maxIdx > lastSyncIdx) {
          lastSyncIdx = maxIdx;
        }
      }
      await this.newOrderCond.wait(1000 * 3);
    }
  }

  newOrderNotify() {
    this.newOrderCond.notify();
  }

  procHisOrderList(rows) {
    this.internalProcOrderList(rows, false);
  }

  procNewOrderList(rows) {
    this.internalProcOrderList(rows, true);
  }

  internalProcOrderList(rows, isNewOrder) {
    let maxIdx = 0;
    rows.forEach(function (orderDb) {
      this.addPendingOrder(orderDb, isNewOrder);
      if (orderDb['idx'] > maxIdx) {
        maxIdx = orderDb['idx'];
      }
    });
    return maxIdx;
  }

  addPendingOrder(orderDb) {
    if (orderDb['order_id'] in this.pendingOrderHash) {
      throw 'order_id exists ' + orderDb['order_id'];
    }
    let boxOrder = new boxorder.BoxOrder(orderDb);
    this.pendingOrderHash[orderDb['order_id']] = boxOrder;
    boxOrder.init();
  }

  removePendingOrder(orderId) {
    delete this.pendingOrderHash[orderId];
  }

}

const _instance = new OrderMgr();

module.exports = _instance;