/**
 * 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.
 */

var App = require('app');
var numberUtils = require("utils/number_utils");
var misc = require('utils/misc');


describe('App.WidgetWizardExpressionView', function () {
  var view;

  beforeEach(function() {
    view = App.WidgetWizardExpressionView.create({
      expression: {
        data: []
      },
      controller: Em.Object.create({
        updateExpressions: Em.K
      })
    });
    view.removeObserver('expression.data.length', view, 'validate');
  });

  describe("#validate()", function() {
    var testCases = [
      {
        data: [],
        result: false
      },
      {
        data: [
          {isMetric: true, name:'1'}
        ],
        result: false
      },
      {
        data: [
          {isMetric: true, name:'1'},
          {name: '+'},
          {isMetric: true, name:'1'}
        ],
        result: false
      },
      {
        data: [
          {name: '('},
          {isMetric: true, name:'1'},
          {name: '-'},
          {isMetric: true, name:'1'},
          {name: ')'}
        ],
        result: false
      },
      {
        data: [
          {name: '('},
          {isMetric: true, name:'1'},
          {name: '-'},
          {isMetric: true, name:'1'},
          {name: ')'},
          {name: '*'},
          {isMetric: true, name:'1'}
        ],
        result: false
      },
      {
        data: [
          {name: '('},
          {name: '('},
          {isMetric: true, name:'1'},
          {name: '-'},
          {isMetric: true, name:'1'},
          {name: ')'},
          {name: '*'},
          {isMetric: true, name:'1'},
          {name: ')'}
        ],
        result: false
      },
      {
        data: [
          {name: '-'}
        ],
        result: true
      },
      {
        data: [
          {name: '-'},
          {isMetric: true, name:'1'}
        ],
        result: true
      },
      {
        data: [
          {isMetric: true, name:'1'},
          {name: '+'}
        ],
        result: true
      },
      {
        data: [
          {name: '*'},
          {isMetric: true, name:'1'},
          {name: '+'}
        ],
        result: true
      },
      {
        data: [
          {isMetric: true, name:'1'},
          {name: '('}
        ],
        result: true
      },
      {
        data: [
          {name: ')'},
          {isMetric: true, name:'1'}
        ],
        result: true
      },
      {
        data: [
          {name: '('}
        ],
        result: true
      },
      {
        data: [
          {name: '('},
          {isMetric: true, name:'1'}
        ],
        result: true
      },
      {
        data: [
          {isMetric: true, name:'1'},
          {name: '('}
        ],
        result: true
      },
      {
        data: [
          {name: '('},
          {isMetric: true, name:'1'},
          {name: '+'},
          {isMetric: true, name:'1'}
        ],
        result: true
      },
      {
        data: [
          {isMetric: true, name:'1'},
          {name: '+'},
          {isMetric: true, name:'1'},
          {name: ')'}
        ],
        result: true
      },
      {
        data: [
          {name: '('},
          {name: '('},
          {isMetric: true, name:'1'},
          {name: '+'},
          {isMetric: true, name:'1'},
          {name: ')'}
        ],
        result: true
      }
    ];
    testCases.forEach(function (test) {
      it(test.data.mapProperty('name').join("") + " - isInvalid = " + test.result, function () {
        view.set('expression.data', test.data);
        view.validate();
        expect(view.get('isInvalid')).to.equal(test.result);
      });
    }, this);
  });

  describe("#isNumberValueInvalid", function() {

    beforeEach(function() {
      sinon.stub(numberUtils, 'isPositiveNumber').returns(true)
    });
    afterEach(function() {
      numberUtils.isPositiveNumber.restore();
    });

    it("numberValue is empty", function() {
      view.set('numberValue', '');
      view.propertyDidChange('isNumberValueInvalid');
      expect(view.get('isNumberValueInvalid')).to.be.true;
    });

    it("numberValue is ' '", function() {
      view.set('numberValue', ' ');
      view.propertyDidChange('isNumberValueInvalid');
      expect(view.get('isNumberValueInvalid')).to.be.true;
    });

    it("numberValue is '2'", function() {
      view.set('numberValue', '2');
      view.propertyDidChange('isNumberValueInvalid');
      expect(view.get('isNumberValueInvalid')).to.be.false;
    });
  });

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

    it("add first operator", function() {
      var event = {context: 'o1'};
      view.set('expression', Em.Object.create({
        data: []
      }));
      view.addOperator(event);
      expect(view.get('expression.data').mapProperty('id')).to.eql([1]);
      expect(view.get('expression.data').mapProperty('name')).to.eql(['o1']);
    });

    it("add second operator", function() {
      var event = {context: 'o2'};
      view.set('expression', Em.Object.create({
        data: [{id: 1, name: 'o1'}]
      }));
      view.addOperator(event);
      expect(view.get('expression.data').mapProperty('id')).to.eql([1, 2]);
      expect(view.get('expression.data').mapProperty('name')).to.eql(['o1', 'o2']);
    });
  });

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

    it("add first number", function() {
      view.set('expression', Em.Object.create({
        data: []
      }));
      view.set('numberValue', '1');
      view.addNumber();
      expect(view.get('expression.data').mapProperty('id')).to.eql([1]);
      expect(view.get('expression.data').mapProperty('name')).to.eql(['1']);
      expect(view.get('numberValue')).to.be.empty;
    });

    it("add second number", function() {
      view.set('expression', Em.Object.create({
        data: [{id: 1, name: '1'}]
      }));
      view.set('numberValue', '2');
      view.addNumber();
      expect(view.get('expression.data').mapProperty('id')).to.eql([1, 2]);
      expect(view.get('expression.data').mapProperty('name')).to.eql(['1', '2']);
      expect(view.get('numberValue')).to.be.empty;
    });
  });

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

    beforeEach(function() {
      sinon.stub(misc, 'sortByOrder').returns([{}]);
    });
    afterEach(function() {
      misc.sortByOrder.restore();
    });

    it("sortByOrder should be called", function() {
      view.redrawField();
      expect(misc.sortByOrder.calledOnce).to.be.true;
      expect(view.get('expression.data')).to.be.eql([{}]);
    });
  });

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

    beforeEach(function() {
      sinon.stub(view, 'propertyDidChange');
      sinon.stub(Em.run, 'next');
    });
    afterEach(function() {
      view.propertyDidChange.restore();
      Em.run.next.restore();
    });

    it("Em.run.next should be called", function() {
      view.didInsertElement();
      expect(view.propertyDidChange.calledOnce).to.be.true;
      expect(Em.run.next.calledOnce).to.be.true;
    });
  });

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

    it("object should be removed", function() {
      var event = {context: 'el1'};
      view.set('expression.data', [event.context]);
      view.removeElement(event);
      expect(view.get('expression.data')).to.be.empty;
    });
  });
});

describe("App.AddNumberExpressionView", function() {

  var view;

  beforeEach(function() {
    view = App.AddNumberExpressionView.create();
  });

  describe("#isInvalid", function() {

    beforeEach(function() {
      sinon.stub(numberUtils, 'isPositiveNumber').returns(true)
    });
    afterEach(function() {
      numberUtils.isPositiveNumber.restore();
    });

    it("value is empty", function() {
      view.set('value', '');
      view.propertyDidChange('isInvalid');
      expect(view.get('isInvalid')).to.be.false;
    });

    it("value is ' '", function() {
      view.set('value', ' ');
      view.propertyDidChange('isInvalid');
      expect(view.get('isInvalid')).to.be.false;
    });

    it("value is '2'", function() {
      view.set('value', '2');
      view.propertyDidChange('isInvalid');
      expect(view.get('isInvalid')).to.be.false;
    });
  });
});

describe("App.InputCursorTextfieldView", function() {

  var view;

  beforeEach(function() {
    view = App.InputCursorTextfieldView.create({
      parentView: App.WidgetWizardExpressionView.create({
        expression: {
          data: []
        },
        controller: Em.Object.create({
          updateExpressions: Em.K
        })
      })
    });
    view.removeObserver('value', view, 'validateInput');
  });

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

    beforeEach(function() {
      sinon.stub(view, 'focusCursor');
    });
    afterEach(function() {
      view.focusCursor.restore();
    });

    it("focusCursor should be called", function() {
      view.didInsertElement();
      expect(view.focusCursor.calledOnce).to.be.true;
    });
  });

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

    beforeEach(function() {
      sinon.stub(view, 'saveNumber');
    });
    afterEach(function() {
      view.saveNumber.restore();
    });

    it("saveNumber should be called", function() {
      view.focusOut();
      expect(view.saveNumber.calledOnce).to.be.true;
    });
  });

  describe("#focusCursor()", function() {
    var mock = {
      focus: Em.K
    };

    beforeEach(function() {
      sinon.stub(Em.run, 'next', Em.clb);
      sinon.stub(view, '$').returns(mock);
      sinon.stub(mock, 'focus');
      view.focusCursor();
    });
    afterEach(function() {
      Em.run.next.restore();
      view.$.restore();
      mock.focus.restore();
    });

    it("Em.run.next should be called", function() {
      expect(Em.run.next.calledOnce).to.be.true;
    });

    it("$ should be called", function() {
      expect(view.$.calledTwice).to.be.true;
    });

    it("focus should be called", function() {
      expect(mock.focus.calledOnce).to.be.true;
    });
  });

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

    beforeEach(function() {
      this.mock = sinon.stub(numberUtils, 'isPositiveNumber');
    });
    afterEach(function() {
      this.mock.restore();
    });

    it("value is positive number", function() {
      this.mock.returns(true);
      view.validateInput();
      expect(view.get('isInvalid')).to.be.false;
    });

    it("value is null", function() {
      this.mock.returns(false);
      view.set('value', null);
      view.validateInput();
      expect(view.get('isInvalid')).to.be.false;
    });

    it("value is empty", function() {
      this.mock.returns(false);
      view.set('value', '');
      view.validateInput();
      expect(view.get('isInvalid')).to.be.false;
    });

    it("value is operator", function() {
      this.mock.returns(false);
      view.set('value', '+');
      view.validateInput();
      expect(view.get('isInvalid')).to.be.false;
      expect(view.get('parentView.expression.data')).to.not.be.empty;
      expect(view.get('value')).to.be.empty;
    });

    it("value is 'm'", function() {
      this.mock.returns(false);
      view.set('value', '+');
      view.validateInput();
      expect(view.get('isInvalid')).to.be.false;
      expect(view.get('value')).to.be.empty;
    });

    it("value is invalid", function() {
      this.mock.returns(false);
      view.set('value', '%');
      view.validateInput();
      expect(view.get('isInvalid')).to.be.true;
    });
  });

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

    beforeEach(function() {
      sinon.stub(view, 'saveNumber');
    });
    afterEach(function() {
      view.saveNumber.restore();
    });

    it("unexpected key", function() {
      view.set('parentView.expression.data', [{name: '1'}, {name: '2'}]);
      view.keyDown({keyCode: 9});
      expect(view.saveNumber.called).to.be.false;
      expect(view.get('parentView.expression.data.length')).to.be.equal(2);
    });

    it("backspace key and not empty value", function() {
      view.set('value', 'm');
      view.set('parentView.expression.data', [{name: '1'}, {name: '2'}]);
      view.keyDown({keyCode: 8});
      expect(view.saveNumber.called).to.be.false;
      expect(view.get('parentView.expression.data.length')).to.be.equal(2);
    });

    it("backspace key and empty value", function() {
      view.set('value', '');
      view.set('parentView.expression.data', [{name: '1'}, {name: '2'}]);
      view.keyDown({keyCode: 8});
      expect(view.saveNumber.called).to.be.false;
      expect(view.get('parentView.expression.data.length')).to.be.equal(1);
    });

    it("enter key", function() {
      view.set('value', '');
      view.set('parentView.expression.data', [{name: '1'}, {name: '2'}]);
      view.keyDown({keyCode: 13});
      expect(view.saveNumber.called).to.be.true;
      expect(view.get('parentView.expression.data.length')).to.be.equal(2);
    });
  });

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

    beforeEach(function() {
      this.mock = sinon.stub(numberUtils, 'isPositiveNumber');
    });
    afterEach(function() {
      this.mock.restore();
    });

    it("value is a positive number", function() {
      view.set('value', '1');
      this.mock.returns(true);
      view.saveNumber();
      expect(view.get('parentView.expression.data').mapProperty('name')).to.be.eql(['1']);
      expect(view.get('numberValue')).to.be.empty;
      expect(view.get('isInvalid')).to.be.false;
      expect(view.get('value')).to.be.empty;
    });

    it("value is not a positive number", function() {
      view.set('value', '-1');
      this.mock.returns(false);
      view.saveNumber();
      expect(view.get('parentView.expression.data')).to.be.empty;
      expect(view.get('value')).to.be.equal('-1');
    });
  });

});

describe('#App.AddMetricExpressionView', function() {
  var AddMetricExpressionView;
  
  beforeEach(function() {
    AddMetricExpressionView = App.AddMetricExpressionView.create({
      currentSelectedComponent: Em.Object.create(),
      controller: Em.Object.create(),
      parentView: Em.Object.create({
        AGGREGATE_FUNCTIONS: ['fun1']
      }),
      elementId: '1'
    });
  });
  
  describe('#metricsSelectionObj.onChangeCallback', function() {
  
    beforeEach(function() {
      AddMetricExpressionView.set('controller.filteredMetrics',  [{
        component_name: 'C1',
        level: 'l1',
        name: 'metric1',
        widget_id: 1
      }]);
      AddMetricExpressionView.set('currentSelectedComponent', Em.Object.create({
        componentName: 'C1',
        serviceName: 'S1',
        level: 'l1',
        hostComponentCriteria: 'criteria1',
        tag: 'tag1',
        selectedAggregation: Em.I18n.t('dashboard.widgets.wizard.step2.aggregateFunction.scanOps')
      }));
      var metricsSelectionObj = AddMetricExpressionView.get('metricsSelectionObj');
      metricsSelectionObj.onChangeCallback({}, {selected: 'metric1'});
    });
    
    it('selectedMetric should be set', function() {
      expect(AddMetricExpressionView.get('currentSelectedComponent.selectedMetric')).to.be.eql(Em.Object.create({
        name: 'metric1',
        hostComponentCriteria: 'criteria1',
        tag: 'tag1',
        componentName: 'C1',
        serviceName: 'S1',
        metricPath: 1,
        isMetric: true
      }));
    });
  
    it('selectedAggregation should be set', function() {
      expect(AddMetricExpressionView.get('currentSelectedComponent.selectedAggregation')).to.be.equal('fun1');
    });
  });
  
  describe('#aggregateFnSelectionObj.onChangeCallback', function() {

    it('selectedAggregation should be set', function() {
      AddMetricExpressionView.set('currentSelectedComponent', Em.Object.create({}));
      var aggregateFnSelectionObj = AddMetricExpressionView.get('aggregateFnSelectionObj');
      aggregateFnSelectionObj.onChangeCallback({}, {selected: 'name1'});
      expect(AddMetricExpressionView.get('currentSelectedComponent.selectedAggregation')).to.be.equal('name1');
    });
  });
  
  describe('#selectComponents', function() {
    var event = {
      context: {},
      stopPropagation: sinon.spy()
    };
    beforeEach(function() {
      AddMetricExpressionView.selectComponents(event);
    });

    it('currentSelectedComponent should be set', function() {
      expect(AddMetricExpressionView.get('currentSelectedComponent')).to.be.an.object;
    });
  
    it('stopPropagation should be called', function() {
      expect(event.stopPropagation.called).to.be.true;
    });
  });
  
  describe('#addMetric', function() {
    var event = {
      context: Em.Object.create({
        selectedMetric: {
          metricPath: 'path',
          name: 'metric1'
        },
        selectedAggregation: 'fun1',
        isAddEnabled: true,
        showAggregateSelect: true
      })
    };
    var data = [];
    beforeEach(function() {
      sinon.stub(AddMetricExpressionView, 'cancel');
      AddMetricExpressionView.set('parentView.expression', {
        data: data
      });
      AddMetricExpressionView.addMetric(event);
    });
    afterEach(function() {
      AddMetricExpressionView.cancel.restore();
    });
    
    it('metric should be added', function() {
      expect(data[0]).to.be.eql(Em.Object.create({
        id: 1,
        metricPath: 'path._fun1',
        name: 'metric1._fun1'
      }));
    });
  
    it('cancel should be called', function() {
      expect(AddMetricExpressionView.cancel.called).to.be.true;
    });
  });
  
  describe('#cancel', function() {
    
    it('selectedAggregation should be set', function() {
      AddMetricExpressionView.cancel();
      expect(AddMetricExpressionView.get('currentSelectedComponent.selectedAggregation')).to.be.equal(
        Em.I18n.t('dashboard.widgets.wizard.step2.aggregateFunction.scanOps')
      );
    });
  
    it('selectedMetric should be null', function() {
      AddMetricExpressionView.cancel();
      expect(AddMetricExpressionView.get('currentSelectedComponent.selectedMetric')).to.be.null;
    });
  });
  
  describe('#getNameServiceGroups', function() {
    beforeEach(function() {
      sinon.stub(App, 'get').returns(true);
      sinon.stub(App.HDFSService, 'find').returns(Em.Object.create({
        masterComponentGroups: [
          {
            name: 'g1'
          }
        ]
      }));
    });
    afterEach(function() {
      App.get.restore();
      App.HDFSService.find.restore();
    });
    
    it('should return service groups', function() {
      expect(AddMetricExpressionView.getNameServiceGroups()).to.be.eql([{
        tag: 'g1',
        displayName: Em.I18n.t('dashboard.widgets.wizard.step2.nameSpaceDropDownItem').format('g1'),
        component: null
      }]);
    });
  });
  
  describe('#getServicesMap', function() {
    beforeEach(function() {
      sinon.stub(App, 'get').returns(true);
      sinon.stub(App.StackServiceComponent, 'find').returns([{
        isMaster: true,
        componentName: 'C2'
      }]);
    });
    afterEach(function() {
      App.get.restore();
      App.StackServiceComponent.find.restore();
    });
  
    it('should return empty when no metrics', function() {
      AddMetricExpressionView.set('controller.filteredMetrics', []);
      expect(AddMetricExpressionView.getServicesMap()).to.be.empty;
    });
  
    it('should return empty when no metrics', function() {
      AddMetricExpressionView.set('controller.filteredMetrics', [
        {
          name: 'metric1',
          component_name: 'NAMENODE',
          level: 'COMPONENT',
          service_name: 'HDFS',
          host_component_criteria: 'criteria1'
        },
        {
          name: 'metric2',
          component_name: 'C1',
          service_name: 'S1',
          level: 'COMPONENT',
          host_component_criteria: 'criteria1'
        },
        {
          name: 'metric3',
          component_name: 'C2',
          service_name: 'S1',
          level: 'COMPONENT',
          host_component_criteria: 'criteria1'
        }
      ]);
      expect(AddMetricExpressionView.getServicesMap()).to.be.eql({
        "S1": {
          "components": {
            "C1": {
              "component_name": "C1",
              "count": 1,
              "hostComponentCriteria": "criteria1",
              "level": "COMPONENT",
              "metrics": [
                "metric2"
              ]
            },
            "C2_COMPONENT": {
              "component_name": "C2",
              "count": 1,
              "hostComponentCriteria": "criteria1",
              "level": "COMPONENT",
              "metrics": [
                "metric3"
              ]
            }
          },
          "count": 2
        }
      });
    });
  });
  
  describe('#componentMap', function() {
    var nameServiceGroups = [{}];
    beforeEach(function() {
      sinon.stub(App, 'get').returns(true);
      sinon.stub(AddMetricExpressionView, 'getServicesMap').returns({
        "S1": {
          "components": {
            "C1": {
              "component_name": "C1",
              "count": 1,
              "hostComponentCriteria": "criteria1",
              "level": "COMPONENT",
              "metrics": [
                "metric2"
              ]
            }
          },
          "count": 1
        },
        "HDFS": {
          "components": {
            "NAMENODE": {
              "component_name": "NAMENODE",
              "count": 1,
              "hostComponentCriteria": "criteria1",
              "level": "COMPONENT",
              "metrics": [
                "metric3"
              ]
            }
          },
          "count": 1
        }
      });
      sinon.stub(AddMetricExpressionView, 'getNameServiceGroups').returns(nameServiceGroups);
      sinon.stub(App.HostComponent, 'getCount').returns(1);
      sinon.stub(AddMetricExpressionView, 'createComponentItem').returns({});
      sinon.stub(AddMetricExpressionView, 'putContextServiceOnTop', function(result) {
        return result;
      });
      sinon.stub(App.StackService, 'find').returns(Em.Object.create({displayName: 'foo'}));
    });
    afterEach(function() {
      App.get.restore();
      AddMetricExpressionView.getServicesMap.restore();
      App.HostComponent.getCount.restore();
      AddMetricExpressionView.getNameServiceGroups.restore();
      AddMetricExpressionView.createComponentItem.restore();
      AddMetricExpressionView.putContextServiceOnTop.restore();
      App.StackService.find.restore();
    });
    
    it('should return map of components', function() {
      AddMetricExpressionView.propertyDidChange('componentMap');
      expect(AddMetricExpressionView.get('componentMap')).to.be.eql([
        Em.Object.create({
          serviceName: 'S1',
          //in order to support panel lists
          href: '#S1',
          displayName: 'foo',
          count: 1,
          components: [{}]
        }),
        Em.Object.create({
          serviceName: 'HDFS',
          //in order to support panel lists
          href: '#HDFS',
          displayName: 'foo',
          count: 1,
          components: [
            Em.Object.create({
              displayName: 'NameNodes',
              isGroup: true,
              components: nameServiceGroups
            })
          ]
        })
      ]);
    });
  });
  
  describe('#createComponentItem', function() {
    beforeEach(function() {
      sinon.stub(App.StackServiceComponent, 'find').returns(Em.Object.create({
        isMaster: true,
        displayName: 'c1'
      }));
    });
    afterEach(function() {
      App.StackServiceComponent.find.restore();
    });
    
    it('should return component', function() {
      var service = {
        "components": {
          "C1": {
            "component_name": "C1",
            "count": 1,
            "hostComponentCriteria": "criteria1",
            "level": "HOSTCOMPONENT",
            "metrics": [
              "metric2"
            ]
          }
        }
      };
      var component = AddMetricExpressionView.createComponentItem(service, 'S1', 'C1', '1', 'tag1');
      component.reopen({
        showAggregateSelect: false,
        isAddEnabled: false
      });
      expect(component).to.be.eql(Em.Object.create({
        componentName: 'C1',
        isAddEnabled: false,
        level: 'HOSTCOMPONENT',
        displayName: Em.I18n.t('widget.create.wizard.step2.activeComponents').format('c1'),
        tag: 'tag1',
        count: 1,
        metrics: ['metric2'],
        selected: false,
        id: 'C11tag1',
        aggregatorId: 'C11_aggregator',
        serviceName: 'S1',
        showAggregateSelect: false,
        selectedMetric: null,
        selectedAggregation: Em.I18n.t('dashboard.widgets.wizard.step2.aggregateFunction.scanOps'),
        hostComponentCriteria: 'criteria1'
      }));
    });
  });
  
  describe('#putContextServiceOnTop', function() {
    
    it('should move service to the top of array', function() {
      AddMetricExpressionView.set('controller.content', {widgetService: 'S2'});
      var serviceComponentMap = [
        {
          serviceName: 'S1'
        },
        {
          serviceName: 'S2'
        }
      ];
      expect(AddMetricExpressionView.putContextServiceOnTop(serviceComponentMap)).to.be.eql([
        {
          serviceName: 'S2'
        },
        {
          serviceName: 'S1'
        }
      ]);
    });
  });
 
});