'use strict';

var Promise = require('bluebird');
var crypto = require('crypto');
var expect = require('chai').expect;
var _ = require('lodash');
var mockFactory =

require('@vixlet/vixlet-utils').mockFactory;
var VixQue =

require('@vixlet/vix-que');

var environmentDefaults = require('../../../utils/environment-defaults');
var User = require('../../../utils/user');
var Domain = require('../../../utils/domain');
var VixletJs = require('../../../index.js');

var cologor = require('../../../utils/cologor');

var waitDuration = 10000;

var titleableCapsuleCover = 'vix_burger.png';
var untitleableCapsuleCover = 'vix_pony.png';
var invalidCapsuleCover = 'vix_idontexist.png';


describe('Capsule Microservice', function () {

  cologor.setIndentLevel(3);

  describe('titles', function () {

    var creator;

    var createUser = function () {
      var params = User.randomUser();
      var password = params.password;
      var vixletJs = new VixletJs({base: environmentDefaults.apiHost});
      return User.createActivatedUser(params)
        .then(function (result) {
          return vixletJs.authenticate({
            grantType: 'password',
            clientId: environmentDefaults.clientId,
            username: result.username,
            password: password
          });
        });
    };

    before(function (done) {

      this.timeout(50000 + waitDuration);

      createUser()
        .then(function (user) {
          creator = user;
          cologor.debug('Done! Waiting ' + waitDuration + ' milliseconds...');
          setTimeout(function () {
            done();
          }, waitDuration);
        })
        .catch(function (err) {
          cologor.error(err);
          return done(err);
        });
    });

    it('should not allow a capsule to be created with an invalid capsule cover', function (done) {
      var capsuleParams = {
        contributable: 'private',
        description: 'Welcome...',
        location: 'Los Angeles, California',
        name: 'The Vixletverse',
        privacy: 'public',
        cover: invalidCapsuleCover
      };
      creator.capsule.create(capsuleParams)
        .then(function (result) {
          return done(new Error('Unexpected success case', result));
        })
        .catch(function (err) {
          expect(err.status).to.equal(400);
          expect(err.response.body).to.exist;
          expect(err.response.body.message).to.contain('Invalid cover');
          expect(err.response.body.name).to.equal('BadRequest');
          return done();
        });
    });

    describe('titleable capsule covers', function() {

      it('should allow a capsule to be created and hasTitle from user input is used when set to true', function(done) {
        this.timeout(4000);
        var capsuleParams  = {
          contributable: 'private',
          description: 'Welcome...',
          location: 'Los Angeles, California',
          name: 'The Vixletverse',
          privacy: 'public',
          cover: titleableCapsuleCover,
          hasTitle: true
        };
        return creator.capsule.create(capsuleParams)
          .then(function(capsule) {
            expect(capsule).to.be.an('object');
            expect(capsule.id).to.be.a('string');
            expect(capsule.name).to.equal(capsuleParams.name);
            expect(capsule.description).to.equal(capsuleParams.description);
            expect(capsule.hasTitle).to.equal(capsuleParams.hasTitle);
            return done();
          })
          .catch(done);
      });

      it('should allow a capsule to be created and hasTitle from user input is used when set to false', function(done) {
        this.timeout(4000);
        var capsuleParams  = {
          contributable: 'private',
          description: 'Welcome...',
          location: 'Los Angeles, California',
          name: 'The Vixletverse',
          privacy: 'public',
          cover: titleableCapsuleCover,
          hasTitle: false
        };
        return creator.capsule.create(capsuleParams)
          .then(function(capsule) {
            expect(capsule).to.be.an('object');
            expect(capsule.id).to.be.a('string');
            expect(capsule.name).to.equal(capsuleParams.name);
            expect(capsule.description).to.equal(capsuleParams.description);
            expect(capsule.hasTitle).to.equal(capsuleParams.hasTitle);
            return done();
          })
          .catch(done);
      });

      it('should allow a capsule\'s hasTitle to be updated from true to false', function(done) {
        this.timeout(4000);
        var capsuleParams  = {
          contributable: 'private',
          description: 'Welcome...',
          location: 'Los Angeles, California',
          name: 'The Vixletverse',
          privacy: 'public',
          cover: titleableCapsuleCover,
          hasTitle: true
        };
        return creator.capsule.create(capsuleParams)
          .then(function(capsule) {
            expect(capsule).to.be.an('object');
            expect(capsule.id).to.be.a('string');
            expect(capsule.name).to.equal(capsuleParams.name);
            expect(capsule.description).to.equal(capsuleParams.description);
            expect(capsule.hasTitle).to.equal(capsuleParams.hasTitle);
            return creator.capsule.update({ id: capsule.id, hasTitle: false });
          })
          .then(function(capsule) {
            expect(capsule).to.be.an('object');
            expect(capsule.id).to.be.a('string');
            expect(capsule.name).to.equal(capsuleParams.name);
            expect(capsule.description).to.equal(capsuleParams.description);
            expect(capsule.hasTitle).to.equal(false);
            return done();
          })
          .catch(done);
      });

      it('should allow a capsule\'s hasTitle to be updated from false to true', function(done) {
        this.timeout(4000);
        var capsuleParams  = {
          contributable: 'private',
          description: 'Welcome...',
          location: 'Los Angeles, California',
          name: 'The Vixletverse',
          privacy: 'public',
          cover: titleableCapsuleCover,
          hasTitle: false
        };
        return creator.capsule.create(capsuleParams)
          .then(function(capsule) {
            expect(capsule).to.be.an('object');
            expect(capsule.id).to.be.a('string');
            expect(capsule.name).to.equal(capsuleParams.name);
            expect(capsule.description).to.equal(capsuleParams.description);
            expect(capsule.hasTitle).to.equal(capsuleParams.hasTitle);
            return creator.capsule.update({ id: capsule.id, hasTitle: true });
          })
          .then(function(capsule) {
            expect(capsule).to.be.an('object');
            expect(capsule.id).to.be.a('string');
            expect(capsule.name).to.equal(capsuleParams.name);
            expect(capsule.description).to.equal(capsuleParams.description);
            expect(capsule.hasTitle).to.equal(true);
            return done();
          })
          .catch(done);
      });
    });

    describe('untitleable capsule covers', function() {

      it('should allow a capsule to be created and hasTitle is to be true', function(done) {
        this.timeout(4000);
        var capsuleParams  = {
          contributable: 'private',
          description: 'Welcome...',
          location: 'Los Angeles, California',
          name: 'The Vixletverse',
          privacy: 'public',
          cover: untitleableCapsuleCover,
          hasTitle: true
        };
        return creator.capsule.create(capsuleParams)
          .then(function(capsule) {
            expect(capsule).to.be.an('object');
            expect(capsule.id).to.be.a('string');
            expect(capsule.name).to.equal(capsuleParams.name);
            expect(capsule.description).to.equal(capsuleParams.description);
            //expect(capsule.hasTitle).to.equal(true);
            return done();
          })
          .catch(done);
      });

      it('should allow a capsule to be created and hasTitle from user input is used when set to false', function(done) {
        this.timeout(4000);
        var capsuleParams  = {
          contributable: 'private',
          description: 'Welcome...',
          location: 'Los Angeles, California',
          name: 'The Vixletverse',
          privacy: 'public',
          cover: untitleableCapsuleCover,
          hasTitle: false
        };
        return creator.capsule.create(capsuleParams)
          .then(function(capsule) {
            expect(capsule).to.be.an('object');
            expect(capsule.id).to.be.a('string');
            expect(capsule.name).to.equal(capsuleParams.name);
            expect(capsule.description).to.equal(capsuleParams.description);
            expect(capsule.hasTitle).to.equal(false);
            return done();
          })
          .catch(done);
      });

      it('should allow a capsule\'s to be updated, and hasTitle to be updated to true', function(done) {
        this.timeout(4000);
        var capsuleParams  = {
          contributable: 'private',
          description: 'Welcome...',
          location: 'Los Angeles, California',
          name: 'The Vixletverse',
          privacy: 'public',
          cover: untitleableCapsuleCover,
          hasTitle: false
        };
        return creator.capsule.create(capsuleParams)
          .then(function(capsule) {
            expect(capsule).to.be.an('object');
            expect(capsule.id).to.be.a('string');
            expect(capsule.name).to.equal(capsuleParams.name);
            expect(capsule.description).to.equal(capsuleParams.description);
            expect(capsule.hasTitle).to.equal(capsuleParams.hasTitle);
            return creator.capsule.update({ id: capsule.id, hasTitle: true});
          })
          .then(function(capsule) {
            expect(capsule).to.be.an('object');
            expect(capsule.id).to.be.a('string');
            expect(capsule.name).to.equal(capsuleParams.name);
            expect(capsule.description).to.equal(capsuleParams.description);
            //expect(capsule.hasTitle).to.equal(true);
            return done();
          })
          .catch(done);
      });
    });

    after(function (done) {
      var params = {
        awsAccessKeyId: environmentDefaults.aws.accessKeyId,
        awsSecretKey: environmentDefaults.aws.secretKey,
        awsRegion: environmentDefaults.aws.region,
        queueName: environmentDefaults.queue.user
      };
      var vixQue = new VixQue(params);
      var queueDeleteUser = function (userId) {
        vixQue.sendMessage({
          message: {
            task: 'deleteUser',
            data: {
              userId: userId,
              isHardDelete: true
            }
          }
        });
      };
      queueDeleteUser(creator.id);
      done();
    });
  });
});