# Source: Operation.js

    "use strict";

    var Shared = require('./Shared'),
    	Path = require('./Path');

    /**
     * The operation class, used to store details about an operation being
     * performed by the database.
     * @param {String} name The name of the operation.
     * @constructor
     */
    var Operation = function (name) {
    	this.pathSolver = new Path();
    	this.counter = 0;
    	this.init.apply(this, arguments);
    };

    Operation.prototype.init = function (name) {
    	this._data = {
    		operation: name, // The name of the operation executed such as "find", "update" etc
    		index: {
    			potential: [], // Indexes that could have potentially been used
    			used: false // The index that was picked to use
    		},
    		steps: [], // The steps taken to generate the query results,
    		time: {
    			startMs: 0,
    			stopMs: 0,
    			totalMs: 0,
    			process: {}
    		},
    		flag: {}, // An object with flags that denote certain execution paths
    		log: [] // Any extra data that might be useful such as warnings or helpful hints
    	};
    };

    Shared.addModule('Operation', Operation);
    Shared.mixin(Operation.prototype, 'Mixin.ChainReactor');

    /**
     * Starts the operation timer.
     */
    Operation.prototype.start = function () {
    	this._data.time.startMs = new Date().getTime();
    };

    /**
     * Adds an item to the operation log.
     * @param {String} event The item to log.
     * @returns {*}
     */
    Operation.prototype.log = function (event) {
    	if (event) {
    		var lastLogTime = this._log.length > 0 ? this._data.log[this._data.log.length - 1].time : 0,
    			logObj = {
    				event: event,
    				time: new Date().getTime(),
    				delta: 0
    			};

    		this._data.log.push(logObj);

    		if (lastLogTime) {
    			logObj.delta = logObj.time - lastLogTime;
    		}

    		return this;
    	}

    	return this._data.log;
    };

    /**
     * Called when starting and ending a timed operation, used to time
     * internal calls within an operation's execution.
     * @param {String} section An operation name.
     * @returns {*}
     */
    Operation.prototype.time = function (section) {
    	if (section !== undefined) {
    		var process = this._data.time.process,
    			processObj = process[section] = process[section] || {};

    		if (!processObj.startMs) {
    			// Timer started
    			processObj.startMs = new Date().getTime();
    			processObj.stepObj = {
    				name: section
    			};

    			this._data.steps.push(processObj.stepObj);
    		} else {
    			processObj.stopMs = new Date().getTime();
    			processObj.totalMs = processObj.stopMs - processObj.startMs;
    			processObj.stepObj.totalMs = processObj.totalMs;
    			delete processObj.stepObj;
    		}

    		return this;
    	}

    	return this._data.time;
    };

    /**
     * Used to set key/value flags during operation execution.
     * @param {String} key
     * @param {String} val
     * @returns {*}
     */
    Operation.prototype.flag = function (key, val) {
    	if (key !== undefined && val !== undefined) {
    		this._data.flag[key] = val;
    	} else if (key !== undefined) {
    		return this._data.flag[key];
    	} else {
    		return this._data.flag;
    	}
    };

    Operation.prototype.data = function (path, val, noTime) {
    	if (val !== undefined) {
    		// Assign value to object path
    		this.pathSolver.set(this._data, path, val);

    		return this;
    	}

    	return this.pathSolver.get(this._data, path);
    };

    Operation.prototype.pushData = function (path, val, noTime) {
    	// Assign value to object path
    	this.pathSolver.push(this._data, path, val);
    };

    /**
     * Stops the operation timer.
     */
    Operation.prototype.stop = function () {
    	this._data.time.stopMs = new Date().getTime();
    	this._data.time.totalMs = this._data.time.stopMs - this._data.time.startMs;
    };

    Shared.finishModule('Operation');
    module.exports = Operation;