const fs = require('fs');
var BasicQueue = require('better-queue');
var MemoryStore = require('better-queue-memory');
var SqlStore = require('better-queue-sql');
var _ = require('lodash');

// Improvements to SqlStore
SqlStore.prototype.getTaskStates = function(n, fields, cb) {
 var self = this;
 var first = true;
 var q = self.adapter.knex(self.tableName).orderBy('lock', 'desc').orderBy('priority', 'DESC').orderBy('added', first ? 'ASC' : 'DESC');
 q = (fields)? q.select(fields) : q.select();
 q = (n > 0)? q.limit(n) : q;
 q.then(function(rows) {
 cb(null, rows);
 }).catch(function(error) {
 cb(error, null);
 });
};

// Improvements to MemoryStore
MemoryStore.prototype.getTaskStates = function(n, fields, cb) {
 var self = this;
 var running = _.flatMap( self._running, (tasks, lockId) => {
 return _.map( tasks, (task, taskId) => {
 return {
 id: taskId,
 task: task,
 lock: lockId,
 priority: self._priorities[taskId]
 };
 });
 });
 var queued = this._queue.map( taskId => {
 return {
 id: taskId,
 task: self._tasks[taskId],
 priority: self._priorities[taskId]
 };
 });

 var all = _.concat([], running, queued);
 all = (n > 0)? _.take(all, n) : all;
 if (cb) {
 cb(null, all);
 }
 return all;
};


// MemoryStored that is backed by a sqlstore
// Always pushes changes to backend store
// But keeps a cache of queue tasks
function CachedStore(store) {
 this._store = store;
 this._taskIds = []; // Array of taskIds
 this._taskStates = []; // Array of task states
 this._taskStatesById = {}; // TaskId to task state
}

CachedStore.prototype.connect = function (cb) {
 var self = this;
 this._store.connect( self.__wrapWithUpdateQueue(cb) );
};

CachedStore.prototype.__wrapWithUpdateQueue = function(cb) {
 var self = this;
 return function(err, res) {
 if (!err) {
 self._store.getTaskStates(0, null, function(err, rows) {
 self._taskStates = rows || [];
 self._taskIds = _.map(self._taskStates, 'id');
 self._taskStatesById = _.keyBy(self._taskStates, 'id');
 console.log('In queue: ' + self._taskStates.length);
 cb(null, res);
 });
 } else {
 cb(err, res);
 }
 };
};

CachedStore.prototype.getTask = function (taskId, cb) {
 return this._store.getTask(taskId, cb);
};

CachedStore.prototype.deleteTask = function (taskId, cb) {
 return this._store.deleteTask(taskId, this.__wrapWithUpdateQueue(cb));
};

CachedStore.prototype.putTask = function (taskId, task, priority, cb) {
 return this._store.putTask(taskId, task, priority, this.__wrapWithUpdateQueue(cb));
};

CachedStore.prototype.takeFirstN = function (n, cb) {
 return this._store.takeFirstN(n, this.__wrapWithUpdateQueue(cb));
};

CachedStore.prototype.takeLastN = function (n, cb) {
 return this._store.takeLastN(n, this.__wrapWithUpdateQueue(cb));
};

CachedStore.prototype.getLock = function (lockId, cb) {
 return this._store.getLock(lockId, cb);
};

CachedStore.prototype.getRunningTasks = function (cb) {
 return this._store.getRunningTasks(cb);
};

CachedStore.prototype.releaseLock = function (lockId, cb) {
 return this._store.releaseLock(lockId, this.__wrapWithUpdateQueue(cb));
};

function Queue(process, opts) {
 opts = opts || {};
 BasicQueue.call(this, process, opts);
 this._stateFile = opts.stateFile;
 this.loadState();
}

Queue.prototype = Object.create(BasicQueue.prototype);
Queue.prototype.constructor = Queue;

// Improvements to the queue
Queue.prototype.size = function() {
 var taskIds = this.taskIds();
 if (this.length !== taskIds.length) {
 console.log('Got taskIds length=%d, cached length=%d', taskIds.length, this.length);
 }
 return taskIds.length;
};

Queue.prototype.taskIds = function() {
 var tasks = this.list();
 if (tasks) {
 return _.map(tasks, 'id');
 }
};

Queue.prototype.list = function() {
 var store = this._store;
 if (store._taskStates) {
 return store._taskStates;
 } else if (store._queue && store._tasks) {
 var tasks = store.getTaskStates();
 return tasks;
 }
};

Queue.prototype.firstTask = function() {
 var tasks = this.list();
 if (tasks && tasks.length > 0) {
 return tasks[0];
 }
};

Queue.prototype.lastTask = function() {
 var tasks = this.list();
 if (tasks && tasks.length > 0) {
 return tasks[tasks.length-1];
 }
};

Queue.prototype.maxPriority = function() {
 var tasks = this.list();
 return _.maxBy(tasks, 'priority').priority;
};

Queue.prototype.minPriority = function() {
 var tasks = this.list();
 return _.minBy(tasks, 'priority').priority;
};

Queue.prototype.clear = function() {
 // Clears the queue
 this.pause();
 var taskIds = this.taskIds();
 for (var i = 0; i < taskIds.length; i++) {
 console.log('cancel %s', taskIds[i]);
 this.cancel(taskIds[i]);
 }
 this.resume();
};

Queue.prototype.isPaused = function() {
 return this._stopped;
};

Queue.prototype.status = function() {
 return { isPaused: this.isPaused(), size: this.size() };
};

Queue.prototype.saveState = function() {
 if (this._stateFile) {
 var state = {
 isPaused: this.isPaused()
 };
 fs.writeFileSync(this._stateFile, JSON.stringify(state), 'utf-8');
 }

};


Queue.prototype.loadState = function() {
 if (this._stateFile && fs.existsSync(this._stateFile)) {
 var state = fs.readFileSync(this._stateFile, 'utf-8');
 if (state) {
 state = JSON.parse(state);
 if (state.isPaused) {
 this.pause();
 }
 }
 }
};

Queue.getCachedSqlStore = function(opts) {
 var store = new SqlStore(opts);
 var cached = new CachedStore(store);
 return cached;
};

module.exports = Queue;