define([
    "dcl/dcl",
    "xide/utils",
    "xide/types",
    "xide/console",
    "xcf/model/Command",
    "xdojo/has!host-node?nxapp/protocols/ProtocolBase",
    "xdojo/has!host-node?dojo/node!yargs-parser"
], function (dcl,utils,types, console,Command,ProtocolBase,yargs) {
    var five = null;
    var debug = true;
    // The returning module
    var Module = null;

    //the johnny-five module, set when connected.
    var JohnnyFive = null;

    // client side, return nothing
    if (!ProtocolBase) {
        //create dummy module
        Module = dcl(null, {});
        patchModule();
        return Module;
    }


    Module = dcl(ProtocolBase, {
        isNodeJS: true,
        board: null,
        context:null,
        inputs: {
            A0: {pin: {}, value: 0},
            A1: {pin: {}, value: 0},
            A2: {pin: {}, value: 0},
            A3: {pin: {}, value: 0},
            A4: {pin: {}, value: 0},
            A5: {pin: {}, value: 0}
        },
        outputs: {
            D1: {pin: {}, value: 0},
            D2: {pin: {}, value: 0},
            D3: {pin: {}, value: 0},
            D4: {pin: {}, value: 0},
            D5: {pin: {}, value: 0},
            D6: {pin: {}, value: 0},
            D7: {pin: {}, value: 0},
            D8: {pin: {}, value: 0},
            D9: {pin: {}, value: 0},
            D10: {pin: {}, value: 0},
            D11: {pin: {}, value: 0},
            D12: {pin: {}, value: 0},
            D13: {pin: {}, value: 0}
        },
        get: function(field) {
            if(this.inputs[field]){
                return this.inputs[field].value;
            }else{
                console.error('pin doesnt exists : ' + field,this.inputs);
            }
        },
        set: function(field, value) {
            value = parseInt(value,10);

            if(this.inputs[field] != undefined) {

                if(parseInt(this.inputs[field].value, 10) !== parseInt( value, 10 )) {
                    this.inputs[field].value = value;
                    //this.emit('change', {field: field, value: this.inputs[field].value});
                }
            }
            else if(this.outputs[field] !== undefined) {
                if(parseInt(this.outputs[field].value,10) !== parseInt(value,10)) {
                    this.outputs[field].value = value;
                    if(this.connected) {
                        this.setHardwarePin(field, value);
                    }
                }
            }
            return this;
        },
        setHardwarePin: function(field, value) {
            var outputField = this.outputs[field];

            if(outputField && outputField.pin) {
                var pinMode = outputField.pin.mode;
            }

            if(outputField !== undefined && (field === 'D3'
                || field === 'D5'
                || field === 'D6'
                || field === 'D9'
                || field === 'D10'
                || field === 'D11') ) {
                var pinMode = outputField.pin.mode;

                // Check which pinmode is set on the pin to determine which method to call
                if (pinMode === this.PINMODES.PWM || pinMode === this.PINMODES.OUTPUT) {
                    this.outputs[field].pin.brightness(value);

                } else if(pinMode === this.PINMODES.SERVO) {
                    this.outputs[field].pin.to(value);
                }

                // For reference:
                //MODES:
                //{ INPUT: 0,
                //OUTPUT: 1,
                //ANALOG: 2,
                //PWM: 3,
                //SERVO: 4,
                //SHIFT: 5,
                //I2C: 6,
                //ONEWIRE: 7,
                //STEPPER: 8,
                //IGNORE: 127,
                //UNKOWN: 16 },

            }
            else if(pinMode == this.PINMODES.OUTPUT) {
                var pinMode = outputField.pin.mode;
                if(value >= 255) {
                    this.outputs[field].pin.on();
                }
                else {
                    this.outputs[field].pin.off();
                }
            }
        },
        addDefaultPins:function(){
            var self = this;
            // Store all pin mode mappings (string -> integer)
            this.PINMODES = this.board.io.MODES;

            var pollFreq = 100;

            // Instantiate each sensor listed on the model to the sensors array
            for(var input in this.inputs) {

                (function() {

                    if(!parseInt(input, 10)) {
                        var sensor = JohnnyFive.Sensor({
                            pin: input,
                            freq: pollFreq
                        });

                        this.inputs[input].pin = sensor;

                        sensor.scale([0, 1023]).on("data", function() {
                            self.set('A'+this.pin, Math.floor(this.value));
                            //console.log('sensor data '+'A'+this.pin,Math.floor(this.value));
                        });
                    }
                    else {
                        this.board.pinMode(input, JohnnyFive.Pin.INPUT);
                    }

                }.bind(this))();
            }


            // Cycle through and add all the outputs here
            for(var output in this.outputs) {
                (function() {
                    // hack for right now to hard code pin <3 as pwm, pin 9 as servo
                    var pin = parseInt(output.substr(1),10);
                    var outputPin;

                    if (pin === 3 || pin === 5 || pin === 6 || pin === 10 || pin === 11 || pin === 9) {
                        outputPin = new JohnnyFive.Led(pin);
                    }
                    //else if(pin === 9) {
                    //outputPin = new five.Servo({
                    //pin: pin,
                    //range: [0,180],
                    //});
                    //}

                    this.outputs[output].pin = outputPin;

                }.bind(this))();
            }

        },
        constructor:function(options){
            utils.mixin(this,options);
        },
        _sendError: function (data, command, options) {
            if(!options){
                console.error('have no options',options);
                options = {};
            }
            if(!options.params){
                console.error('have no params',options);
                options.params = {wait:true};
            }
            var wait = options.params.wait;
            var self = this;
            var outString = JSON.stringify(utils.mixin({
                command: command
            }, data, null, 2));
            if (wait) {
                self.owner.onError(command, options, new Buffer(outString));
            } else {
                self.owner.onData(outString, new Buffer(outString));
            }
        },
        setMode:function(nr,mode,options){
            var board = this.board;
            //nr = parseInt(nr,10);
            mode = parseInt(mode,10);

            //this.context.pinMode(nr,mode);
            this.setHardwarePin(nr,mode);
        },
        digitalWrite:function(nr,value,options){
            this.board.digitalWrite(parseInt(nr,10), parseInt(value,10));
        },
        digitalRead:function(nr,options){
            this.board.digitalRead(parseInt(nr,10),function(value){
                console.log('digitalRead: ',value);
                this._send({
                    value:value,
                    gpio:nr
                },'digitalRead',options);
            }.bind(this));
        },
        _send: function (data, command, options) {
            var wait = options.params.wait;
            var self = this;
            var outString = JSON.stringify(utils.mixin({
                command: command
            }, data, null, 2));

            if (wait) {
                self.owner.onFinish(command, options, new Buffer(outString));
            } else {
                self.owner.onData(outString, new Buffer(outString));
            }
        },
        analogRead:function(nr,options){
            var self = this;
            /*
            var handler = function(value){
                console.log('analogRead: ',value);
                self._send({
                    value:value,
                    gpio:nr
                },'analogRead',options);
            }.bind(this);

            //this.board.analogRead.apply(this.board,[parseInt(nr,10),handler]);
            this.context.analogRead(parseInt(nr,10),handler);*/

            self._send({
                value:this.get(nr,10),
                gpio:parseInt(nr,10)
            },'analogRead',options);

        },
        /**
         *
         * @param what {string} A string encoded byte array in the 01,02,... format
         * @returns {null}
         */
        write:function(what,options){
            var _parsed = null;
            //convert buffer from byte array string to string
            var intArray = utils.bufferFromDecString(what);
            var buffer = new Buffer(intArray);

            what = buffer.toString();

            var args = what.split(" ");
            var cmd = "" + args[0];
            args.shift();

            this.isDebug() && console.log('write : ' + what, args);

            if (typeof this[cmd] === 'function') {
                args.push(options);
                try {
                    return this[cmd].apply(this, args);
                }catch(e){
                    console.error('Error running '+cmd + " : " + e.message);
                    this._sendError({
                        error:e.message
                    },cmd,options);
                }
            }else{
                console.error('cant find command '+cmd);
            }

            return;

            try {
                _parsed = (new Function("{\n" + what + "\n}")).apply(this.context,[console,this]);
            }catch(e) {
                console.error('Arduino: Error running code : ' + e.message, e);
                console.trace();
                this.owner.onError(what, e);
                utils.stack();
            }

            debug && console.log('Arduino,result '+_parsed);
            return null;
        },
        onButton:function(){
            console.log('on button');
            //send to IDE or clients
            this.owner.onData("on button");
        },
        onConnected:function(){
            this.owner.onConnected();
        },
        onInfo:function(evt){
            var owner=this.owner;
            var connectionManager = owner.delegate;
            connectionManager.onData(owner,evt);
        },
        connect: function () {
            var five = null;
            var self = this;
            try {
                five = require(["dojo/node!johnny-five"],function(_five){
                    JohnnyFive = _five;
                    five = _five;
                    var myBoard;
                    try {
                        //if(global['_j5_context']) {

                        if(global['_j5_context'] && global['_j5_context'][self.options.host]){
                            console.error('re-use!');
                            self.context = global['_j5_context'][self.options.host].context;
                            self.board = global['_j5_context'][self.options.host].board;
                            self.inputs = global['_j5_context'][self.options.host].inputs;
                            self.outputs = global['_j5_context'][self.options.host].outputs;
                            self.connected = true;
                            self.onConnected();
                            return;
                        }

                        myBoard = new five.Board({
                            repl: false,
                            debug: false,
                            port: self.options.host
                        });

                        myBoard.on("error", function (e) {
                            console.error('johnny-five ', e);
                            self._sendError(e['class'] + ':' + e.message, 'connect', self.options);
                        })
                        myBoard.on("ready", function () {
                            self.context = this;
                            self.context.j5 = _five;
                            self.context.log = console.log;
                            self.board = myBoard;
                            self.addDefaultPins();
                            self.connected = true;
                            self.onConnected();


                            if(!global['_j5_context']){
                                global['_j5_context'] = {}
                            }
                            global['_j5_context'][self.options.host] = {
                                context:self.context,
                                board:myBoard,
                                inputs : self.inputs,
                                outputs : self.outputs
                            };
                        });

                        myBoard.on("info", function (event) {
                            self.onInfo(event);
                            //console.log("%s sent an 'info' message: %s", event.class, event.message);
                        });

                    }catch(e){
                        console.error('----'+ e.message,e.stack);
                        utils.stack();
                    }
                });
            }catch(e){
                console.error('error requiring '+ e.message,e);
            }
        },
        /***
         * Standard callback when we have a message from the device we're bound to (specified in profile).
         * 1. put the message in the incoming queue, tag it as 'unread'
         * 2. in case we have messages to send and we are in 'onReply' mode, trigger outgoing queue
         *
         * @param data {Object} : Message struct build by the device manager
         * @param data.device {Object} : Device info
         * @param data.device.host {String} : The host
         * @param data.device.port {String} : The host's port
         * @param data.device.protocol {String} : The host's protocol

         * @param data.message {String} : RAW message, untreated
         */
        onMessage: function (data) {},
        end:function(){
            console.error('disconnect');
            if(this.context){
                this.context.disconnect();
                this.board = null;
            }
        },
        destroy: function () {
            console.error('disconnect');
            if(this.context){
                this.board = null;
            }
        }
    });

    Module.is = function(){
        return types.PROTOCOL.SERIAL;
    };

    function patchModule(){

        var PIN_MODES = {
            INPUT: 0x00,
            OUTPUT: 0x01,
            ANALOG: 0x02,
            PWM: 0x03,
            SERVO: 0x04
        };

        Module.getFields = function (command, fields) {
            var result = [];
            //add a GPIO field
            if(command._isGPIO) {
                command._gpio = command._gpio || 17;
                result.push(utils.createCI('test', types.ECIType.STRING, command._gpio, {
                    group: 'GPIO',
                    title: 'GPIO',
                    dst: '_gpio',
                    order: 197
                }));
            }

            //add gpio mode field
            if(command._gpioFunc === 'setMode') {
                command._mode = command._mode || "OUTPUT";
                result.push(utils.createCI('test', types.ECIType.ENUMERATION, command._mode, {
                    group: 'GPIO',
                    title: 'Mode',
                    dst: '_mode',
                    order: 198,
                    widget:{
                        options:[
                            {value:PIN_MODES.INPUT,label:"INPUT"},
                            {value:PIN_MODES.OUTPUT,label:"OUTPUT"},
                            {value:PIN_MODES.ANALOG,label:"ANALOG"},
                            {value:PIN_MODES.PWM,label:"PWM"},
                            {value:PIN_MODES.SERVO,label:"SERVO"}
                        ]
                    }
                }));
            }

            if(command._gpioFunc === 'digitalWrite') {
                command._value = command._value || 1;
                result.push(utils.createCI('test', types.ECIType.ENUMERATION, command._value, {
                    group: 'GPIO',
                    title: 'Value',
                    dst: '_value',
                    order: 199,
                    widget:{
                        options:[
                            {value:0,label:"0"},
                            {value:1,label:"1"}
                        ]
                    }
                }));
            }

            if(command._gpioFunc === 'analogWrite') {
                command._value = command._value || 1;
                result.push(utils.createCI('test', types.ECIType.ENUMERATION, command._value, {
                    group: 'GPIO',
                    title: 'Value',
                    dst: '_value',
                    order: 199,
                    widget:{
                        options:[
                            {value:0,label:"0"},
                            {value:1,label:"1"}
                        ]
                    }
                }));
            }


            return result;
        };
        /**
         *
         * @param label
         * @param icon
         * @param ctrAgs
         * @param variables
         * @param send
         * @param func
         * @param description
         * @param scope
         * @param owner
         * @param target
         * @param group
         */
        function createBlock(label,icon,ctrAgs,variables,send,func,description,scope, owner, target, group){
            return {
                name: label,
                owner: owner,
                icon: icon,
                proto: Command,
                target: target,
                ctrArgs: utils.mixin({
                    icon:icon,
                    flags:0,
                    name:label,
                    scope: scope,
                    group: group,
                    variables:variables ? JSON.stringify(variables) : "{}",
                    send:send,
                    _isGPIO:true,
                    _gpioFunc:func,
                    description:description
                },ctrAgs)
            };
        }

        /**
         * Extend xblox for new blocks/commands.
         * @param scope
         * @param owner
         * @param target
         * @param group
         * @param items
         * @returns {*}
         */
        Module.getNewBlocks=function(scope, owner, target, group, items){

            if(!items){
                return null;
            }
            items.push({
                name: 'Johnny-Five',
                iconClass: 'fa-code',
                items: [
                    createBlock('Set GPIO Mode','fa-cogs',null,
                        { 'GPIO': '_gpio','GPIO_MODE': '_mode'},
                        "setMode {{GPIO}} {{GPIO_MODE}}","setMode",
                        "Set the mode of a specific pin, one of INPUT, OUTPUT, ANALOG, PWM, SERVO. Mode constants are exposed via the Pin class",
                        scope,owner,target,group),

                    createBlock('Digital Write','fa-send',null,
                        { 'GPIO': '_gpio','GPIO_VALUE': '_value'},
                        "digitalWrite {{GPIO}} {{GPIO_VALUE}}","digitalWrite",
                        "Write a digital value (0 or 1) to a digital pin.",
                        scope,owner,target,group),

                    createBlock('Digital Read','fa-send',null,
                        { 'GPIO': '_gpio'},
                        "digitalRead {{GPIO}}","digitalRead",
                        "Returns the GPIO level",
                        scope,owner,target,group),

                    createBlock('Analog Read','fa-send',null,
                        { 'GPIO': '_gpio'},
                        "analogRead {{GPIO}}","analogRead",
                        "Register a handler to be called whenever the board reports the voltage value (0-1023) of the specified analog pin.",
                        scope,owner,target,group),

                    createBlock('Analog Write','fa-send',null,
                        { 'GPIO': '_gpio'},
                        "analogWrite {{GPIO}} {{GPIO_VALUE}}","analogWrite",
                        "Write an unsigned, 8-bit value (0-255) to an analog pin.",
                        scope,owner,target,group)
                ]
            });
            return items;
        };
        /**
         * Override interface for "toText"
         * @param command
         * @param text
         * @returns {*}
         */
        Module.toText = function (command, text) {
            if(!command._isGPIO){
                return;
            }
            if(command.variables){
                var commandVariables = utils.fromJson(command.variables);
                var variables = {};

                for(var variable in commandVariables){
                    variables[variable]=command[commandVariables[variable]] || " ";
                }
                text = utils.replace(text,null,variables,{
                    begin:'{{',
                    end:'}}'
                });
                return text;
            }

        };
        Module.resolveAfter = function (command,inputString) {
            if(!command._isGPIO){
                return;
            }
            if(command.variables){
                var commandVariables = utils.fromJson(command.variables);
                var variables = {};
                for(var variable in commandVariables){
                    variables[variable]=command._resolve(command[commandVariables[variable]],{
                        flags:0x00000800
                    },false);
                }
                inputString = utils.replace(inputString,null,variables,{
                    begin:'{{',
                    end:'}}'
                });
            }
            return inputString;
        };
    }

    patchModule();

    return Module;
});