const app = require('j7/app');
const utils = require('j7/utils');
const bcutils = require('j7/bcutils');
const log = require('j7/log');
const event = require('j7/event');
const BaseService = require('./baseservice');
const factory = require('./factory');
const metaFactory = require('../metadata/factory');
const bc = require('../blockchain');
const C = require('../C');

const LIMIT_COUNT = 100;

class EventCenter extends BaseService {

  instances = [
    {
      'name': 'heroInstance',
      'last_block_number': 0,
      'eventName': 'Transfer',
    },
    {
      'name': 'equipInstance',
      'last_block_number': 0,
      'eventName': 'Transfer',
    },
    {
      'name': 'chipInstance',
      'last_block_number': 0,
      'eventName': 'Transfer',
    },
    {
      'name': 'luckboxInstance',
      'last_block_number': 0,
      'eventName': 'Transfer',
    }
  ];

  boxInstance = {
    'name': 'boxproxyInstance',
    'last_block_number': 0,
    'eventName': 'BoxOpened',
  };

  async init() {
    this.lastIdx = 0;
    this.pendingConfirmOwnerHash = {};

    const {err, conn} = await app.getDbConn('MarketDb0');
    if (err) {
      throw 'db error:' + err;
    }
    this.conn = conn;

    event.addListener(C.DESTORY_EXEC_CONFIRM_OWNER_EVENT, (tokenId) => {
      log.info('destory:' + tokenId);
      try {
        if (utils.getVal(this.pendingConfirmOwnerHash, tokenId)) {
          delete this.pendingConfirmOwnerHash[tokenId];
        }
      } catch(err) {
        log.error('destory confirm owner:' + err);
      }
    });

    this.confirmOwner();
    await this.initEventProcess();
  }

  async initEventProcess() {
    {
      this.instances.forEach(async (item) => {
        factory.create('EventProcess', null)
          .init(item, async (event) = {
            await factory.create('NftTransferProcess', null).start(this.conn, event);
          })
      });
    }
    {
      factory.create('EventProcess', null)
        .init(this.boxInstance, async (event) = {
          await factory.create('BoxOpenedProcess', null).start(this.conn, event);
        });
    }
  }

  async addConfirmOwnerRequest(tokenId) {
    const pendingRequest = utils.getVal(this.pendingConfirmOwnerHash, tokenId);
    if (!pendingRequest) {
      const newRequest = new factory.create('ExecConfirmOwner', null);
      this.pendingConfirmOwnerHash[tokenId] = newRequest;
      newRequest.init(tokenId);
      return;
    } else {
      pendingRequest.addTryCount();
    }
  }

  async confirmOwner() {
    let maxIdx = 0;
    while (true) {
      {
        const {err, rows} = await this.conn.execQuery(
          'SELECT * FROM t_nft_transfer WHERE `idx` > ? AND ' +
            '`owner_confirmed` = 0 LIMIT ' + LIMIT_COUNT,
          [this.lastIdx]);
        if (!err) {
          for (let i in rows) {
            const row = rows[i];
            this.addConfirmOwnerRequest(row['token_id']);
            if (row['idx'] > this.lastIdx) {
              this.lastIdx = row['idx'];
            }
          }
          if (rows.length < 1 && this.lastIdx + LIMIT_COUNT < maxIdx) {
            this.lastIdx += LIMIT_COUNT;
            continue;
          }
        }
      }
      {
        const {err, row} = await this.conn.execQueryOne(
          'SELECT max(idx) max_idx FROM t_nft_transfer', []);
        if (!err && row['max_idx'] != null) {
          maxIdx = row['max_idx'];
        }
      }
      while (Object.keys(this.pendingConfirmOwnerHash).length > 50) {
        await utils.sleep(1000 + utils.randRange(500, 1500));
      }
      await utils.sleep(2000 + utils.randRange(500, 1500));
    }
  }

}

module.exports = EventCenter;