var _, cron, expect, moment, newUser, repeatWithoutLastWeekday, shared, sinon;

_ = require('lodash');

expect = require('expect.js');

sinon = require('sinon');

moment = require('moment');

shared = require('../../common/script/index.js');

shared.i18n.translations = require('../../website/src/libs/i18n.js').translations;

repeatWithoutLastWeekday = function() {
  var repeat;
  repeat = {
    su: true,
    m: true,
    t: true,
    w: true,
    th: true,
    f: true,
    s: true
  };
  if (shared.startOfWeek(moment().zone(0)).isoWeekday() === 1) {
    repeat.su = false;
  } else {
    repeat.s = false;
  }
  return {
    repeat: repeat
  };
};


/* Helper Functions */

newUser = function(addTasks) {
  var buffs, user;
  if (addTasks == null) {
    addTasks = true;
  }
  buffs = {
    per: 0,
    int: 0,
    con: 0,
    str: 0,
    stealth: 0,
    streaks: false
  };
  user = {
    auth: {
      timestamps: {}
    },
    stats: {
      str: 1,
      con: 1,
      per: 1,
      int: 1,
      mp: 32,
      "class": 'warrior',
      buffs: buffs
    },
    items: {
      lastDrop: {
        count: 0
      },
      hatchingPotions: {},
      eggs: {},
      food: {},
      gear: {
        equipped: {},
        costume: {}
      }
    },
    party: {
      quest: {
        progress: {
          down: 0
        }
      }
    },
    preferences: {},
    dailys: [],
    todos: [],
    rewards: [],
    flags: {},
    achievements: {},
    contributor: {
      level: 2
    }
  };
  shared.wrap(user);
  user.ops.reset(null, function() {});
  if (addTasks) {
    _.each(['habit', 'todo', 'daily'], function(task) {
      return user.ops.addTask({
        body: {
          type: task,
          id: shared.uuid()
        }
      });
    });
  }
  return user;
};

cron = function(usr, missedDays) {
  if (missedDays == null) {
    missedDays = 1;
  }
  usr.lastCron = moment().subtract(missedDays, 'days');
  return usr.fns.cron();
};

describe('daily/weekly that repeats everyday (default)', function() {
  var daily, user, weekly;
  user = null;
  daily = null;
  weekly = null;
  describe('when startDate is in the future', function() {
    beforeEach(function() {
      user = newUser();
      user.dailys = [
        shared.taskDefaults({
          type: 'daily',
          startDate: moment().add(7, 'days'),
          frequency: 'daily'
        }), shared.taskDefaults({
          type: 'daily',
          startDate: moment().add(7, 'days'),
          frequency: 'weekly',
          repeat: {
            su: true,
            m: true,
            t: true,
            w: true,
            th: true,
            f: true,
            s: true
          }
        })
      ];
      daily = user.dailys[0];
      return weekly = user.dailys[1];
    });
    it('does not damage user for not completing it', function() {
      cron(user);
      return expect(user.stats.hp).to.be(50);
    });
    it('does not change value on cron if daily is incomplete', function() {
      cron(user);
      expect(daily.value).to.be(0);
      return expect(weekly.value).to.be(0);
    });
    it('does not reset checklists if daily is not marked as complete', function() {
      var checklist;
      checklist = [
        {
          'text': '1',
          'id': 'checklist-one',
          'completed': true
        }, {
          'text': '2',
          'id': 'checklist-two',
          'completed': true
        }, {
          'text': '3',
          'id': 'checklist-three',
          'completed': false
        }
      ];
      daily.checklist = checklist;
      weekly.checklist = checklist;
      cron(user);
      expect(daily.checklist[0].completed).to.be(true);
      expect(daily.checklist[1].completed).to.be(true);
      expect(daily.checklist[2].completed).to.be(false);
      expect(weekly.checklist[0].completed).to.be(true);
      expect(weekly.checklist[1].completed).to.be(true);
      return expect(weekly.checklist[2].completed).to.be(false);
    });
    it('resets checklists if daily is marked as complete', function() {
      var checklist;
      checklist = [
        {
          'text': '1',
          'id': 'checklist-one',
          'completed': true
        }, {
          'text': '2',
          'id': 'checklist-two',
          'completed': true
        }, {
          'text': '3',
          'id': 'checklist-three',
          'completed': false
        }
      ];
      daily.checklist = checklist;
      weekly.checklist = checklist;
      daily.completed = true;
      weekly.completed = true;
      cron(user);
      _.each(daily.checklist, function(box) {
        return expect(box.completed).to.be(false);
      });
      return _.each(weekly.checklist, function(box) {
        return expect(box.completed).to.be(false);
      });
    });
    return it('is due on startDate', function() {
      var daily_due_on_start_date, daily_due_today, weekly_due_on_start_date, weekly_due_today;
      daily_due_today = shared.shouldDo(moment(), daily);
      daily_due_on_start_date = shared.shouldDo(moment().add(7, 'days'), daily);
      expect(daily_due_today).to.be(false);
      expect(daily_due_on_start_date).to.be(true);
      weekly_due_today = shared.shouldDo(moment(), weekly);
      weekly_due_on_start_date = shared.shouldDo(moment().add(7, 'days'), weekly);
      expect(weekly_due_today).to.be(false);
      return expect(weekly_due_on_start_date).to.be(true);
    });
  });
  describe('when startDate is in the past', function() {
    beforeEach(function() {
      user = newUser();
      user.dailys = [
        shared.taskDefaults({
          type: 'daily',
          startDate: moment().subtract(7, 'days'),
          frequency: 'daily'
        }), shared.taskDefaults({
          type: 'daily',
          startDate: moment().subtract(7, 'days'),
          frequency: 'weekly'
        })
      ];
      daily = user.dailys[0];
      return weekly = user.dailys[1];
    });
    it('does damage user for not completing it', function() {
      cron(user);
      return expect(user.stats.hp).to.be.lessThan(50);
    });
    it('decreases value on cron if daily is incomplete', function() {
      cron(user, 1);
      expect(daily.value).to.be(-1);
      return expect(weekly.value).to.be(-1);
    });
    it('decreases value on cron once only if daily is incomplete and multiple days are missed', function() {
      cron(user, 7);
      expect(daily.value).to.be(-1);
      return expect(weekly.value).to.be(-1);
    });
    it('resets checklists if daily is not marked as complete', function() {
      var checklist;
      checklist = [
        {
          'text': '1',
          'id': 'checklist-one',
          'completed': true
        }, {
          'text': '2',
          'id': 'checklist-two',
          'completed': true
        }, {
          'text': '3',
          'id': 'checklist-three',
          'completed': false
        }
      ];
      daily.checklist = checklist;
      weekly.checklist = checklist;
      cron(user);
      _.each(daily.checklist, function(box) {
        return expect(box.completed).to.be(false);
      });
      return _.each(weekly.checklist, function(box) {
        return expect(box.completed).to.be(false);
      });
    });
    return it('resets checklists if daily is marked as complete', function() {
      var checklist;
      checklist = [
        {
          'text': '1',
          'id': 'checklist-one',
          'completed': true
        }, {
          'text': '2',
          'id': 'checklist-two',
          'completed': true
        }, {
          'text': '3',
          'id': 'checklist-three',
          'completed': false
        }
      ];
      daily.checklist = checklist;
      daily.completed = true;
      weekly.checklist = checklist;
      weekly.completed = true;
      cron(user);
      _.each(daily.checklist, function(box) {
        return expect(box.completed).to.be(false);
      });
      return _.each(weekly.checklist, function(box) {
        return expect(box.completed).to.be(false);
      });
    });
  });
  return describe('when startDate is today', function() {
    beforeEach(function() {
      user = newUser();
      user.dailys = [
        shared.taskDefaults({
          type: 'daily',
          startDate: moment().subtract(1, 'days'),
          frequency: 'daily'
        }), shared.taskDefaults({
          type: 'daily',
          startDate: moment().subtract(1, 'days'),
          frequency: 'weekly'
        })
      ];
      daily = user.dailys[0];
      return weekly = user.dailys[1];
    });
    it('does damage user for not completing it', function() {
      cron(user);
      return expect(user.stats.hp).to.be.lessThan(50);
    });
    it('decreases value on cron if daily is incomplete', function() {
      cron(user);
      expect(daily.value).to.be.lessThan(0);
      return expect(weekly.value).to.be.lessThan(0);
    });
    it('resets checklists if daily is not marked as complete', function() {
      var checklist;
      checklist = [
        {
          'text': '1',
          'id': 'checklist-one',
          'completed': true
        }, {
          'text': '2',
          'id': 'checklist-two',
          'completed': true
        }, {
          'text': '3',
          'id': 'checklist-three',
          'completed': false
        }
      ];
      daily.checklist = checklist;
      weekly.checklist = checklist;
      cron(user);
      _.each(daily.checklist, function(box) {
        return expect(box.completed).to.be(false);
      });
      return _.each(weekly.checklist, function(box) {
        return expect(box.completed).to.be(false);
      });
    });
    return it('resets checklists if daily is marked as complete', function() {
      var checklist;
      checklist = [
        {
          'text': '1',
          'id': 'checklist-one',
          'completed': true
        }, {
          'text': '2',
          'id': 'checklist-two',
          'completed': true
        }, {
          'text': '3',
          'id': 'checklist-three',
          'completed': false
        }
      ];
      daily.checklist = checklist;
      daily.completed = true;
      weekly.checklist = checklist;
      weekly.completed = true;
      cron(user);
      _.each(daily.checklist, function(box) {
        return expect(box.completed).to.be(false);
      });
      return _.each(weekly.checklist, function(box) {
        return expect(box.completed).to.be(false);
      });
    });
  });
});

describe('daily that repeats every x days', function() {
  var daily, user;
  user = null;
  daily = null;
  beforeEach(function() {
    user = newUser();
    user.dailys = [
      shared.taskDefaults({
        type: 'daily',
        startDate: moment(),
        frequency: 'daily'
      })
    ];
    return daily = user.dailys[0];
  });
  return _.times(11, function(due) {
    return it('where x equals ' + due, function() {
      daily.everyX = due;
      return _.times(30, function(day) {
        var isDue;
        isDue = shared.shouldDo(moment().add(day, 'days'), daily);
        if (day % due === 0) {
          expect(isDue).to.be(true);
        }
        if (day % due !== 0) {
          return expect(isDue).to.be(false);
        }
      });
    });
  });
});

describe('daily that repeats every X days when multiple days are missed', function() {
  var daily, everyX, startDateDaysAgo, user;
  everyX = 3;
  startDateDaysAgo = everyX * 3;
  user = null;
  daily = null;
  describe('including missing a due date', function() {
    var missedDays;
    missedDays = everyX * 2 + 1;
    beforeEach(function() {
      user = newUser();
      user.dailys = [
        shared.taskDefaults({
          type: 'daily',
          startDate: moment().subtract(startDateDaysAgo, 'days'),
          frequency: 'daily',
          everyX: everyX
        })
      ];
      return daily = user.dailys[0];
    });
    it('decreases value on cron once only if daily is incomplete', function() {
      cron(user, missedDays);
      return expect(daily.value).to.be(-1);
    });
    it('resets checklists if daily is incomplete', function() {
      var checklist;
      checklist = [
        {
          'text': '1',
          'id': 'checklist-one',
          'completed': true
        }
      ];
      daily.checklist = checklist;
      cron(user, missedDays);
      return _.each(daily.checklist, function(box) {
        return expect(box.completed).to.be(false);
      });
    });
    return it('resets checklists if daily is marked as complete', function() {
      var checklist;
      checklist = [
        {
          'text': '1',
          'id': 'checklist-one',
          'completed': true
        }
      ];
      daily.checklist = checklist;
      daily.completed = true;
      cron(user, missedDays);
      return _.each(daily.checklist, function(box) {
        return expect(box.completed).to.be(false);
      });
    });
  });
  return describe('but not missing a due date', function() {
    var missedDays;
    missedDays = everyX - 1;
    beforeEach(function() {
      user = newUser();
      user.dailys = [
        shared.taskDefaults({
          type: 'daily',
          startDate: moment().subtract(startDateDaysAgo, 'days'),
          frequency: 'daily',
          everyX: everyX
        })
      ];
      return daily = user.dailys[0];
    });
    it('does not decrease value on cron', function() {
      cron(user, missedDays);
      return expect(daily.value).to.be(0);
    });
    it('does not reset checklists if daily is incomplete', function() {
      var checklist;
      checklist = [
        {
          'text': '1',
          'id': 'checklist-one',
          'completed': true
        }
      ];
      daily.checklist = checklist;
      cron(user, missedDays);
      return _.each(daily.checklist, function(box) {
        return expect(box.completed).to.be(true);
      });
    });
    return it('resets checklists if daily is marked as complete', function() {
      var checklist;
      checklist = [
        {
          'text': '1',
          'id': 'checklist-one',
          'completed': true
        }
      ];
      daily.checklist = checklist;
      daily.completed = true;
      cron(user, missedDays);
      return _.each(daily.checklist, function(box) {
        return expect(box.completed).to.be(false);
      });
    });
  });
});