/*jshint strict: false, sub: true */
/*global print */
'use strict';

////////////////////////////////////////////////////////////////////////////////
/// DISCLAIMER
///
/// Copyright 2016 ArangoDB GmbH, Cologne, Germany
///
/// Licensed under the Apache License, Version 2.0 (the "License");
/// you may not use this file except in compliance with the License.
/// You may obtain a copy of the License at
///
///     http://www.apache.org/licenses/LICENSE-2.0
///
/// Unless required by applicable law or agreed to in writing, software
/// distributed under the License is distributed on an "AS IS" BASIS,
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
/// See the License for the specific language governing permissions and
/// limitations under the License.
///
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
///
/// @author Dr. Frank Celler
////////////////////////////////////////////////////////////////////////////////

const internal = require("internal");
const fs = require("fs");
const tasks = require("org/arangodb/tasks");

const _ = require("lodash");

const executeExternalAndWait = require("internal").executeExternalAndWait;

const db = internal.db;
const sleep = internal.sleep;

const optsDefault = {
  duration: 60, // in minutes
  gnuplot: false,
  results: "results",
  runId: "run"
};

////////////////////////////////////////////////////////////////////////////////
/// @brief create image using gnuplot
////////////////////////////////////////////////////////////////////////////////

function gnuplot() {
  executeExternalAndWait("gnuplot", "out/kills.plot");
}

////////////////////////////////////////////////////////////////////////////////
/// @brief statistics generator
////////////////////////////////////////////////////////////////////////////////

let statisticsInitialized = false;

const killsLog = fs.join("out", "kills.csv");
const types = ["inserter", "updater", "remover", "killer"];

function statistics(opts) {
  if (!statisticsInitialized) {
    fs.makeDirectoryRecursive("out");

    fs.write(killsLog, "# " + types.join("\t") + "\n");

    statisticsInitialized = true;
  }

  const results = opts.results;

  let runtime = Math.round(((new Date()) - opts.startTime) / 1000);
  let line = [runtime];

  for (let i = 0; i < types.length; ++i) {
    const s = db._query(
      `
       FOR u IN @@results 
         FILTER u.type == @type
         RETURN u.statistics
      `, {
        '@results': results,
        'type': types[i]
      }).toArray()[0];

    if (s !== undefined) {
      line.push(s.count);
      line.push(s.success);
      line.push(s.failures);
    } else {
      line.push(0);
      line.push(0);
      line.push(0);
    }
  }

  fs.append(killsLog, line.join("\t") + "\n");
}

////////////////////////////////////////////////////////////////////////////////
/// @brief INSERTER
////////////////////////////////////////////////////////////////////////////////

exports.inserter = function(opts) {
  const runId = opts.runId;

  const duration = opts.duration;
  const start = Date.now();
  const end = start + 1000 * 60 * duration;

  const results = opts.results;
  const r = db._collection(results);

  try {
    r.remove(runId);
  } catch (err) {}

  r.save({
    _key: runId,
    started: true,
    finished: false,
    startDate: start,
    endDate: end,
    type: "inserter",
    statistics: {
      count: 0,
      success: 0,
      failures: 0
    }
  });

  let count = 0;
  let success = 0;
  let failures = 0;
  let lastErr = "";

  while (true) {
    ++count;

    if (count % 1000 === 0) {
      r.update(runId, {
        statistics: {
          count: count,
          success: success,
          failures: failures
        },
        lastError: lastErr
      });
    }

    let c = Math.floor(Math.random() * 8) + 2;
    let q = `
      FOR doc IN 1..@c
        INSERT {
          _from: CONCAT("posts/test", doc),
          _to: CONCAT("posts/test", @c),
          value: doc
        }
        IN edges`;

    try {
      db._query({
        query: q,
        bindVars: {
          c
        }
      });

      ++success;
    } catch (err) {
      if (err.errorNum !== 1500) {
        lastErr = String(err);
        print(err);
        ++failures;
      }
    }

    if (Date.now() > end) {
      break;
    }
  }

  r.update(runId, {
    finished: true,
    statistics: {
      count: count,
      success: success,
      failures: failures
    }
  });
};

////////////////////////////////////////////////////////////////////////////////
/// @brief UPDATER
////////////////////////////////////////////////////////////////////////////////

exports.updater = function(opts) {
  const runId = opts.runId;

  const duration = opts.duration;
  const start = Date.now();
  const end = start + 1000 * 60 * duration;

  const results = opts.results;
  const r = db._collection(results);

  try {
    r.remove(runId);
  } catch (err) {}

  r.save({
    _key: runId,
    started: true,
    finished: false,
    startDate: start,
    endDate: end,
    type: "updater",
    statistics: {
      count: 0,
      success: 0,
      failures: 0
    }
  });

  let count = 0;
  let success = 0;
  let failures = 0;
  let lastErr = "";

  while (true) {
    ++count;

    if (count % 1000 === 0) {
      r.update(runId, {
        statistics: {
          count: count,
          success: success,
          failures: failures
        }
      });
    }

    let c = Math.floor(Math.random() * 8) + 2;
    let q = `
      FOR doc IN edges
        SORT RAND()
        LIMIT @c
        UPDATE doc WITH { value: doc.value + 1 }
        IN edges`;

    try {
      db._query({
        query: q,
        bindVars: {
          c
        }
      });

      success++;
    } catch (err) {
      if (err.errorNum !== 1500) {
        lastErr = String(err);
        print(err);
        ++failures;
      }
    }

    if (Date.now() > end) {
      break;
    }
  }

  r.update(runId, {
    finished: true,
    statistics: {
      count: count,
      success: success,
      failures: failures
    }
  });
};

////////////////////////////////////////////////////////////////////////////////
/// @brief REOMVER
////////////////////////////////////////////////////////////////////////////////

exports.remover = function(opts) {
  const runId = opts.runId;

  const duration = opts.duration;
  const start = Date.now();
  const end = start + 1000 * 60 * duration;

  const results = opts.results;
  const r = db._collection(results);

  try {
    r.remove(runId);
  } catch (err) {}

  r.save({
    _key: runId,
    started: true,
    finished: false,
    startDate: start,
    endDate: end,
    type: "remover",
    statistics: {
      count: 0,
      success: 0,
      failures: 0
    }
  });

  let count = 0;
  let success = 0;
  let failures = 0;
  let lastErr = "";

  while (true) {
    ++count;

    if (count % 1000 === 0) {
      r.update(runId, {
        statistics: {
          count: count,
          success: success,
          failures: failures
        }
      });
    }

    let c = Math.floor(Math.random() * 8) + 2;
    let q = `
      FOR doc IN edges
        SORT RAND()
        LIMIT @c
        REMOVE doc._key
        IN edges`;

    try {
      db._query({
        query: q,
        bindVars: {
          c
        }
      });

      success++;
    } catch (err) {
      if (err.errorNum !== 1500) {
        lastErr = String(err);
        print(err);
        ++failures;
      }
    }

    if (Date.now() > end) {
      break;
    }
  }

  r.update(runId, {
    finished: true,
    statistics: {
      count: count,
      success: success,
      failures: failures
    }
  });
};

////////////////////////////////////////////////////////////////////////////////
/// @brief KILLER
////////////////////////////////////////////////////////////////////////////////

exports.killer = function(opts) {
  const runId = opts.runId;

  const duration = opts.duration;
  const start = Date.now();
  const end = start + 1000 * 60 * duration;

  const results = opts.results;
  const r = db._collection(results);

  try {
    r.remove(runId);
  } catch (err) {}

  r.save({
    _key: runId,
    started: true,
    finished: false,
    startDate: start,
    endDate: end,
    type: "killer",
    statistics: {
      count: 0,
      success: 0,
      failures: 0
    }
  });

  let count = 0;
  let success = 0;
  let failures = 0;
  let lastErr = "";

  const queries = require("org/arangodb/aql/queries");

  while (true) {
    ++count;

    if (count % 100 === 0) {
      r.update(runId, {
        statistics: {
          count: count,
          success: success,
          failures: failures
        }
      });
    }

    queries.current().forEach(function(q) {
      if (q.query.indexOf("edges") !== -1) {
        try {
          queries.kill(q.id);
          success++;
        } catch (err) {
          if (err.errorNum !== 1591) {
            lastErr = String(err);
            print(err);
          }
          ++failures;
        }
      }
    });

    if (Date.now() > end) {
      break;
    }

    internal.wait(Math.random() * 0.1, false);
  }

  r.update(runId, {
    finished: true,
    statistics: {
      count: count,
      success: success,
      failures: failures
    }
  });
};

////////////////////////////////////////////////////////////////////////////////
/// @brief killing
////////////////////////////////////////////////////////////////////////////////

exports.killingParallel = function(opts) {
  _.defaults(opts, optsDefault);

  // start time
  opts.startTime = new Date();

  // create the test collections
  db._drop("edges");
  db._createEdgeCollection("edges");

  db._drop("posts");
  db._create("posts");

  // create the "results" collection
  const results = opts.results;
  db._drop(results);
  db._create(results);

  // create output directory
  fs.makeDirectoryRecursive("out");

  // start worker
  const w = [
    function(params) {
      require("./js/server/tests/stress/killingQueries").inserter(params);
    },
    function(params) {
      require("./js/server/tests/stress/killingQueries").updater(params);
    },
    function(params) {
      require("./js/server/tests/stress/killingQueries").remover(params);
    },
    function(params) {
      require("./js/server/tests/stress/killingQueries").killer(params);
    }
  ];

  for (let i = 0; i < w.length; ++i) {
    const cmd = w[i];
    let o = JSON.parse(JSON.stringify(opts));

    o.runId = "run_" + i;

    tasks.register({
      id: "stress" + i,
      name: "stress test " + i,
      offset: i,
      params: o,
      command: cmd
    });
  }

  // wait for a result
  const countDone = function() {
    const a = db._query("FOR u IN @@results FILTER u.finished RETURN 1", {
      '@results': 'results'
    });

    const b = db._query("FOR u IN @@results FILTER u.started RETURN 1", {
      '@results': 'results'
    });

    return a.count() === b.count();
  };

  let m = 0;

  for (let i = 0; i < 10; ++i) {
    m = db._query("FOR u IN @@results FILTER u.started RETURN 1", {
      '@results': 'results'
    }).count();

    print(m + " workers are up and running");

    if (m === w.length) {
      break;
    }

    sleep(30);
  }

  if (m < w.length) {
    print("cannot start enough workers (want", w.length + ",", "got", m + "),",
      "please check number V8 contexts");
    throw new Error("cannot start workers");
  }

  if (opts.gnuplot) {
    fs.write(fs.join("out", "kills.plot"),
      `
set terminal png size 1024,1024
set size ratio 0.3
set output "out/kills.png"

set multiplot layout 4, 1 title "Killing Queries Stress Test" font ",14"

set autoscale
set logscale y
set key outside
set xlabel "runtime in seconds"

set ylabel "inserter"
plot \
  "out/kills.csv" using 1:2 title "count" with lines lw 2, \
  '' using 1:3 title "success" with lines, \
  '' using 1:4 title "failures" with lines

set ylabel "updater"
plot \
  "out/kills.csv" using 1:5 title "count" with lines lw 2, \
  '' using 1:6 title "success" with lines, \
  '' using 1:7 title "failures" with lines

set ylabel "remover"
plot \
  "out/kills.csv" using 1:8 title "count" with lines lw 2, \
  '' using 1:9 title "success" with lines, \
  '' using 1:10 title "failures" with lines

set ylabel "killer"
plot \
  "out/kills.csv" using 1:11 title "count" with lines lw 2, \
  '' using 1:12 title "success" with lines, \
  '' using 1:13 title "failures" with lines
`);
  }

  let count = 0;

  while (!countDone()) {
    ++count;
    statistics(opts);

    if (opts.gnuplot && count % 6 === 0) {
      print("generating image");
      gnuplot();
    }

    sleep(10);
  }

  statistics(opts);

  if (opts.gnuplot) {
    gnuplot();
  }

  return true;
};