import { expect } from 'meteor/practicalmeteor:chai';
import { Meteor } from 'meteor/meteor';
import _ from 'lodash';

describe('Wm.Pos.Sales.Services.SalesOrderItemMethods', () => {
  let SalesOrderItemMethods = Wm.Pos.Sales.Methods.SalesOrderItem;
  let { OrganizationService } = Wm.Pos.Core.Services;

  let SalesOrderItem = Astro.Class.get('SalesOrderItems');
  let Member = Astro.Class.get('Member');
  let MembersSetting = Astro.Class.get('MembersSetting');
  let Deal = Astro.Class.get('Deal');
  let Deals = Deal.getCollection();
  let SalesOrder = Astro.Class.get('SalesOrder');
  let SalesOrders = SalesOrder.getCollection();

  before(() => {
    sinon.stub(OrganizationService, 'getOrganizationId', () => '420');
    sinon.stub(Meteor, 'userId', () => 'user_id');
  });

  after(() => {
    OrganizationService.getOrganizationId.restore();
    Meteor.userId.restore();
  });

  let fakeDatabase = {
    deals: [{
      _id: 'valid_deal',
      organizationId: '420',
      startTime: _.pick(moment().add({ hours: -1 }).toObject(), ['hours', 'minutes', 'seconds']),
      endTime: _.pick(moment().add({ hours: 1 }).toObject(), ['hours', 'minutes', 'seconds']),
      discountType: '$',
      discountAmount: 500,
      code: 'VALID',
      name: 'Valid Deal'
    }, {
      _id: 'bad_time',
      organizationId: '420',
      startTime: _.pick(moment().add({ hours: -3 }).toObject(), ['hours', 'minutes', 'seconds']),
      endTime: _.pick(moment().add({ hours: -1 }).toObject(), ['hours', 'minutes', 'seconds'])
    }],
    salesOrders: [{
      _id: 'valid_sales_order',
      organizationId: '420',
      memberId: 'member_1'
    }],
    members: [{
      _id: 'member_1',
      organizationId: '420',
      membershipLevel: 'gold'
    }, {
      _id: 'member_2',
      organizationId: '420',
      membershiplevel: 'silver'
    }],
    memberSetting: {
      organizationId: '420',
      membershipLevelsEnabled: true
    }
  };

  describe('addDeal', () => {

    let methodsToStub = {
      '_isLineTypeOnOrder': false,
      '_isTodayValidForDeal': true,
      '_hasDealExceededClaims': false,
      '_hasMemberExceededDealClaims': false,
      '_isMembershipLevelValidForDeal': true
    };

    let stub = methods => {
      _.forEach(methods, key => {
        sinon.stub(SalesOrderItemMethods, key, () => methodsToStub[key]);
      });
    };

    let restore = methods => {
      _.forEach(methods, key => {
        SalesOrderItemMethods[key].restore();
      });
    };

    beforeEach(() => {
      sinon.stub(SalesOrderItem, 'insert');
      sinon.stub(SalesOrders, 'findOne', q => _.find(fakeDatabase.salesOrders, q));
      sinon.stub(Deals, 'findOne', q => _.find(fakeDatabase.deals, q));
      sinon.stub(Member, 'findOne', q => _.find(fakeDatabase.members, q));
      stub(_.keys(methodsToStub));
    });

    afterEach(() => {
      SalesOrderItem.insert.restore();
      SalesOrders.findOne.restore();
      Deals.findOne.restore();
      Member.findOne.restore();
      restore(_.keys(methodsToStub));
    });

    it('should add a deal to a sales order when conditions are met', () => {
      let result = SalesOrderItemMethods.addDeal('valid_deal', 'valid_sales_order');
      expect(result.ok).to.be.true;
      expect(SalesOrderItem.insert.callCount).to.equal(1);
    });
    it('should prevent a deal being added at the wrong time', () => {
      let result = SalesOrderItemMethods.addDeal('bad_time', 'valid_sales_order');
      expect(result.ok).not.to.be.true;
      expect(result.message).to.contain('deal-outside-time-allowed');
    });
    it('should prevent a deal being added if the line item already exists on the same order', () => {
      methodsToStub._isLineTypeOnOrder = true;
      let result = SalesOrderItemMethods.addDeal('valid_deal', 'valid_sales_order');
      expect(result.ok).not.to.be.true;
      expect(result.message).to.contain('only-one-deal-allowed');
      methodsToStub._isLineTypeOnOrder = false;
    });
    it('should prevent a deal being added if its an invalid day', () => {
      methodsToStub._isTodayValidForDeal = false;
      let result = SalesOrderItemMethods.addDeal('valid_deal', 'valid_sales_order');
      expect(result.ok).not.to.be.true;
      expect(result.message).to.contain('invalid-day-for-deal');
      methodsToStub._isTodayValidForDeal = true;
    });
    it('should prevent a deal being added if its claim count is exceeded', () => {
      methodsToStub._hasDealExceededClaims = true;
      let result = SalesOrderItemMethods.addDeal('valid_deal', 'valid_sales_order');
      expect(result.ok).not.to.be.true;
      expect(result.message).to.contain('maximum-claims-code');
      methodsToStub._hasDealExceededClaims = false;
    });
    it('should prevent a deal being added if its claim per member is exceeded', () => {
      methodsToStub._hasMemberExceededDealClaims = true;
      let result = SalesOrderItemMethods.addDeal('valid_deal', 'valid_sales_order');
      expect(result.ok).not.to.be.true;
      expect(result.message).to.contain('maximum-claims-client');
      methodsToStub._hasMemberExceededDealClaims = false;
    });
    it('should prevent a deal being added for improper membership levels', () => {
      methodsToStub._isMembershipLevelValidForDeal = false;
      let result = SalesOrderItemMethods.addDeal('valid_deal', 'valid_sales_order');
      expect(result.ok).not.to.be.true;
      expect(result.message).to.contain('invalid-membership-level');
      methodsToStub._isMembershipLevelValidForDeal = true;
    });
  });



  describe('_isMembershipLevelValidForDeal', () => {

    let deal = {
      applicableMembershipLevels: ['gold']
    };

    beforeEach(() => {
      sinon.stub(Member, 'findOne', q => _.find(fakeDatabase.members, q));
      sinon.stub(MembersSetting, 'findOne', () => fakeDatabase.memberSetting);
    });

    afterEach(() => {
      Member.findOne.restore();
      MembersSetting.findOne.restore();
    });

    it('should validate the members membership level if settings are enabled', () => {
      let result = SalesOrderItemMethods._isMembershipLevelValidForDeal(deal, 'member_1', '420');
      expect(result).to.be.true;
    });
    it('should validate if settings are disabled', () => {
      MembersSetting.findOne.restore();
      sinon.stub(MembersSetting, 'findOne', () => ({ membershiplevelsEnabled: false }));

      let result = SalesOrderItemMethods._isMembershipLevelValidForDeal(deal, 'member_1', '420');
      expect(result).to.be.true;
    });
    it('should not validate if deal is not for membership level', () => {
      let result = SalesOrderItemMethods._isMembershipLevelValidForDeal(deal, 'member_2', '420');
      expect(result).not.to.be.that.of.which.is.true;
    });
  });



  describe('_hasMemberExceededDealClaims', () => {

    let deal = {
      code: 'chicken',
      maximumClaimsPerClient: 2
    };

    let infiniteDeal = {
      code: 'butts',
      maximumClaimsPerClient: 0
    }

    let salesOrderItems = [{
      sku: 'chicken',
      memberId: '1'
    }, {
      sku: 'chicken',
      memberId: '1'
    }, {
      sku: 'chicken',
      memberId: '2'
    }, {
      sku: 'butts',
      memberId: '1'
    }, {
      sku: 'butts',
      memberId: '1'
    }, {
      sku: 'butts',
      memberId: '1'
    }];

    beforeEach(() => {
      sinon.stub(SalesOrderItem, 'find', q => ({ count: () => (_.filter(salesOrderItems, _.pick(q, ['sku', 'memberId'])).length) }));
    });

    afterEach(() => {
      SalesOrderItem.find.restore();
    });

    it('should validate if member has not exceeded claims', () => {
      let result = SalesOrderItemMethods._hasMemberExceededDealClaims(deal, '2', '420');
      expect(result).to.be.false;
    });
    it('should not validate if member has exceeded claims', () => {
      let result = SalesOrderItemMethods._hasMemberExceededDealClaims(deal, '1', '420');
      expect(result).to.be.true;
    });
    it('should validate if claims is 0', () => {
      let result = SalesOrderItemMethods._hasMemberExceededDealClaims(infiniteDeal, '1', '420');
      expect(result).to.be.false;
    });
  });



  describe('_hasDealExceededClaims', () => {
    let infiniDeal = {
      maximumClaimsPerCode: 0,
      code: 'chicken'
    };
    let deal = {
      maximumClaimsPerCode: 2,
      code: 'uniquemofo'
    };
    let exceededDeal = {
      maximumClaimsPerCode: 1,
      code: 'potato'
    };

    let salesOrderItems = [{
      sku: 'chicken'
    }, {
      sku: 'chicken'
    }, {
      sku: 'uniquemofo'
    }, {
      sku: 'potato'
    }];

    beforeEach(() => {
      sinon.stub(SalesOrderItem, 'find', q => ({ count: () => (_.filter(salesOrderItems, _.pick(q, ['sku'])).length) }));
    });

    afterEach(() => {
      SalesOrderItem.find.restore();
    });

    it('should validate if claims count is set to 0', () => {
      let result = SalesOrderItemMethods._hasDealExceededClaims(infiniDeal, '420');
      expect(result).to.equal.false;
    });
    it('should validate if claims are less than the set value', () => {
      let result = SalesOrderItemMethods._hasDealExceededClaims(deal, '420');
      expect(result).to.equal.false;
    });
    it('should not validate if claims are greater than the set value', () => {
      let result = SalesOrderItemMethods._hasDealExceededClaims(exceededDeal, '420');
      expect(result).to.equal.true;
    });
  });



  describe('_isTodayValidForDeal', () => {
    let DAY = moment().format('ddd').toUpperCase();
    let ANOTHER_DAY = moment().add({ days: 1 }).format('ddd').toUpperCase();

    let todaysDeal = {
      validDays: [DAY]
    };
    let tomorrowsDeal = {
      validDays: [ANOTHER_DAY]
    };

    it('should validate if today falls in the array', () => {
      let result = SalesOrderItemMethods._isTodayValidForDeal(todaysDeal);
      expect(result).to.be.true;
    });
    it('should not validate if today does not fall in the array', () => {
      let result = SalesOrderItemMethods._isTodayValidForDeal(tomorrowsDeal);
      expect(result).to.be.false;
    });
  });



  describe('_isLineTypeOnOrder', () => {

    let salesOrderItems = [{
      salesOrderId: 'with_deal',
      type: 'deal'
    }, {
      salesOrderId: 'with_deal',
      type: 'product'
    }, {
      salesOrderId: 'without_deal',
      type: 'product'
    }, {
      salesOrderId: 'without_deal',
      type: 'product'
    }];

    beforeEach(() => {
      sinon.stub(SalesOrderItem, 'find', q => ({ count: () => (_.filter(salesOrderItems, _.pick(q, ['salesOrderId', 'type'])).length) }));
    });

    afterEach(() => {
      SalesOrderItem.find.restore();
    });

    it('should validate by checking the current sales order for another deal type', () => {
      let result = SalesOrderItemMethods._isLineTypeOnOrder('deal', 'without_deal', '420');
      expect(result).not.to.be.true;
    });
    it('should not validate by checking and finding a deal type line item on the existing order', () => {
      let result = SalesOrderItemMethods._isLineTypeOnOrder('deal', 'with_deal', '420');
      expect(result).to.be.true;
    });
  });



});