/*
 * Copyright 2016 resin.io
 *
 * 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.
 */

'use strict';

const m = require('mochainon');
const _ = require('lodash');
const robot = require('../../lib/shared/robot');

describe('Shared: Robot', function() {

  describe('.COMMAND', function() {

    it('should be a plain object', function() {
      m.chai.expect(_.isPlainObject(robot.COMMAND)).to.be.true;
    });

    it('should only contain string values', function() {
      m.chai.expect(_.every(_.values(robot.COMMAND), _.isString)).to.be.true;
    });

    it('should contain only unique values', function() {
      const numberOfKeys = _.size(_.keys(robot.COMMAND));
      m.chai.expect(_.size(_.uniq(_.values(robot.COMMAND)))).to.equal(numberOfKeys);
    });

  });

  describe('.isEnabled()', function() {

    it('should return false if ETCHER_CLI_ROBOT is not set', function() {
      m.chai.expect(robot.isEnabled({})).to.be.false;
    });

    it('should return true if ETCHER_CLI_ROBOT=1', function() {
      m.chai.expect(robot.isEnabled({
        ETCHER_CLI_ROBOT: 1
      })).to.be.true;
    });

    it('should return false if ETCHER_CLI_ROBOT=0', function() {
      m.chai.expect(robot.isEnabled({
        ETCHER_CLI_ROBOT: 0
      })).to.be.false;
    });

    it('should return true if ETCHER_CLI_ROBOT="true"', function() {
      m.chai.expect(robot.isEnabled({
        ETCHER_CLI_ROBOT: 'true'
      })).to.be.true;
    });

    it('should return false if ETCHER_CLI_ROBOT="false"', function() {
      m.chai.expect(robot.isEnabled({
        ETCHER_CLI_ROBOT: 'false'
      })).to.be.false;
    });

    it('should return true if ETCHER_CLI_ROBOT=true', function() {
      m.chai.expect(robot.isEnabled({
        ETCHER_CLI_ROBOT: true
      })).to.be.true;
    });

    it('should return false if ETCHER_CLI_ROBOT=false', function() {
      m.chai.expect(robot.isEnabled({
        ETCHER_CLI_ROBOT: false
      })).to.be.false;
    });

  });

  describe('.buildMessage()', function() {

    it('should build a message without data', function() {
      const message = robot.buildMessage('hello');
      const result = '{"command":"hello","data":{}}';
      m.chai.expect(message).to.equal(result);
    });

    it('should build a message with data', function() {
      const message = robot.buildMessage('hello', {
        foo: 1,
        bar: 2
      });
      const result = '{"command":"hello","data":{"foo":1,"bar":2}}';
      m.chai.expect(message).to.equal(result);
    });

    it('should throw if data is defined but it not an object', function() {
      m.chai.expect(() => {
        robot.buildMessage('hello', 'world');
      }).to.throw('Invalid data: world');
    });

  });

  describe('.isMessage()', function() {

    it('should return true if message is an empty object', function() {
      m.chai.expect(robot.isMessage('{}')).to.be.true;
    });

    it('should return true if message is an object', function() {
      m.chai.expect(robot.isMessage('{"command":"foo"}')).to.be.true;
    });

    it('should return false if message is an invalid object', function() {
      m.chai.expect(robot.isMessage('{"command":\\foo"}')).to.be.false;
    });

    it('should return false if message is an unquoted string', function() {
      m.chai.expect(robot.isMessage('foo')).to.be.false;
    });

    it('should return false if message is an quoted string', function() {
      m.chai.expect(robot.isMessage('"foo"')).to.be.false;
    });

    it('should return false if message is an empty string', function() {
      m.chai.expect(robot.isMessage('')).to.be.false;
    });

    it('should return false if message is undefined', function() {
      m.chai.expect(robot.isMessage(undefined)).to.be.false;
    });

    it('should return false if message is null', function() {
      m.chai.expect(robot.isMessage(null)).to.be.false;
    });

    it('should return false if message is a positive integer string', function() {
      m.chai.expect(robot.isMessage('5')).to.be.false;
    });

    it('should return false if message is a negative integer string', function() {
      m.chai.expect(robot.isMessage('-3')).to.be.false;
    });

    it('should return false if message is a zero string', function() {
      m.chai.expect(robot.isMessage('0')).to.be.false;
    });

    it('should return false if message is a positive float string', function() {
      m.chai.expect(robot.isMessage('5.3')).to.be.false;
    });

    it('should return false if message is a negative float string', function() {
      m.chai.expect(robot.isMessage('-2.1')).to.be.false;
    });

    it('should return false if message is a positive integer', function() {
      m.chai.expect(robot.isMessage(5)).to.be.false;
    });

    it('should return false if message is a negative integer', function() {
      m.chai.expect(robot.isMessage(-3)).to.be.false;
    });

    it('should return false if message is zero', function() {
      m.chai.expect(robot.isMessage(0)).to.be.false;
    });

    it('should return false if message is a positive float', function() {
      m.chai.expect(robot.isMessage(5.3)).to.be.false;
    });

    it('should return false if message is a negative float', function() {
      m.chai.expect(robot.isMessage(-2.1)).to.be.false;
    });

    it('should return false if message is an array', function() {
      m.chai.expect(robot.isMessage([ 'foo' ])).to.be.false;
    });

    it('should return false if message is an array string', function() {
      m.chai.expect(robot.isMessage('["foo"]')).to.be.false;
    });

    it('should return true for a message built with .buildMessage()', function() {
      m.chai.expect(robot.isMessage(robot.buildMessage('foo', {
        message: 'bar'
      }))).to.be.true;
    });

    it('should return true for a message built with .buildErrorMessage()', function() {
      const error = new Error('foo');
      m.chai.expect(robot.isMessage(robot.buildErrorMessage(error))).to.be.true;
    });

  });

  describe('.buildErrorMessage()', function() {

    it('should build a message from a simple error', function() {
      const error = new Error('foo');
      const message = robot.buildErrorMessage(error);

      m.chai.expect(JSON.parse(message)).to.deep.equal({
        command: robot.COMMAND.ERROR,
        data: {
          message: 'foo',
          stack: error.stack
        }
      });
    });

    it('should save the error description', function() {
      const error = new Error('foo');
      error.description = 'error description';
      const message = robot.buildErrorMessage(error);

      m.chai.expect(JSON.parse(message)).to.deep.equal({
        command: robot.COMMAND.ERROR,
        data: {
          message: 'foo',
          description: 'error description',
          stack: error.stack
        }
      });
    });

    it('should save the error code', function() {
      const error = new Error('foo');
      error.code = 'MYERROR';
      const message = robot.buildErrorMessage(error);

      m.chai.expect(JSON.parse(message)).to.deep.equal({
        command: robot.COMMAND.ERROR,
        data: {
          message: 'foo',
          code: 'MYERROR',
          stack: error.stack
        }
      });
    });

    it('should handle a string error', function() {
      const message = JSON.parse(robot.buildErrorMessage('foo'));
      m.chai.expect(message.data.message).to.equal('foo');
      m.chai.expect(message.data.stack).to.be.a.string;
      m.chai.expect(_.isEmpty(message.data.stack)).to.be.false;
    });

  });

  describe('.parseMessage()', function() {

    it('should parse a valid message', function() {
      const message = robot.buildMessage('foo', {
        bar: 1
      });

      m.chai.expect(robot.parseMessage(message)).to.deep.equal({
        command: 'foo',
        data: {
          bar: 1
        }
      });
    });

    it('should parse a valid without data', function() {
      const message = robot.buildMessage('foo');
      m.chai.expect(robot.parseMessage(message)).to.deep.equal({
        command: 'foo',
        data: {}
      });
    });

    it('should throw if input is not valid JSON', function() {
      m.chai.expect(() => {
        robot.parseMessage('Hello world\nFoo Bar');
      }).to.throw('Invalid message');
    });

    it('should throw if input has no command', function() {
      m.chai.expect(() => {
        robot.parseMessage('{"data":{"foo":"bar"}}');
      }).to.throw('Invalid message');
    });

    it('should throw if input has no data', function() {
      m.chai.expect(() => {
        robot.parseMessage('{"command":"foo"}');
      }).to.throw('Invalid message');
    });

  });

  describe('.getCommand()', function() {

    it('should get the command of a message', function() {
      const message = robot.parseMessage(robot.buildMessage('hello', {
        foo: 1,
        bar: 2
      }));

      m.chai.expect(robot.getCommand(message)).to.equal('hello');
    });

  });

  describe('.getData()', function() {

    it('should get the data of a message', function() {
      const message = robot.parseMessage(robot.buildMessage('hello', {
        foo: 1,
        bar: 2
      }));

      m.chai.expect(robot.getData(message)).to.deep.equal({
        foo: 1,
        bar: 2
      });
    });

    it('should return an empty object if the message has no data', function() {
      m.chai.expect(robot.getData({
        command: 'foo'
      })).to.deep.equal({});
    });

  });

  describe('.recomposeErrorMessage()', function() {

    it('should return an instance of Error', function() {
      const error = new Error('Foo bar');
      const message = robot.parseMessage(robot.buildErrorMessage(error));
      m.chai.expect(robot.recomposeErrorMessage(message)).to.be.an.instanceof(Error);
    });

    it('should be able to recompose an error object', function() {
      const error = new Error('Foo bar');
      const message = robot.parseMessage(robot.buildErrorMessage(error));
      m.chai.expect(robot.recomposeErrorMessage(message)).to.deep.equal(error);
    });

    it('should be able to recompose an error object with a code', function() {
      const error = new Error('Foo bar');
      error.code = 'FOO';
      const message = robot.parseMessage(robot.buildErrorMessage(error));
      m.chai.expect(robot.recomposeErrorMessage(message)).to.deep.equal(error);
    });

    it('should be able to recompose an error object with a description', function() {
      const error = new Error('Foo bar');
      error.description = 'My description';
      const message = robot.parseMessage(robot.buildErrorMessage(error));
      m.chai.expect(robot.recomposeErrorMessage(message)).to.deep.equal(error);
    });

  });

});