/**
 * Test case for figuring out robust way to recognize if connection is dead
 * for mysql based drivers.
 */
const Bluebird = require('bluebird');
const toxiproxy = require('toxiproxy-node-client');
const toxicli = new toxiproxy.Toxiproxy('http://localhost:8474');
const rp = require('request-promise-native');

async function stdMysqlQuery(con, sql) {
  return new Promise((resolve, reject) => {
    try {
      con.query(
        {
          sql,
          timeout: 4000,
        },
        function(error, results, fields) {
          if (error) {
            reject(error);
          } else {
            resolve(results);
          }
        }
      );
    } catch (err) {
      reject(err); // double sure...
    }
  });
}

// ALL THE DRIVERS HAS DIFFERENT BAG OF TRICKS TO RECOVER AND
// RECOGNIZE WHEN CONNECTION HAS BEEN CLOSED

// ------------- setup mysql db driver connection
const mysql = require('mysql');
let mysqlCon = { state: 'disconnected' };
async function mysqlQuery(sql) {
  // best way to check if connection is still alive
  if (mysqlCon.state === 'disconnected') {
    console.log('reconnecting mysql');
    mysqlCon = mysql.createConnection({
      host: 'localhost',
      user: 'root',
      password: 'mysqlrootpassword',
      port: 23306,
      connectTimeout: 500,
    });
    // not always triggered, if this happens during query
    mysqlCon.on('error', (err) => {
      console.log('- STATS Mysql connection died:', err);
    });
  }
  return stdMysqlQuery(mysqlCon, sql);
}

// ------------- setup mysql2 db driver connection
const mysql2 = require('mysql2');
let mysql2Con = { _fatalError: 'initmefirst' };
async function mysql2Query(sql) {
  if (mysql2Con._fatalError) {
    console.log('reconnecting mysql2');
    mysql2Con = mysql2.createConnection({
      host: 'localhost',
      user: 'root',
      password: 'mysqlrootpassword',
      port: 23306,
      connectTimeout: 500,
    });
    mysql2Con.on('error', (err) => {
      console.log('- STATS Mysql2 connection died:', err);
    });
  }
  console.log('================ MYSQL2 Running query....');
  const res = await stdMysqlQuery(mysql2Con, sql);
  console.log('=========== done');
  return res;
}

const counters = {};
function setMysqlQueryCounters(name) {
  const counts = (counters[name] = { queries: 0, results: 0, errors: 0 });
}
setMysqlQueryCounters('mysql');
setMysqlQueryCounters('mysql2');

const _ = require('lodash');

// start printing out counters
let lastCounters = _.cloneDeep(counters);

setInterval(() => {
  const reqsPerSec = {};
  for (let key of Object.keys(counters)) {
    reqsPerSec[key] = {
      queries: counters[key].queries - lastCounters[key].queries,
      results: counters[key].results - lastCounters[key].results,
      errors: counters[key].errors - lastCounters[key].errors,
    };
  }
  console.log(
    '------------------------ STATS PER SECOND ------------------------'
  );
  console.dir(reqsPerSec, { colors: true });
  console.log(
    '------------------------------- EOS ------------------------------'
  );
  lastCounters = _.cloneDeep(counters);

  // if hang
  ///if (reqsPerSec.mysql2.queries === 0) process.exit(0);
}, 1000);

async function main() {
  async function recreateProxy(serviceName, listenPort, proxyToPort) {
    try {
      await rp.delete({
        url: `${toxicli.host}/proxies/${serviceName}`,
      });
    } catch (err) {}

    const proxy = await toxicli.createProxy({
      name: serviceName,
      listen: `0.0.0.0:${listenPort}`,
      upstream: `${serviceName}:${proxyToPort}`,
    });

    // add some latency
    await proxy.addToxic(
      new toxiproxy.Toxic(proxy, {
        type: 'latency',
        attributes: { latency: 1, jitter: 1 },
      })
    );

    // cause connections to be closed every some transferred bytes
    await proxy.addToxic(
      new toxiproxy.Toxic(proxy, {
        type: 'limit_data',
        attributes: { bytes: 1000 },
      })
    );
  }

  // create TCP proxies for simulating bad connections etc.
  async function recreateProxies() {
    console.log('----- Recreating proxies -> cutting connections completely');
    await recreateProxy('postgresql', 25432, 5432);
    await recreateProxy('mysql', 23306, 3306);
    await recreateProxy('oracledbxe', 21521, 1521);
  }
  setInterval(() => recreateProxies(), 2000);

  async function loopQueries(prefix, query) {
    const counts = counters[prefix];

    while (true) {
      try {
        counts.queries += 1;
        // without this delay we endup to busy failure loop
        await Bluebird.delay(0);
        await query();
        counts.results += 1;
      } catch (err) {
        counts.errors += 1;
        console.log(prefix, err);
      }
    }
  }

  await recreateProxies();

  loopQueries('mysql', () => mysqlQuery('select 1'));
  loopQueries('mysql2', () => mysql2Query('select 1'));

  // wait forever
  while (true) {
    await Bluebird.delay(1000);
  }
}

main()
  .then(() => console.log('DONE'))
  .catch((err) => console.log(err));