var _ = require("lodash"),
    util = require('util'),
    CronJob = require('cron').CronJob,
    fs = require("fs"),
    url = require("url"),
    md5 = require('MD5');

var _dur_re = /((\d+)d)?((\d+)h)?((\d+)m)?((\d+)s)?/;
var _dur_seclabel = {
    'd' : 86400,
    'h' : 3600,
    'm' : 60,
    's' : 1
};
    
var ELEMENT_SEP = ".";
var RANGE_SEP = " ... ";
var DURATION_SEP = " + ";
var PERIOD_SEP = " / ";
var SET_SEP = ",";


var KIND_CAPABILITY = "capability"
var KIND_SPECIFICATION = "specification"
var KIND_RESULT = "result"
var KIND_RECEIPT = "receipt"
var KIND_REDEMPTION = "redemption"
var KIND_INDIRECTION = "indirection"
var KIND_WITHDRAWAL = "withdrawal"
var KIND_INTERRUPT = "interrupt"
var KIND_EXCEPTION = "exception"


var _dow_label = ['mo', 'tu', 'we', 'th', 'fr', 'sa', 'su'];

var __DEFAULT_REGISTRY_FILE = "./registry.json";

var time = function(){
}

time.TIME_PAST      = "past";
time.TIME_NOW       = "now";
time.TIME_FUTURE    = "future"
time.TIME_INVALID    = "invalid";

time.time_past = function(strVal){
    return (strVal === time.TIME_PAST);
}

time.time_now = function(strVal){
     return (strVal === time.TIME_NOW);
}

time.time_future = function(strVal){
   return (strVal === time.TIME_FUTURE);
}

time.parse_time = function(valStr){
    if (!valStr)
        return null;
    switch(valStr){
        case time.TIME_PAST:
            return time.TIME_PAST;
            break;
        case time.TIME_FUTURE:
            return time.TIME_FUTURE;
            break;
        case time.TIME_NOW:
            return time.TIME_NOW;
            break;
        default:
            try{
                return  new Date(valStr);
            }catch(e){
                return time.TIME_INVALID;
            }
    }
}

time.unparse_time = function(valts){
    if (!valts)
        return time.TIME_INVALID;
    if (valts instanceof Date)
             return  valts.toString();
   switch(valStr){
        case time.TIME_PAST:
            return time.TIME_PAST;
            break;
        case time.TIME_FUTURE:
            return time.TIME_FUTURE;
            break;
        case time.TIME_NOW:
            return time.TIME_NOW;
            break;
        default:
            return time.TIME_INVALID;
    } 
    
}

time.parse_dur = function(valstr){
    if (!valstr)
        return null
    var valsec = 0;
    m = _dur_re.exec(valstr);
    var durSecLabels = _.keys(_dur_seclabel);

    for (var i=1 ; i<5; i++){
        if (!isNaN(m[2*i])){
            valsec += (parseInt(_dur_seclabel[durSecLabels[i-1]]) * parseInt(m[2*i]));
        }
    }
    return valsec;
}

time.unparse_dur = function(valtd){
    var valstr = "";
    var durSecLabels = _.keys(_dur_seclabel);

    for (var i=1 ; i<5; i++){
        if (valtd >= _dur_seclabel[durSecLabels[i-1]]){
            valunit = parseInt(valtd / _dur_seclabel[durSecLabels[i-1]]);
            valstr += valunit.toString() + durSecLabels[i-1];
            valtd -= valunit * _dur_seclabel[durSecLabels[i-1]]
        }
    }
    if (!valstr.length)
        valstr = "0s";
    return valstr;
}
time.unParseDur = time.parse_dur;

time.total_seconds = function(valInt){
    return valInt;
}

time.areEqual = function(date_A , date_B){

    if ((_.isString(date_A)) && ((date_A == time.TIME_FUTURE) ||  (date_A == time.TIME_NOW) || (date_A == time.TIME_PAST))  ){
        return (date_A === date_B);
    }
    
    var dA , dB;

    if (!_.isDate(date_A))
        dA = new Date(date_A);
    else    
        dA = date_A;
    if (!_.isDate(date_B))
        dB = new Date(date_B);
    else    
        dB = date_B;
    return (dB.getTime() === dA.getTime());
}

var when = function(valstr , a , b , d , p){
    this.setDate("_a" , a || null);
    this.setDate("_b" , b || null);
   
    this._d = d || null; // duration
    this._p = p || null; // period

    if (valstr)
        this.parse(valstr)
}

when.prototype.setDate = function(whichDate , value){
    if (!value){
        this[whichDate] = null;
        return;
    }
     if (value && (value === time.TIME_PAST || value === time.TIME_NOW || value === time.TIME_FUTURE))
        this[whichDate] = value ;
    else
        (_.isDate(value))?this[whichDate]=value:this[whichDate] = new Date(value);
}

when.prototype.parse = function(valstr){

        var valsplit = valstr.split(PERIOD_SEP);
        if (valsplit.length > 1){
            this._p = time.parse_dur(valsplit[1]);
        }else
            this.p = null;

        valsplit = valsplit[0].split(DURATION_SEP); //+
       
        if (valsplit.length > 1){
            this._d = time.parse_dur(valsplit[1]);
            this.setDate("_a" , valsplit[0]);
            this._b = null;
        }else{
            this._d = null
            valsplit = valsplit[0].split(RANGE_SEP);
             if (valsplit.length > 1){
                 this.setDate("_a" , time.parse_time(valsplit[0]));
                 this.setDate("_b" , time.parse_time(valsplit[1]));
            }
            else{
                this.setDate("_a" , time.parse_time(valsplit[0]));

                this._b = null;
            }
        }   
}

when.prototype.is_immediate = function(){
    return this._a === time.TIME_NOW;
}
when.prototype.is_forever = function(){
    return this._a === time.TIME_FUTURE;
}
when.prototype.is_past = function(){
   return ((this._a === time.TIME_PAST) && (this._b === time.TIME_NOW));
}
when.prototype.is_future = function(){
   return ((this._a === time.TIME_NOW) && (this._b === time.TIME_FUTURE));
}
when.prototype.is_infinite = function(){
   return ((this._a === time.TIME_PAST) && (this._b === time.TIME_FUTURE));
}

when.prototype.is_definite = function(){
    if (!this._b)
        return _.isNumber(this._d);
    else
        return ((this._a instanceof Date) && (this._b instanceof Date));
}

when.prototype.is_singleton = function(){
    return (this._a && !this._b && !this._d);
}

when.prototype._datetimes = function(tzero){
    var start=null,end=null;
    if (!tzero)
        tzero = new Date();
    else    
        (_.isDate(tzero))?tzero=tzero:tzero = new Date(tzero);
    switch(this._a){
        case time.TIME_NOW:
            start = tzero;
            break;
        case time.TIME_PAST:
            start = null;
            break;
        default:
            start = this._a;
    }
    switch (this._b){
        case (time.TIME_FUTURE):
            end = null;
            break;
        case (null):
            if (this._d){
                end = new Date((start.getTime() + this._d*1000));//_d is in seonds, getTime in millisec
            }
            else
                end = start;
            break;
        default:
            end = this._b;
    }
    return { "start":start , 
             "end" : end};
}

when.prototype.duration = function(tzero){
    if (this._d)
        return this._d;
    if (this._b === time.TIME_FUTURE)
            return null;
    if (!this._b)
        return 0;
    else{
        var se = this._datetimes(tzero);

       return (se.end.getTime() - se.start.getTime());
    }
}

when.prototype.timer_delays = function(tzero){
    var se=null,sd=null,ed=null;
    if (!tzero) 
        tzero = new Date();

    var se = this._datetimes(tzero);

    sd = time.total_seconds(se.start - tzero);
    if (sd < 0)
        sd = 0;

    if (this._b && (!time.time_future(this._b))){
        ed = time.total_seconds(se.end - tzero);
    }else{
        if (this._d){
            ed = (sd + time.total_seconds(this._d)*1000); // everything in millisec
        }
    }

    if (ed && ed<0){
        sd = null;
        ed = null;
    }
    
    return {
        sd: sd/1000,
        ed: ed/1000
    };
}


when.prototype.period = function(){
    return this._p;
}

when.prototype.in_scope = function(t, tzero){
        return ((this.sort_scope(t, tzero) == 0));
}

when.prototype.sort_scope = function(t, tzero){
    if (t === time.TIME_NOW){
        if ((this._a === time.TIME_NOW) || (this._b === time.TIME_NOW))
            return 0;
        else{
            if (!tzero)
                tzero = new Date();
             t = tzero;
        }   
    }

    var se = this._datetimes(tzero);
    if (se.start && (t < se.start))
        return time.total_seconds(t - se.start);
    else{
        if (se.end && (t > se.end))
            return time.total_seconds(t - se.end);
        else
            return 0;
    } 
}

when.prototype.follows = function(s,tzero){
    if ((s.in_scope(this._a, tzero)) || (s.in_scope(this._b, tzero)))
        return true;
    return false
}       

var when_infinite = new when(null , time.TIME_PAST, time.TIME_FUTURE);

var Scheduler = function(){
    this.jobs = []; // Array of all scheduled jobs
}

Scheduler.prototype.addJob = function(cronTime, onTick, onComplete){
    var job = new CronJob(cronTime, onTick, onComplete,true);
    this.jobs.push(job);
}

var Primitive = function(type){
    this.setType(type);
}

var PRIMITIVES = {
     "UNDEF":{
        label: "undef",
        isValid: function(value){return true;},
        unParse: function(value){ return value; },
        parse: function(value){return value}
     },
    "STRING":{
        label: "string",
        isValid: function(value){ return _.isString(value); },
        unParse: function(value){ return value; },
        parse: function(value){return value},
        constraints : {
            "range" : {
                met_by : function(value){
                    return ((this._param.valA <= value) && (this._param.valB >= value));
                }
            },
            "list" : {
                 met_by : function(value){
                    return (_.contains(this._param, value));
                },
            }
        }
     },
    "BOOL":{
        label: "bool",
        isValid: function(value){return _.isBoolean(value);},
        unParse: function(value){
                    if (value)
                        return 'true';
                    return 'false';
                },
        parse: function(value){
                if (value.toLowerCase() === "true")
                    return true;
                return false;
        }
     },
    "NATURAL":{
        label: "natural",
        isValid: function(value){return utility.isInt(value);},
        unParse: function(value){return value.toString();},
        parse: function(value){return parseInt(value);}
     },
    "REAL":{
        label: "real",
        isValid: function(value){return utility.isReal(value); },
        unParse: function(value){return value.toString();   },
        parse: function(value){return parseFloat(value); }
     },
    "IP":{
        label: "ip",
        isValid: function(value){return (/^(\d{1,3}\.){3,3}\d{1,3}$/.test(value))},
        unParse: function(value){ return value; },
        parse: function(value){return value}
     },
    "IP6":{
        label: "ip6",
        isValid: function(value){return (/^[A-Fa-f0-9:]+$/.test(value)) },
        unParse: function(value){return value;},
        parse: function(value){return value}
     },
    "URL":{
        label: "url",
        isValid: function(value){return url.parse(value); },
        unParse: function(value){ return value; },
        parse: function(value){return value}
     },
    "TIME":{
        label: "time",
        isValid: function(value){return ((!_.isNaN(Date.parse(value))) || ( (value == time.TIME_PAST ) || (value == time.TIME_NOW ) || (value == time.TIME_FUTURE ) )); },
        unParse: function(value){ return time.parse_time(value);},
        parse: function(value){return time.parse_time(value); }
     }

}

var pk = _.keys(PRIMITIVES);

Primitive.UNDEF = pk[0];
Primitive.STRING = pk[1];
Primitive.BOOL = pk[2];
Primitive.NATURAL = pk[3];
Primitive.REAL = pk[4];
Primitive.IP = pk[5];
Primitive.IP6 = pk[6];
Primitive.URL = pk[7];
Primitive.TIME = pk[8];

Primitive.VALUE_NONE = "*";

Primitive.prototype.setType = function(type){

   if ((!type) || !(PRIMITIVES[type]))
        this.type = this.UNDEF;
    else
        this.type = type; // the type of primitive the istance is.
}

Primitive.knownPrimitive = function(prim){
    return (_.indexOf(pk, prim.toUpperCase()) != -1);
}

Primitive.prototype.parse = function(sval){
    if (sval === Primitive.VALUE_NONE)
        return Primitive.VALUE_NONE;
     if ((this.type != Primitive.BOOL ) && (!sval)){
        return null;
    }
    return (PRIMITIVES[this.type].parse(sval)) ;
}

Primitive.prototype.unparse = function(val){
    if ((this.type != Primitive.BOOL ) && (!val)){
        return null;
    }
    return (PRIMITIVES[this.type].unParse(val)) ;
}

Primitive.prototype.isValid = function(val){
    if ((this.type != Primitive.BOOL ) && (!val)){
        return null;
    }
    return (PRIMITIVES[this.type].isValid(val)) ;
}

var Element = function(config){

    if (!config || _.isUndefined(config)){
        config = {};
    }
    if (_.isObject(config)){
        this._name = config.name || "Undef";
        (config.prim)?this._prim = config.prim.toUpperCase():this._prim = Primitive.UNDEF;
        this._desc = config.desc || "";  
    }else{
        var el = Element.getFromName(config);
        this._name = el.name || "Undef";
        this._prim = el.prim.toUpperCase() || Primitive.UNDEF;
        this._desc = el.desc || "";  
    }

    this._constrains = { __uniqueID__ : 0,
                        details : {}}; 
}

_element_registry = {};

Element.initialize_registry = function(filename){
    var fn = filename || __DEFAULT_REGISTRY_FILE,
        registry = "";
    try {
        registry = fs.readFileSync(fn);
        _element_registry = JSON.parse(registry);
    }
    catch (err) {
        console.log('There has been an error parsing the registry file.( '+fn+')');
        console.log(err);
    }
}

Element.getFromName = function(name){
    var names = name.split(".");
    var ret = _element_registry;
    for (el in names){
        if (ret[names[el]])
            ret = ret[names[el]];
        else    
            throw new Error("Undefined element in registry:"+name);
    }
    return ret;
}

Element.prototype.parse = function(sval){
    this._prim.parse(sval);
}

Element.prototype.unparse = function(val){
    this._prim.unparse(val);
}

Element.prototype.compatible_with = function(rval){
    return this._name == rval;
}

Element.prototype.transformation_to = function(rval){
    return function(rval){ return rval };
}

var Constraints = function(config){
    this._prim = Primitive.UNDEF; // Default to UNDEF primitive type
    this._name = "Constraint"; 
    this._type = Constraints.UNDEF;
    this.met_by = function(val){return true;}
    this.single_value = function(){return false;}
    
    
    if (_.isObject(config)){
        if (config.prim && Primitive.knownPrimitive(config.prim))
            this._prim=config.prim.toUpperCase();
        if (config.name)
                this._name = config.name;
        if (config.type)
                this._type = config.type;
         if (config.param)
                this._param = config.param;
    }

    if (PRIMITIVES[this._prim].constraints && PRIMITIVES[this._prim].constraints[this._type]){
        if (PRIMITIVES[this._prim].constraints[this._type].met_by){
            this.met_by = PRIMITIVES[this._prim].constraints[this._type].met_by;
        }
        if (PRIMITIVES[this._prim].constraints[this._type].single_value)
            this.single_value = PRIMITIVES[this._prim][this._type].constraints.single_value;
    }
}

Constraints.UNDEF = "undef";
Constraints.RANGE = "range";
Constraints.LIST = "list"; // List of acceptable values

Constraints.CONSTRAINT_ALL = "*"

Constraints.parse_constraint = function(prim , sval){
    if (_.isUndefined(prim) || _.isUndefined(sval))
        throw new Error("Missing parameter in parse_constraints");
    var ret = null; // If no case applies, return an UNDEF constraints
    if (sval === Constraints.CONSTRAINT_ALL)
        ret = Constraints.CONSTRAINT_ALL;

    else if (sval.indexOf(RANGE_SEP) > 0){
        var sp = sval.split(RANGE_SEP);
        options = {
            type: Constraints.RANGE,
            prim: prim || Primitive.UNDEF,
            name: "",
            param: {valA: sp[0],
                    valB: sp[1]}
        }
        ret =  new Constraints(options);
    }

    else if (sval.indexOf(SET_SEP) > 0){
        var values = sval.split(SET_SEP);
        options = {
            type: Constraints.LIST,
            prim: prim || Primitive.UNDEF,
            name: "",
            param: values
        }
        ret = new Constraints(options);
    }
    return ret || new Constraints();
}

Element.prototype.addConstraint = function(config){
    var self = this , cons;
    
    if (!_.isObject(config)){
        cons = Constraints.parse_constraint(self._prim , config);

        if (cons._prim !== self._prim)
            throw new Error("Error adding constraints. The contraints type is incompatible with element type");
    }else{
        if ((_.isUndefined(config.type))){
            throw new Error('Constrain: missing param');
        }
        var params = config.constraintOptions || {};
        var options = {
            type: config.type,
            prim: self._prim.toUpperCase(),
            name: config.name,
            param: params
        }
        cons = new Constraints(options);
    }

    this._constrains.details[this._constrains.__uniqueID__] = cons;
    var ret = this._constrains.__uniqueID__;
    this._constrains.__uniqueID__ += 1; // Next unique ID 
    return ret; // The internal ID
}

Element.prototype._clear_constraint = function(constraintId){
    if (!_.isUndefined(constraintId))
        delete this._constrains.details[constraintId];
    else{
         this._constrains.details = {};
         this._constrains.__uniqueID__ = 0;
    }
}

Element.prototype.setConstraintsName = function(constraintsId , name){
   this._constrains.details[constraintsId]._name = name || 'Constraint';
}

Element.prototype.getConstraints = function(constraintsId){
    if (_.isUndefined(constraintsId))
        return this._constrains.details;
    else
        return this._constrains.details[constraintsId];
}

Element.prototype.met_by = function(value , constraintsId){
    if (_.isUndefined(constraintsId)){
        var ret = true;
        for (constr in this._constrains.details){
            ret = ret && (this._constrains.details[constr].met_by(value));

            if (!ret)
                    return ret;
        }
        return ret;
    }
    else{
        return(this._constrains.details[constraintsId].met_by(value));
    }
}

Element.prototype.isValid = function(value){
    return PRIMITIVES[this._prim].isValid(value);
}

var Parameter = function(el , value){
    if (el instanceof Element)
        this._element = el;
    else if (_.isString(el))
        this._element = new Element(el);
    if (!this._element)
        throw new Error("Parameter el is not valid");
    this.setValue(value);
}

Parameter.prototype.hasValue = function(){
    return (!(_.isNull(this._value) || _.isUndefined(this._value)));
}

Parameter.prototype.setValue = function(val){
    if (_.isUndefined(val))
        return;
    if ((this._element.isValid(val)) && (this._element.met_by(val)))
        this._value = val;
    else
        throw new Error("Value is not valid for this parameter");
}
Parameter.prototype.getValue = function(){
    return this._value;
}
Parameter.prototype.getConstraints = function(){
    return this._element.getConstraints();
}

Parameter.prototype._clear_constraint = function(constraintId){
    this._element._clear_constraint(constraintId);
}

Parameter.prototype.to_dict = function(){
    return JSON.stringify(this);
}

var Metavalue = Parameter;

var ResultColumn = function(el , value){
    this._vals = {};
    if (el instanceof Element)
        this._element = el;
    else if (_.isString(el))
        this._element = new Element(el);
    if (!this._element)
        this._element = new Element(); // Try to create a new undefined element
    this.setValue(value);
}

ResultColumn.prototype.setValue = function(val){
    if (!val || _.isUndefined(val))
        val = {};
    if (_.isObject(val)){
        for (el in val){
            if ((this._element.isValid(val[el])) && (this._element.met_by(val[el])))
                this._vals[el] = val[el];
             else{
                    throw new Error("Value is not valid for this parameter");
             }
        }
    }else
        throw new Error("You should provide a json to ResultColumn.prototype.setValue");
}
ResultColumn.prototype.__setitem__ == ResultColumn.prototype.setValue;

ResultColumn.prototype.delValue = function(key){
    if (this._vals[key])
        delete this._vals[key];
}
ResultColumn.prototype.__delitem__ == ResultColumn.prototype.delValue;

ResultColumn.prototype.clear = function(){
    this._vals = {};
}

ResultColumn.prototype.getValue = function(key){
    if (_.isUndefined(key)){
        return this._vals;
    }
    else
        return this._vals[key];
}

var Statement = function(config){
    if (!config)
        config = {};
    if (config.dictval)
        config = this._from_dict(config.dictval);

    this._params = config.params || config._params || {};
    this._metadata = config.metadata || config._metadata || {};
    this._resultcolumns = config.resultcolumns || config._resultcolumns || {};
    this._link = config.link || config._link || null;
    this._verb = config.verb || config._verb || Statement.VERB_MEASURE;
    this._label = config.label || config._label || null;
    this._when = config.when || config._when || when_infinite;
    this._token = config.token || config._token || null;
    this._schedule = config.schedule || config._schedule || null; // completely ignored unless this is a specification
}

Statement.VERB_MEASURE = "measure";
Statement.VERB_QUERY = "query";
Statement.VERB_COLLECT = "collect";
Statement.VERB_STORE = "store";

Statement.prototype.add_parameter = function(parameter_name , element ,  value){
    this._params[parameter_name] = new Parameter(element , value);

}

Statement.prototype.add_parameter_from_dict = function(dict , param_name){
    var new_param = JSON.parse(dict);
    if (! new_param instanceof Parameter)
        throw new Error("The dictionary for the param is not valid");
    this._params[param_name] =  JSON.parse(dict);
}


Statement.prototype.has_parameter = function(parameter_name){
    return(_.contains(_.keys(this._params),parameter_name));
}

Statement.prototype.parameter_names = function(){
    return _.keys(this._params);
}

Statement.prototype.count_parameters = function(){
    return (_.keys(this._params)).length;
}

Statement.prototype.get_parameter_value = function(param_name){
    return this._params[param_name].getValue() || null;
}

Statement.prototype.get_parameter_constraints = function(param_name){
    return this._params[param_name].getValue() || null;
}

Statement.prototype.set_parameter_value = function(param_name , value){
    if (this._params[param_name])
        this._params[param_name].setValue(value);
}

Statement.prototype.del_parameter = function(param_name){
    if (this._params[param_name])
        delete this._params[param_name];
}

Statement.prototype.add_metadata = function(meta_name , value){
        this._metadata[meta_name] = value || "";
}

Statement.prototype.has_metadata = function(meta_name ){
     return(_.contains(_.keys(this._metadata),meta_name));
}

Statement.prototype.get_metadata_value = function(meta_name){
      return(this._metadata[meta_name]);
}

Statement.prototype.metadata_names = function(){
    return _.keys(this._metadata);
}

Statement.prototype.count_metadata = function(){
    return _.keys(this._metadata).length;
}

Statement.prototype.set_metadata_value = function(meta_name , value){
    if (this._metadata[meta_name])
        this._metadata[meta_name]=value; // noextra check on metaData
}

Statement.prototype.add_result_column = function(elem_name , element){
    this._resultcolumns[elem_name] = new ResultColumn(element);
}

Statement.prototype.set_result_column_value = function(result_column , value){
    this._resultcolumns[result_column].setValue(value);
}

Statement.prototype.count_result_rows = function(result_column){
    return(_.keys(this._resultcolumns[result_column]._vals).length)
}

Statement.prototype.result_column_names = function(){
    return _.keys(this._resultcolumns);
}

Statement.prototype.get_result_column_value = function(rc_name , key){
    return this._resultcolumns[rc_name].getValue(key);
}

Statement.prototype.count_result_columns = function(rc_name , value){
    return this.result_column_names().length;
}

Statement.prototype.has_result_columns = function(rc_name){
    return(_.contains(_.keys(this._resultcolumns),rc_name));
}

Statement.prototype.get_link = function(){
    return this._link;
}

Statement.prototype.set_link = function(link){
    this._link = link;
}

Statement.prototype.get_label = function(){
    return this._label;
}

Statement.prototype.set_label = function(label){
    this._label = label;
}

Statement.prototype.get_when = function(){
    return this._when;
}

Statement.prototype.set_when = function(wh){
    var w = null;
    if (wh instanceof when)
        w = wh;
    else{
        try{
            w = new when(wh);
        }catch(e){

            w = new when(when.NOW);
        }
    }
    this._when = w;
}

Statement.prototype._schema_hash = function(){
    return md5("p " + " " + _.reduce(_.sortBy(this.parameter_names()) , function(concat, param){return(concat+param)})+ " r " + " " + _.reduce(_.sortBy(this.result_column_names()) , function(concat, rc){return(concat+rc)} ));
}

Statement.prototype._pv_hash = function(){
        var spk = _.sortBy(_.keys(this._params)),
            spv = [];
        for (k in spk){
            spv.push(this.get_parameter_value(spk[k]));
        }
        tstr = this._verb + " w " + JSON.stringify(this._when) + 
               " pk " + " " + _.reduce(spk , function(concat, param){return(concat+param)}) + 
               " pv " + " " +  _.reduce(spv , function(concat, param){return(concat+param)}) + 
               " r " + " " + _.reduce(_.sortBy(this.result_column_names()) , function(concat, param){return(concat+param)} );
        return md5(tstr);
}

Statement.prototype._mpcv_hash = function(){
        var spk = _.sortBy(this.parameter_names()),
            spv = [],
            spc = [],
            smk = _.sortBy(this.metadata_names()),
            smv = [];

        for (k in spk){
            spv.push(this.get_parameter_value(spk[k]));
            spc.push(this._params[spk[k]].getConstraints());
        }

        for (k in smk){
            smv.push(this.get_metadata_value(smk[k]));
        }
       
        var tstr = this._verb + " w " + JSON.stringify(this._when) +
               " pk " + " " + _.reduce(spk , function(concat, param){return(concat+param)}) +
               " pc " + " " + _.reduce(spc , function(concat, param){return(concat+param)}) + " pv " + " " + 
                _.reduce(spv , function(concat, param){return(concat+param)}) 
               " mk " + " " + _.reduce(smk , function(concat, param){return(concat+param)}) + " mv " + " " + 
                _.reduce(smv , function(concat, param){return(concat+param)})
               " r " + " " + _.reduce(_.sortBy(this.result_column_names()) , function(concat, param){return(concat+param)} );
        return md5(tstr);
}

Statement.prototype._default_token = function(){
      return this._mpcv_hash();
}

Statement.prototype.get_token = function(){
    if (!this._token)
            this._token = this._default_token();
    return this._token;
}

Statement.prototype._result_rows = function(resultColumn){
    if (_.isUndefined(resultColumn))
        throw new Error("resultColumn should be a valid column in _result_rows");
    var rows = [],
        rck = _.keys(this.get_result_column_value(resultColumn));
    
        for (var i = 0 ; i< this.count_result_rows(resultColumn) ; i++){
            rows.push(this._resultcolumns[resultColumn]._vals[rck[i]]);
        }
    return rows;
}

Statement.prototype.to_dict = function(){
    return JSON.stringify(this);
}

Statement._from_dict = function(d){
    return JSON.parse(d);
}

Statement.prototype.validate = function(){
    var pn = this.parameter_names();
    for (var i=0 ; i< this.count_parameters() ; i++){
        if (!this._params[pn[i]].hasValue())
            return false
    }
    return true;
}

Statement.prototype._clear_constraints = function(){
    var pn = this.parameter_names();
    for (var i=0 ; i< this.count_parameters() ; i++){
        if (!this._params[pn[i]]._clear_constraint())
            return false
    }       
}

var Capability = function(config){
    Statement.apply( this, arguments ); // Call the Statement (super) contructor
}

util.inherits(Capability, Statement);

Capability.prototype.kind_str = function(){
    return KIND_CAPABILITY;
}

Capability.prototype._params_from_dict = function(d){
    var pn = _.keys(d);
    for (i=0 ; i<d.length ; i++){
        Capability.add_parameter_from_dict(d[pd[i]]);
    }
}

var Specification = function(config){
    Statement.apply( this, arguments ); // Call the Statement (super) contructor
    this._schedule = config.schedule || sconfig._schedule || null;
    if (config.capability){

        this._verb = config.capability._verb || config.capability.verb || null;
        this._label = config.capability._label || config.capability.label || null;
        this._metadata = config.capability._metadata || config.capability.metadata || null;
        this._params = config.capability._params || config.capability.params || null;
        this._resultcolumns = config.capability._resultcolumns || config.capability.resultcolumns || null;
    }
    if (config.when || config._when)
        this._when = config.when || config._when;
    return this;// Chaining
}
util.inherits(Specification, Statement);

Specification.prototype.kind_str = function(){
            return KIND_SPECIFICATION;
}

Specification.prototype._default_token = function(){
            return this._pv_hash();
}

Specification.prototype.has_schedule = function(){
            return (!_.isNull(this._schedule));
}

Specification.prototype.to_dict = function(){
        return (JSON.stringify(this));
}

Specification.from_dict = function(d){    
    var spec = JSON.parse(d);
    if (spec instanceof Specification)
        return spec;
    else
        throw new Error("The dictionary does not contain a valid Specification");
}

var Result = function(config){
    Statement.apply( this, arguments ); // Call the Statement (super) contructor
    
     if (config.capability){

        this._verb = config.capability._verb || config.capability.verb || null;
        this._label = config.capability._label || config.capability.label || null;
        this._metadata = config.capability._metadata || config.capability.metadata || null;
        this._params = config.capability._params || config.capability.params || null;
        this._resultcolumns = config.capability._resultcolumns || config.capability.resultcolumns || null;
    }
    if (config.when || config._when)
        this._when = config.when || config._when;
     this.get_token();

     this._clear_constraints();
    
    return this;// Chaining
}
util.inherits(Result, Statement);

Result.prototype.kind_str = function(){
    return KIND_RESULT;
}

Result.prototype.validate = function(){
    var pn = this.parameter_names();
    for (var i=0 ; i< this.count_parameters() ; i++){
        if (!this._params[pn[i]].hasValue()){
                return false
        }
    }
    if (! this._when.is_definite()){
                return false
        }
    return true;
}

Result.from_dict = function(d){    
    var spec = JSON.parse(d);
    if (spec instanceof Result)
        return spec;
    else
        throw new Error("The dictionary does not contain a valid Result");
}

Result.prototype.set_result_value = function(columnName, val){
            this._resultcolumns[columnName].setValue(val);
}

Result.prototype.get_result_value = function(columnName, key){
       return  this._resultcolumns[columnName].getValue(key);
}

var BareNotification = function(config){
    if (!config)
        config = {};
    this._token = config.token || null;
    
    return this; //Chainig
}

var Exception = function(config){
    BareNotification.apply( this, arguments ); // Call the Statement (super) contructor
    if (!config)
        config = {};
    
    this._errmsg = config.errmsg || "Unspecified exception";
    
    return this; //Chainig
}
util.inherits(Exception, BareNotification);
   

Exception.prototype.get_token = function(){
    return this._token;
}

Exception.prototype.to_dict = function(){
    return JSON.stringify(this);

}

Exception._from_dict(d){
    var ret = JSON.parse(d);
    if (! ret instanceof Exception)
        throw new error("The dictionary should be a valid Exception instance");
    else
        return ret
}

var StatementNotification = function(config){
    Statement.apply( this, arguments ); // Call the Statement (super) contructor
    
    if (!config)
        config = {};
        
    return this; //Chainig
}
util.inherits(StatementNotification, Statement);

Statement.prototype.to_dict = function(){
    return JSON.stringify(this);
}

Statement._from_dict(d){
    var ret = JSON.parse(d);
    if (! ret instanceof Statement)
        throw new error("The dictionary should be a valid Statement instance");
    else
        return ret
}

Statement.prototype.kind_str = function(){
            throw new error("Cannot instantiate a raw StatementNotification");
}

var Receipt = function(config){
    StatementNotification.apply( this, arguments ); // Call the Statement (super) contructor
      if (!config)
        config = {};
    
    return this; //Chainig
}
util.inherits(Receipt, StatementNotification);

Receipt.prototype.kind_str = function(){
        return KIND_RECEIPT;
}
Receipt.prototype.validate = function(){
    return this.validate();
}

var Redemption = function(StatementNotification){
    StatementNotification.apply( this, arguments ); // Call the Statement (super) contructor
    if (!config)
        config = {};
    if (!_.isUndefined(config.receipt))
            this._token = receipt.get_token();
    
    return this; //Chainig
}
util.inherits(Redemption, StatementNotification);
    
Redemption.protorype.kind_str = function(){
        return KIND_REDEMPTION;
}

Redemption.protorype.validate = function(){
        return this.validate();
}

var Withdrawal = function(config){
    StatementNotification.apply( this, arguments ); // Call the Statement (super) contructor
    if (!config)
        config = {};
    
    return this; //Chainig
}
util.inherits(Withdrawal, StatementNotification);
  
Withdrawal.prototype.kind_str = function(){
    return KIND_WITHDRAWAL;
}
Withdrawal.prototype.validate = function(){
    return this.validate();
}

var Interrupt = function(){
    StatementNotification.apply( this, arguments ); // Call the Statement (super) contructor
    if (!config)
        config = {};
    
    return this; //Chainig
}
util.inherits(Interrupt, StatementNotification);
  
Interrupt.prototype.kind_str = function(){
        return KIND_INTERRUPT;
}
Interrupt.prototype.validate = function(){
    return this.validate();
}

var utility = function(){}

utility._parse_numset = function(valstr){

   return _.map(valstr.split(SET_SEP) , function(value, index){
        return parseInt(value);
    } );
}
utility.parseNumSet = utility._parse_numset;

utility._unparse_numset = function(valset){
    return (valset.join(SET_SEP))
}
utility.unParseNumSet = utility._unparse_numset;

utility._parse_wdayset = function(valstr){
    return _.map(valstr.split(SET_SEP) , function(value, index){
        return _dow_label.indexOf(value.toLocaleLowerCase().trim());
    } );
}
utility.parseWdaySet = utility._parse_wdayset;

utility._unparse_wdayset = function(valset){
    return _.map(valset , function(value, index){
        return _dow_label[parseInt(value)];
    } ).join(SET_SEP);
}
utility.unparseWdaySet = utility._unparse_wdayset;


utility.isInt = function(n) {
   return (n % 1 === 0);
}

utility.isReal = function(n){
    return ( !isNaN(parseFloat ( n )));
}

module.exports = {
    time: time,
    when: when,
    When: when,
    when_infinite: when_infinite,
    utility: utility,
    Scheduler: Scheduler,
    Primitive : Primitive,
    Element: Element,
    Constraints: Constraints,
    Parameter: Parameter,
    Metavalue: Metavalue,
    ResultColumn: ResultColumn,
    Statement: Statement,
    Capability: Capability,
    Specification: Specification,
    Result: Result,
    Receipt: Receipt,
    Redemption:Redemption,
    Withdrawal: Withdrawal
}