/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 */

App = require('app');

require('controllers/main/service/widgets/create/step2_controller');


describe('App.WidgetWizardStep2Controller', function () {
  var controller = App.WidgetWizardStep2Controller.create({
    content: Em.Object.create()
  });

  App.TestAliases.testAsComputedEqual(controller, 'isEditWidget', 'content.controllerName', 'widgetEditController');

  describe("#filteredMetrics", function () {
    var testCases = [
      {
        metric: {
          point_in_time: false
        },
        type: null,
        result: []
      },
      {
        metric: {
          point_in_time: true
        },
        type: null,
        result: [
          {
            point_in_time: true
          }
        ]
      },
      {
        metric: {
          temporal: false
        },
        type: 'GRAPH',
        result: []
      },
      {
        metric: {
          temporal: true
        },
        type: 'GRAPH',
        result: [
          {
            temporal: true
          }
        ]
      }
    ];

    testCases.forEach(function (test) {
      it("type=" + test.type + "; temporal=" + test.metric.temporal + "; point_in_time=" + test.metric.point_in_time, function () {
        controller.get('content').setProperties({
          widgetType: test.type,
          allMetrics: [test.metric]
        });
        controller.propertyDidChange('filteredMetrics');
        expect(controller.get('filteredMetrics')).to.eql(test.result);
      });
    });
  });

  describe("#isSubmitDisabled", function () {
    beforeEach(function () {
      this.expressionFunc = sinon.stub(controller, 'isExpressionComplete');
      this.graphFunc = sinon.stub(controller, 'isGraphDataComplete');
      this.templateFunc = sinon.stub(controller, 'isTemplateDataComplete');
      controller.set('expressions', ['']);
    });
    afterEach(function () {
      this.expressionFunc.restore();
      this.graphFunc.restore();
      this.templateFunc.restore();
      controller.get('expressions').clear();
    });
    it("invalid property", function () {
      controller.set('widgetPropertiesViews', [Em.Object.create({isValid: false})]);
      controller.propertyDidChange('isSubmitDisabled');
      expect(controller.get('isSubmitDisabled')).to.be.true;
    });
    it("valid number widget", function () {
      controller.set('widgetPropertiesViews', []);
      controller.set('content.widgetType', 'NUMBER');
      this.expressionFunc.returns(true);
      controller.propertyDidChange('isSubmitDisabled');
      expect(controller.get('isSubmitDisabled')).to.be.false;
    });
    it("invalid number widget", function () {
      controller.set('widgetPropertiesViews', []);
      controller.set('content.widgetType', 'NUMBER');
      this.expressionFunc.returns(false);
      controller.propertyDidChange('isSubmitDisabled');
      expect(controller.get('isSubmitDisabled')).to.be.true;
    });
    it("valid graph widget", function () {
      controller.set('widgetPropertiesViews', []);
      controller.set('content.widgetType', 'GRAPH');
      this.graphFunc.returns(true);
      controller.propertyDidChange('isSubmitDisabled');
      expect(controller.get('isSubmitDisabled')).to.be.false;
    });
    it("invalid graph widget", function () {
      controller.set('widgetPropertiesViews', []);
      controller.set('content.widgetType', 'GRAPH');
      this.graphFunc.returns(false);
      controller.propertyDidChange('isSubmitDisabled');
      expect(controller.get('isSubmitDisabled')).to.be.true;
    });
    it("valid template widget", function () {
      controller.set('widgetPropertiesViews', []);
      controller.set('content.widgetType', 'TEMPLATE');
      this.templateFunc.returns(true);
      controller.propertyDidChange('isSubmitDisabled');
      expect(controller.get('isSubmitDisabled')).to.be.false;
    });
    it("invalid template widget", function () {
      controller.set('widgetPropertiesViews', []);
      controller.set('content.widgetType', 'TEMPLATE');
      this.templateFunc.returns(false);
      controller.propertyDidChange('isSubmitDisabled');
      expect(controller.get('isSubmitDisabled')).to.be.true;
    });
    it("unknown widget type", function () {
      controller.set('widgetPropertiesViews', []);
      controller.set('content.widgetType', '');
      controller.propertyDidChange('isSubmitDisabled');
      expect(controller.get('isSubmitDisabled')).to.be.false;
    });
  });

  describe("#isExpressionComplete()", function () {
    var testCases = [
      {
        expression: null,
        result: false,
        title: 'no expression'
      },
      {
        expression: Em.Object.create({isInvalid: true}),
        result: false,
        title: 'invalid expression, no data array'
      },
      {
        expression: Em.Object.create({isInvalid: false, isEmpty: false}),
        result: false,
        title: 'no data array'
      },
      {
        expression: Em.Object.create({isInvalid: false, isEmpty: true}),
        result: false,
        title: 'empty expression'
      },
      {
        expression: Em.Object.create({isInvalid: true, data: []}),
        result: false,
        title: 'invalid expression, empty data array'
      },
      {
        expression: Em.Object.create({isInvalid: false, isEmpty: false, data: []}),
        result: false,
        title: 'empty data array'
      },
      {
        expression: Em.Object.create({isInvalid: false, isEmpty: true, data: []}),
        result: false,
        title: 'empty expression and data array'
      },
      {
        expression: Em.Object.create({isInvalid: true, data: [{isMetric: false}]}),
        result: false,
        title: 'invalid expression, no metrics'
      },
      {
        expression: Em.Object.create({isInvalid: false, isEmpty: false, data: [{isMetric: false}]}),
        result: false,
        title: 'no metrics'
      },
      {
        expression: Em.Object.create({isInvalid: false, isEmpty: true, data: [{isMetric: false}]}),
        result: false,
        title: 'empty expression, no metrics'
      },
      {
        expression: Em.Object.create({isInvalid: true, data: [{isMetric: false}, {isMetric: true}]}),
        result: false,
        title: 'invalid expression'
      },
      {
        expression: Em.Object.create({isInvalid: false, isEmpty: false, data: [{isMetric: false}, {isMetric: true}]}),
        result: true,
        title: 'valid expression'
      },
      {
        expression: Em.Object.create({isInvalid: false, isEmpty: true, data: [{isMetric: false}, {isMetric: true}]}),
        result: false,
        title: 'empty expression, valid data array'
      }
    ];
    testCases.forEach(function (test) {
      it(test.title, function () {
        expect(controller.isExpressionComplete(test.expression)).to.equal(test.result);
      });
    });
  });

  describe("#isGraphDataComplete()", function () {
    beforeEach(function () {
      this.mock = sinon.stub(controller, 'isExpressionComplete');
    });
    afterEach(function () {
      this.mock.restore();
    });
    it("dataSets is empty", function () {
      expect(controller.isGraphDataComplete([])).to.be.false;
    });
    it("label is empty", function () {
      expect(controller.isGraphDataComplete([Em.Object.create({label: ''})])).to.be.false;
    });
    it("expression is not complete", function () {
      this.mock.returns(false);
      expect(controller.isGraphDataComplete([Em.Object.create({label: 'abc'})])).to.be.false;
    });
    it("expression is complete", function () {
      this.mock.returns(true);
      expect(controller.isGraphDataComplete([Em.Object.create({label: 'abc'})])).to.be.true;
    });
  });

  describe("#isTemplateDataComplete()", function () {
    beforeEach(function () {
      this.mock = sinon.stub(controller, 'isExpressionComplete');
    });
    afterEach(function () {
      this.mock.restore();
    });
    it("expressions is empty", function () {
      expect(controller.isTemplateDataComplete([])).to.be.false;
    });
    it("templateValue is empty", function () {
      expect(controller.isTemplateDataComplete([{}], '')).to.be.false;
    });
    it("expression is not complete", function () {
      this.mock.returns(false);
      expect(controller.isTemplateDataComplete([{}], 'abc')).to.be.false;
    });
    it("expression is complete", function () {
      this.mock.returns(true);
      expect(controller.isTemplateDataComplete([{}], 'abc')).to.be.true;
    });
  });

  describe("#addDataSet()", function () {

    beforeEach(function () {
      controller.get('dataSets').clear();
      controller.addDataSet(null, true);
      controller.addDataSet(null);
    });

    afterEach(function() {
      controller.get('dataSets').clear();
    });

    it('check id', function () {
      expect(controller.get('dataSets').mapProperty('id')).to.eql([1, 2]);
    });

    it('check isRemovable', function () {
      expect(controller.get('dataSets').mapProperty('isRemovable')).to.eql([false, true]);
    });
  });

  describe("#removeDataSet()", function () {
    it('should remove selected dataSet', function () {
      var dataSet = Em.Object.create();
      controller.get('dataSets').pushObject(dataSet);
      controller.removeDataSet({context: dataSet});
      expect(controller.get('dataSets')).to.be.empty;
    });
  });

  describe("#addExpression()", function () {

    beforeEach(function () {
      controller.get('expressions').clear();
      controller.addExpression(null, true);
      controller.addExpression(null);
    });

    afterEach(function () {
      controller.get('expressions').clear();
    });

    it('check id', function () {
      expect(controller.get('expressions').mapProperty('id')).to.eql([1, 2]);
    });

    it('check isRemovable', function () {
      expect(controller.get('expressions').mapProperty('isRemovable')).to.eql([false, true]);
    });

  });

  describe("#removeExpression()", function () {
    it("should remove selected expression", function () {
      var expression = Em.Object.create();
      controller.get('expressions').pushObject(expression);
      controller.removeExpression({context: expression});
      expect(controller.get('expressions')).to.be.empty;
    });
  });

  describe("#initWidgetData()", function () {

    describe("new data", function () {

      beforeEach(function () {
        controller.set('expressions', []);
        controller.set('dataSets', []);
        controller.get('content').setProperties({
          widgetProperties: {a: 1},
          widgetValues: [1],
          widgetMetrics: [2]
        });

        controller.initWidgetData();
      });

      it('widgetProperties is {a: 1}', function () {
        expect(controller.get('widgetProperties')).to.eql({a: 1});
      });

      it('widgetValues is []', function () {
        expect(controller.get('widgetValues')).to.eql([]);
      });

      it('widgetMetrics is []', function () {
        expect(controller.get('widgetMetrics')).to.eql([]);
      });

      it('expressions is not empty', function () {
        expect(controller.get('expressions')).to.not.be.empty;
      });

      it('dataSets is not empty', function () {
        expect(controller.get('dataSets')).to.not.be.empty;
      });

    });

    describe("previously edited", function () {

      beforeEach(function () {
        controller.set('expressions', [{}]);
        controller.set('dataSets', [{}]);
        controller.get('content').setProperties({
          widgetProperties: {a: 1},
          widgetValues: [1],
          widgetMetrics: [2]
        });

        controller.initWidgetData();
      });

      it('widgetProperties is {a: 1}', function () {
        expect(controller.get('widgetProperties')).to.eql({a: 1});
      });
      it('widgetValues is [1]', function () {
        expect(controller.get('widgetValues')).to.eql([1]);
      });
      it('widgetMetrics is  [2]', function () {
        expect(controller.get('widgetMetrics')).to.eql([2]);
      });
      it('expressions is not empty', function () {
        expect(controller.get('expressions')).to.not.be.empty;
      });
      it('dataSets is not empty', function () {
        expect(controller.get('dataSets')).to.not.be.empty;
      });

    });
  });

  describe("#updateExpressions()", function () {

    beforeEach(function () {
      sinon.stub(controller, 'parseExpression').returns({values: [1], metrics: [1]});
      sinon.stub(controller, 'parseTemplateExpression').returns({values: [1], metrics: [1]});
      sinon.stub(controller, 'parseGraphDataset').returns({values: [1], metrics: [1]});
    });

    afterEach(function () {
      controller.parseExpression.restore();
      controller.parseTemplateExpression.restore();
      controller.parseGraphDataset.restore();
    });

    describe("empty expressions", function () {

      beforeEach(function () {
        controller.set('expressions', []);
        controller.updateExpressions();
      });

      it('parseExpression is not called', function () {
        expect(controller.parseExpression.called).to.be.false;
      });
      it('parseTemplateExpression is not called', function () {
        expect(controller.parseTemplateExpression.called).to.be.false;
      });
      it('parseGraphDataset is not called', function () {
        expect(controller.parseGraphDataset.called).to.be.false;
      });
      it('widgetValues is empty', function () {
        expect(controller.get('widgetValues')).to.be.empty;
      });
      it('widgetMetrics is empty', function () {
        expect(controller.get('widgetMetrics')).to.be.empty;
      });
    });

    describe("empty dataSets", function () {

      beforeEach(function () {
        controller.set('dataSets', []);
        controller.updateExpressions();
      });

      it('parseExpression is not called', function () {
        expect(controller.parseExpression.called).to.be.false;
      });
      it('parseTemplateExpression is not called', function () {
        expect(controller.parseTemplateExpression.called).to.be.false;
      });
      it('parseGraphDataset is not called', function () {
        expect(controller.parseGraphDataset.called).to.be.false;
      });
      it('widgetValues is empty', function () {
        expect(controller.get('widgetValues')).to.be.empty;
      });
      it('widgetMetrics is empty', function () {
        expect(controller.get('widgetMetrics')).to.be.empty;
      });
    });

    describe("GAUGE widget", function () {

      beforeEach(function () {
        controller.set('expressions', [{}]);
        controller.set('content.widgetType', 'GAUGE');
        controller.set('dataSets', [{}]);
        //controller.updateExpressions();
      });


      it('parseExpression is called once', function () {
        expect(controller.parseExpression.calledOnce).to.be.true;
      });
      it('parseTemplateExpression is not called', function () {
        expect(controller.parseTemplateExpression.called).to.be.false;
      });
      it('parseGraphDataset is not called', function () {
        expect(controller.parseGraphDataset.called).to.be.false;
      });
      it('widgetValues is not empty', function () {
        expect(controller.get('widgetValues')).to.not.be.empty;
      });
      it('widgetMetrics is not empty', function () {
        expect(controller.get('widgetMetrics')).to.not.be.empty;
      });
    });

    describe("NUMBER widget", function () {

      beforeEach(function () {
        controller.set('expressions', [{}]);
        controller.set('content.widgetType', 'NUMBER');
        controller.set('dataSets', [{}]);
        //controller.updateExpressions();
      });


      it('parseExpression is called once', function () {
        expect(controller.parseExpression.calledOnce).to.be.true;
      });
      it('parseTemplateExpression is not called', function () {
        expect(controller.parseTemplateExpression.called).to.be.false;
      });
      it('parseGraphDataset is not called', function () {
        expect(controller.parseGraphDataset.called).to.be.false;
      });
      it('widgetValues is not empty', function () {
        expect(controller.get('widgetValues')).to.not.be.empty;
      });
      it('widgetMetrics is not empty', function () {
        expect(controller.get('widgetMetrics')).to.not.be.empty;
      });
    });

    describe("TEMPLATE widget", function () {

      beforeEach(function () {
        controller.set('expressions', [{}]);
        controller.set('content.widgetType', 'TEMPLATE');
        controller.set('dataSets', [{}]);
        //controller.updateExpressions();
      });


      it('parseExpression is not called', function () {
        expect(controller.parseExpression.called).to.be.false;
      });
      it('parseTemplateExpression is called once', function () {
        expect(controller.parseTemplateExpression.calledOnce).to.be.true;
      });
      it('parseGraphDataset is not called', function () {
        expect(controller.parseGraphDataset.called).to.be.false;
      });
      it('widgetValues is not empty', function () {
        expect(controller.get('widgetValues')).to.not.be.empty;
      });
      it('widgetMetrics is not empty', function () {
        expect(controller.get('widgetMetrics')).to.not.be.empty;
      });
    });

    describe("GRAPH widget", function () {

      beforeEach(function () {
        controller.set('expressions', [{}]);
        controller.set('content.widgetType', 'GRAPH');
        controller.set('dataSets', [{}]);
        //controller.updateExpressions();
      });

      it('parseExpression is not called', function () {
        expect(controller.parseExpression.called).to.be.false;
      });
      it('parseTemplateExpression is not called', function () {
        expect(controller.parseTemplateExpression.called).to.be.false;
      });
      it('parseGraphDataset is called once', function () {
        expect(controller.parseGraphDataset.calledOnce).to.be.true;
      });
      it('widgetValues is not empty', function () {
        expect(controller.get('widgetValues')).to.not.be.empty;
      });
      it('widgetMetrics is not empty', function () {
        expect(controller.get('widgetMetrics')).to.not.be.empty;
      });
    });

  });

  describe("#parseGraphDataset()", function () {
    beforeEach(function () {
      sinon.stub(controller, 'parseExpression').returns({value: 'value'});
    });
    afterEach(function () {
      controller.parseExpression.restore();
    });
    it("empty dataSets", function () {
      expect(controller.parseGraphDataset([])).to.be.eql({
        metrics: [],
        values: []
      });
    });
    it("correct dataSets", function () {
      var result = controller.parseGraphDataset([Em.Object.create({label: 'label'})]);
      expect(result.values).to.be.eql([
        {
          "name": "label",
          "value": "value"
        }
      ]);
      expect(result.metrics).to.be.empty;
    });
  });

  describe("#parseTemplateExpression()", function () {
    beforeEach(function () {
      sinon.stub(controller, 'parseExpression').returns({value: 'value'});
    });
    afterEach(function () {
      controller.parseExpression.restore();
    });
    it("empty expressions", function () {
      expect(controller.parseTemplateExpression("{{Expression1}}", [])).to.be.eql({
        metrics: [],
        values: [
          {
            value: "{{Expression1}}"
          }
        ]
      });
    });
    it("correct expressions", function () {
      var result = controller.parseTemplateExpression("{{Expression1}}", [Em.Object.create({alias: '{{Expression1}}'})]);
      expect(result.values).to.be.eql([
        {
          value: "value"
        }
      ]);
      expect(result.metrics).to.be.empty;
    });
  });

  describe("#parseExpression()", function () {
    it("expression is empty", function () {
      expect(controller.parseExpression({data: []})).to.eql({
        metrics: [],
        value: ''
      });
    });
    it("expression is correct", function () {
      var data = [
        {
          name: 'm1',
          serviceName: 'S1',
          componentName: 'C1',
          metricPath: 'mp',
          hostComponentCriteria: 'hcc',
          isMetric: true
        },
        {
          name: '+'
        },
        {
          name: '10'
        }
      ];
      expect(controller.parseExpression({data: data})).to.eql({
        metrics: [
          {
            "name": "m1",
            "service_name": "S1",
            "component_name": "C1",
            "metric_path": "mp",
            "host_component_criteria": "hcc"
          }
        ],
        value: '${m1+10}'
      });
    });
  });

  describe("#updateProperties()", function () {
    it("widgetPropertiesViews is empty", function () {
      controller.set('widgetPropertiesViews', []);
      expect(controller.get('widgetProperties')).to.be.empty;
    });
    it("widgetPropertiesViews is correct", function () {
      controller.set('widgetPropertiesViews', [
        Em.Object.create({
          valueMap: {
            "key1": 'alias1'
          },
          key1: 1
        })
      ]);
      expect(controller.get('widgetProperties')).to.eql({
        "alias1": 1
      });
    });
  });

  describe("#renderProperties()", function () {
    beforeEach(function () {
      this.mock = sinon.stub(App.WidgetType, 'find');
      sinon.stub(App.WidgetPropertyTypes, 'findProperty').returns({valueMap: {}});
      sinon.stub(App.WidgetProperty, 'create').returns({});
    });
    afterEach(function () {
      this.mock.restore();
      App.WidgetPropertyTypes.findProperty.restore();
      App.WidgetProperty.create.restore();
    });
    it("no properties", function () {
      this.mock.returns(Em.Object.create({properties: []}));
      controller.renderProperties();
      expect(controller.get('widgetPropertiesViews')).to.be.empty;
    });
    it("correct properties", function () {
      this.mock.returns(Em.Object.create({properties: [{}]}));
      controller.renderProperties();
      expect(App.WidgetProperty.create.calledWith({valueMap: {}})).to.be.true;
      expect(controller.get('widgetPropertiesViews')).to.not.be.empty;
    });
  });

  describe("#parseValue()", function () {
    beforeEach(function () {
      sinon.stub(controller, 'getExpressionData').returns({});
    });
    afterEach(function () {
      controller.getExpressionData.restore();
    });
    it("empty value", function () {
      expect(controller.parseValue("", [])).to.be.empty;
    });
    it("correct value", function () {
      expect(controller.parseValue("${m1}", [])).to.not.be.empty;
      expect(controller.getExpressionData.calledWith("m1", [])).to.be.true;
    });
  });

  describe("#getExpressionData()", function () {
    beforeEach(function () {
      sinon.stub(controller, 'getExpressionVariable').returns({});
    });
    afterEach(function () {
      controller.getExpressionVariable.restore();
    });
    it("empty expression", function () {
      expect(controller.getExpressionData("", [])).to.be.empty;
    });
    it("correct expression", function () {
      expect(controller.getExpressionData("m1+10", [])).to.not.be.empty;
      expect(controller.getExpressionVariable.getCall(0).args).to.eql(["m1", 1, []]);
      expect(controller.getExpressionVariable.getCall(1).args).to.eql(["10", 3, []]);
    });
  });

  describe("#getExpressionVariable()", function () {
    it("get metric definition", function () {
      var metrics = [
        {
          name: 'm1',
          component_name: 'C1',
          service_name: 'S1',
          metric_path: 'mp',
          host_component_criteria: 'hcc'
        }
      ];
      expect(controller.getExpressionVariable("m1", 1, metrics)).to.be.eql(Em.Object.create({
        id: 1,
        name: 'm1',
        isMetric: true,
        componentName: 'C1',
        serviceName: 'S1',
        metricPath: 'mp',
        hostComponentCriteria: 'hcc'
      }));
    });
    it("get number definition", function () {
      expect(controller.getExpressionVariable("10", 2, [])).to.be.eql(Em.Object.create({
        id: 2,
        name: "10",
        isNumber: true
      }));
    });
  });

  describe("#next()", function () {
    beforeEach(function () {
      sinon.stub(App.router, 'send');
    });
    afterEach(function () {
      App.router.send.restore();
    });
    it("user is moved to the next step", function () {
      controller.next();
      expect(App.router.send.calledWith('next')).to.be.true;
    });
  });
});