import moment from 'moment';
import _ from 'lodash';
import cloneDeep from 'lodash/cloneDeep';
import nconf from 'nconf';
import { model as User } from '../models/user';
import common from '../../common';
import { preenUserHistory } from './preening';
import sleep from './sleep';
import { revealMysteryItems } from './payments/subscriptions';

const CRON_SAFE_MODE = nconf.get('CRON_SAFE_MODE') === 'true';
const CRON_SEMI_SAFE_MODE = nconf.get('CRON_SEMI_SAFE_MODE') === 'true';
const { MAX_INCENTIVES } = common.constants;
const { shouldDo } = common;
const { scoreTask } = common.ops;
const { i18n } = common;
const { loginIncentives } = common.content;
// const maxPMs = 200;

function setIsDueNextDue (task, user, now) {
  const optionsForShouldDo = cloneDeep(user.preferences.toObject());
  task.isDue = common.shouldDo(now, task, optionsForShouldDo);
  optionsForShouldDo.nextDue = true;
  const nextDue = common.shouldDo(now, task, optionsForShouldDo);
  if (nextDue && nextDue.length > 0) {
    task.nextDue = nextDue;
  }
}

export async function recoverCron (status, locals) {
  const { user } = locals;

  await sleep(0.3);

  const reloadedUser = await User.findOne({ _id: user._id }).exec();

  if (!reloadedUser) {
    throw new Error(`User ${user._id} not found while recovering.`);
  } else if (reloadedUser._cronSignature !== 'NOT_RUNNING') {
    status.times += 1;

    if (status.times < 5) {
      await recoverCron(status, locals);
    } else {
      throw new Error(`Impossible to recover from cron for user ${user._id}.`);
    }
  } else {
    locals.user = reloadedUser;
  }
}

const CLEAR_BUFFS = {
  str: 0,
  int: 0,
  per: 0,
  con: 0,
  stealth: 0,
  streaks: false,
};

function grantEndOfTheMonthPerks (user, now) {
  // multi-month subscriptions are for multiples of 3 months
  const SUBSCRIPTION_BASIC_BLOCK_LENGTH = 3;
  const { plan } = user.purchased;
  const subscriptionEndDate = moment(plan.dateTerminated).isBefore() ? moment(plan.dateTerminated).startOf('month') : moment(now).startOf('month');
  const dateUpdatedMoment = moment(plan.dateUpdated).startOf('month');
  const elapsedMonths = moment(subscriptionEndDate).diff(dateUpdatedMoment, 'months');

  if (elapsedMonths > 0) {
    plan.dateUpdated = now;
    // For every month, inc their "consecutive months" counter.
    // Give perks based on consecutive blocks
    // If they already got perks for those blocks (eg, 6mo subscription,
    // subscription gifts, etc) - then dec the offset until it hits 0
    _.defaults(plan.consecutive, {
      count: 0, offset: 0, trinkets: 0, gemCapExtra: 0,
    });

    // Award mystery items
    revealMysteryItems(user, elapsedMonths);

    // 1 for one-month recurring or gift subscriptions; later set to 3 for 3-month recurring, etc.
    let planMonthsLength = 1;

    for (let i = 0; i < elapsedMonths; i += 1) {
      plan.consecutive.count += 1;

      plan.consecutive.offset -= 1;
      // If offset is now greater than 0, the user is within a period
      // for which they have already been given the consecutive months perks.
      //
      // If offset now equals 0, this is the final month for which
      // the user has already been given the consecutive month perks.
      // We do not give them more perks yet because they might cancel
      // the subscription before the next payment is taken.
      //
      // If offset is now less than 0, the user EITHER has
      // a single-month recurring subscription and MIGHT be due for perks,
      // OR has a multi-month subscription that renewed some time
      // in the previous calendar month and so they are due for a new set of perks
      // (strictly speaking, they should have been given the perks
      // at the time that next payment was taken, but we don't have support for
      // tracking payments like that - giving the perks when offset is < 0 is a workaround).

      if (plan.consecutive.offset < 0) {
        if (plan.planId) {
          // NB gift subscriptions don't have a planID
          // (which doesn't matter because we don't need to reapply perks
          // for them and by this point they should have expired anyway)
          const planIdRegExp = new RegExp('_([0-9]+)mo'); // e.g., matches 'google_6mo' / 'basic_12mo' and captures '6' / '12'
          const match = plan.planId.match(planIdRegExp);
          if (match !== null && match[0] !== null) {
            // 3 for 3-month recurring subscription, etc
            planMonthsLength = match[1]; // eslint-disable-line prefer-destructuring
          }
        }

        // every 3 months you get one set of perks - this variable records how many sets you need
        let perkAmountNeeded = 0;
        if (planMonthsLength === 1) {
          // User has a single-month recurring subscription and are due for perks
          // IF they've been subscribed for a multiple of 3 months.
          if (plan.consecutive.count % SUBSCRIPTION_BASIC_BLOCK_LENGTH === 0) { // every 3 months
            perkAmountNeeded = 1;
          }
          plan.consecutive.offset = 0; // allow the same logic to be run next month
        } else {
          // User has a multi-month recurring subscription
          // and it renewed in the previous calendar month.

          // e.g., for a 6-month subscription, give two sets of perks
          perkAmountNeeded = planMonthsLength / SUBSCRIPTION_BASIC_BLOCK_LENGTH;
          // don't need to check for perks again for this many months
          // (subtract 1 because we should have run this when the payment was taken last month)
          plan.consecutive.offset = planMonthsLength - 1;
        }
        if (perkAmountNeeded > 0) {
          plan.consecutive.trinkets += perkAmountNeeded; // one Hourglass every 3 months
          plan.consecutive.gemCapExtra += 5 * perkAmountNeeded; // 5 extra Gems every 3 months
          // cap it at 50 (hard 25 limit + extra 25)
          if (plan.consecutive.gemCapExtra > 25) plan.consecutive.gemCapExtra = 25;
        }
      }
    }
  }
}

function removeTerminatedSubscription (user) {
  const { plan } = user.purchased;

  _.merge(plan, {
    planId: null,
    customerId: null,
    paymentMethod: null,
  });

  _.merge(plan.consecutive, {
    count: 0,
    offset: 0,
    gemCapExtra: 0,
  });

  user.markModified('purchased.plan');
}

function resetHabitCounters (user, tasksByType, now, daysMissed) {
  // check if we've passed a day on which we should reset the habit counters, including today
  let resetWeekly = false;
  let resetMonthly = false;
  for (let i = 0; i < daysMissed; i += 1) {
    if (resetWeekly === true && resetMonthly === true) {
      break;
    }
    const thatDay = moment(now)
      .zone(user.preferences.timezoneOffset + user.preferences.dayStart * 60)
      .subtract({ days: i });
    if (thatDay.day() === 1) {
      resetWeekly = true;
    }
    if (thatDay.date() === 1) {
      resetMonthly = true;
    }
  }

  tasksByType.habits.forEach(task => {
    // reset counters if appropriate

    let reset = false;
    if (task.frequency === 'daily') {
      reset = true;
    } else if (task.frequency === 'weekly' && resetWeekly === true) {
      reset = true;
    } else if (task.frequency === 'monthly' && resetMonthly === true) {
      reset = true;
    }
    if (reset === true) {
      task.counterUp = 0;
      task.counterDown = 0;
    }
  });
}

function trackCronAnalytics (analytics, user, _progress, options) {
  analytics.track('Cron', {
    category: 'behavior',
    gaLabel: 'Cron Count',
    gaValue: user.flags.cronCount,
    uuid: user._id,
    user,
    resting: user.preferences.sleep,
    cronCount: user.flags.cronCount,
    progressUp: _.min([_progress.up, 900]),
    progressDown: _progress.down,
    headers: options.headers,
    loginIncentives: user.loginIncentives,
  });

  if (
    user.party && user.party.quest && !user.party.quest.RSVPNeeded
    && !user.party.quest.completed && user.party.quest.key && !user.preferences.sleep
  ) {
    analytics.track('quest participation', {
      category: 'behavior',
      uuid: user._id,
      user,
      questName: user.party.quest.key,
      headers: options.headers,
    });
  }
}

function awardLoginIncentives (user) {
  if (user.loginIncentives > MAX_INCENTIVES) return;

  //  Remove old notifications if they exists
  user.notifications.forEach((notif, index) => {
    if (notif && notif.type === 'LOGIN_INCENTIVE') user.notifications.splice(index, 1);
  });

  const notificationData = {};
  notificationData.message = i18n.t('checkinEarned', user.preferences.language);

  const loginIncentive = loginIncentives[user.loginIncentives];

  if (loginIncentive.rewardKey) {
    loginIncentive.assignReward(user);
    notificationData.reward = loginIncentive.reward;
    notificationData.rewardText = '';

    // @TODO: Abstract this logic and share it across the server and client
    let count = 0;
    for (const reward of loginIncentive.reward) {
      if (reward.text) {
        notificationData.rewardText += reward.text(user.preferences.language);
        if (reward.key === 'RoyalPurple') {
          notificationData.rewardText = i18n.t('potion', { potionType: notificationData.rewardText }, user.preferences.language);
        }
      } else if (loginIncentive.rewardKey[0] === 'background_blue') {
        notificationData.rewardText = i18n.t('incentiveBackgrounds', user.preferences.language);
      }

      if (loginIncentive.reward.length > 0 && count < loginIncentive.reward.length - 1) notificationData.rewardText += ', ';

      count += 1;
    }

    // Overwrite notificationData.rewardText if rewardName was explicitly declared
    if (loginIncentive.rewardName) {
      notificationData.rewardText = i18n.t(loginIncentive.rewardName, user.preferences.language);
    }

    notificationData.rewardKey = loginIncentive.rewardKey;
    notificationData.message = i18n.t('unlockedCheckInReward', user.preferences.language);
  }

  notificationData.nextRewardAt = loginIncentives[user.loginIncentives].nextRewardAt || 0;
  user.addNotification('LOGIN_INCENTIVE', notificationData);
}

// Perform various beginning-of-day reset actions.
export function cron (options = {}) {
  const {
    user, tasksByType, analytics, now = new Date(), daysMissed, timezoneOffsetFromUserPrefs,
  } = options;
  let _progress = { down: 0, up: 0, collectedItems: 0 };

  // Record pre-cron values of HP and MP to show notifications later
  const beforeCronStats = _.pick(user.stats, ['hp', 'mp']);

  user.preferences.timezoneOffsetAtLastCron = timezoneOffsetFromUserPrefs;
  // User is only allowed a certain number of drops a day. This resets the count.
  if (user.items.lastDrop.count > 0) user.items.lastDrop.count = 0;

  // "Perfect Day" achievement for perfect days
  let perfect = true;

  // Reset Gold-to-Gems cap if it's the start of the month
  const dateUpdatedFalse = !moment(user.purchased.plan.dateUpdated).startOf('month').isSame(moment().startOf('month')) || !user.purchased.plan.dateUpdated;

  if (user.purchased && user.purchased.plan && dateUpdatedFalse) {
    user.purchased.plan.gemsBought = 0;
    if (!user.purchased.plan.dateUpdated) user.purchased.plan.dateUpdated = moment();
  }

  if (user.isSubscribed()) {
    grantEndOfTheMonthPerks(user, now);
  }

  const { plan } = user.purchased;
  const userHasTerminatedSubscription = plan.dateTerminated
    && moment(plan.dateTerminated).isBefore(new Date());
  if (!CRON_SAFE_MODE && userHasTerminatedSubscription) removeTerminatedSubscription(user);

  // Login Incentives
  user.loginIncentives += 1;
  awardLoginIncentives(user);

  const multiDaysCountAsOneDay = true;
  // If the user does not log in for two or more days,
  // cron (mostly) acts as if it were only one day.
  // When site-wide difficulty settings are introduced, this can be a user preference option.

  // Tally each task
  let todoTally = 0;

  // make uncompleted To-Dos redder (further incentive to complete them)
  tasksByType.todos.forEach(task => {
    if (
      task.group.assignedDate
      && moment(task.group.assignedDate).isAfter(user.auth.timestamps.updated)
    ) return;
    scoreTask({
      task,
      user,
      direction: 'down',
      cron: true,
      times: multiDaysCountAsOneDay ? 1 : daysMissed,
    });

    todoTally += task.value;
  });

  // For incomplete Dailys, add value (further incentive),
  // deduct health, keep records for later decreasing the nightly mana gain.
  // The negative effects are not done when resting in the inn.
  let dailyChecked = 0; // how many dailies were checked?
  let dailyDueUnchecked = 0; // how many dailies were un-checked?
  let atLeastOneDailyDue = false; // were any dailies due?
  if (!user.party.quest.progress.down) user.party.quest.progress.down = 0;

  tasksByType.dailys.forEach(task => {
    if (
      task.group.assignedDate
      && moment(task.group.assignedDate).isAfter(user.auth.timestamps.updated)
    ) return;
    const { completed } = task;
    // Deduct points for missed Daily tasks
    let EvadeTask = 0;
    let scheduleMisses = daysMissed;

    if (completed) {
      dailyChecked += 1;
      if (!atLeastOneDailyDue) { // only bother checking until the first thing is found
        const thatDay = moment(now).subtract({ days: daysMissed });
        atLeastOneDailyDue = shouldDo(thatDay.toDate(), task, user.preferences);
      }
    } else {
      // dailys repeat, so need to calculate how many they've missed according to their own schedule
      scheduleMisses = 0;

      for (let i = 0; i < daysMissed; i += 1) {
        const thatDay = moment(now).subtract({ days: i + 1 });

        if (shouldDo(thatDay.toDate(), task, user.preferences)) {
          atLeastOneDailyDue = true;
          scheduleMisses += 1;
          if (user.stats.buffs.stealth) {
            user.stats.buffs.stealth -= 1;
            EvadeTask += 1;
          }
        }
        if (multiDaysCountAsOneDay) break;
      }

      if (scheduleMisses > EvadeTask) {
        // The user did not complete this due Daily
        // (but no penalty if cron is running in safe mode).
        if (CRON_SAFE_MODE) {
          dailyChecked += 1; // allows full allotment of mp to be gained
        } else {
          perfect = false;

          // Partially completed checklists dock fewer mana points
          if (task.checklist && task.checklist.length > 0) {
            const fractionChecked = _.reduce(
              task.checklist,
              (m, i) => m + (i.completed ? 1 : 0),
              0,
            ) / task.checklist.length;
            dailyDueUnchecked += 1 - fractionChecked;
            dailyChecked += fractionChecked;
          } else {
            dailyDueUnchecked += 1;
          }

          if (!user.preferences.sleep) {
            const delta = scoreTask({
              user,
              task,
              direction: 'down',
              times: multiDaysCountAsOneDay ? 1 : scheduleMisses - EvadeTask,
              cron: true,
            });

            if (!CRON_SEMI_SAFE_MODE) {
              // Apply damage from a boss, less damage for Trivial priority (difficulty)
              user.party.quest.progress.down += delta * (task.priority < 1 ? task.priority : 1);
              // NB: Medium and Hard priorities do not increase damage from boss.
              // This was by accident
              // initially, and when we realised, we could not fix it because users are used to
              // their Medium and Hard Dailies doing an Easy amount of damage from boss.
              // Easy is task.priority = 1. Anything < 1 will be Trivial (0.1) or any future
              // setting between Trivial and Easy.
            }
          }
        }
      }

      // add history entry when task was not completed
      task.history.push({
        date: Number(new Date()),
        value: task.value,
      });
    }

    task.completed = false;
    setIsDueNextDue(task, user, now);

    if (completed || scheduleMisses > 0) {
      if (task.checklist) {
        task.checklist.forEach(i => { i.completed = false; });
      }
    }

    if (task.group && task.group.approval && task.group.approval.approved) {
      task.group.approval.approved = false;
      task.group.approval.dateApproved = null;
      task.group.approval.requested = false;
      task.group.approval.requestedDate = null;
    }
  });

  resetHabitCounters(user, tasksByType, now, daysMissed);

  tasksByType.habits.forEach(task => {
    // slowly reset value to 0 for "onlies" (Habits with + or - but not both)
    // move singleton Habits towards yellow.
    if (task.up === false || task.down === false) {
      task.value = Math.abs(task.value) < 0.1 ? 0 : task.value /= 2;
    }
    if (task.group && task.group.approval && task.group.approval.approved) {
      task.group.approval.approved = false;
      task.group.approval.dateApproved = null;
      task.group.approval.requested = false;
      task.group.approval.requestedDate = null;
    }
  });

  // Finished tallying
  user.history.todos.push({ date: now, value: todoTally });

  // tally experience
  let expTally = user.stats.exp;
  let lvl = 0; // iterator
  while (lvl < user.stats.lvl - 1) {
    lvl += 1;
    expTally += common.tnl(lvl);
  }

  user.history.exp.push({ date: now, value: expTally });

  // Remove any remaining completed todos from the list of active todos
  user.tasksOrder.todos = user.tasksOrder.todos
    .filter(taskOrderId => _.some(
      tasksByType.todos,
      taskType => taskType._id === taskOrderId && taskType.completed === false,
    ));
  // TODO also adjust tasksOrder arrays to remove deleted tasks of any kind (including rewards), ensure that all existing tasks are in the arrays, no tasks IDs are duplicated -- https://github.com/HabitRPG/habitica/issues/7645

  // preen user history so that it doesn't become a performance problem
  // also for subscribed users but differently
  preenUserHistory(user, tasksByType);

  if (perfect && atLeastOneDailyDue) {
    user.achievements.perfect += 1;
    const lvlDiv2 = Math.ceil(common.capByLevel(user.stats.lvl) / 2);
    user.stats.buffs = {
      str: lvlDiv2,
      int: lvlDiv2,
      per: lvlDiv2,
      con: lvlDiv2,
      stealth: 0,
      streaks: false,
    };
  } else {
    user.stats.buffs = _.cloneDeep(CLEAR_BUFFS);
  }

  common.setDebuffPotionItems(user);

  // Add 10 MP, or 10% of max MP if that'd be more.
  // Perform this after Perfect Day for maximum benefit
  // Adjust for fraction of dailies completed
  if (!user.preferences.sleep) {
    if (dailyDueUnchecked === 0 && dailyChecked === 0) dailyChecked = 1;
    user.stats.mp += (_.max([10, 0.1 * common.statsComputed(user).maxMP]) * dailyChecked) / (dailyDueUnchecked + dailyChecked); // eslint-disable-line max-len
    if (user.stats.mp > common.statsComputed(user).maxMP) {
      user.stats.mp = common.statsComputed(user).maxMP;
    }
  }

  // After all is said and done,
  // progress up user's effect on quest, return those values & reset the user's
  if (!user.preferences.sleep) {
    const { progress } = user.party.quest;
    _progress = progress.toObject(); // clone the old progress object
    _.merge(progress, { down: 0, up: 0, collectedItems: 0 });
  }

  // Send notification for changes in HP and MP.
  // First remove a possible previous cron notification because
  // we don't want to flood the users with many cron notifications at once.
  const oldCronNotif = user.notifications.find((notif, index) => {
    if (notif && notif.type === 'CRON') {
      user.notifications.splice(index, 1);
      return true;
    }
    return false;
  });

  user.addNotification('CRON', {
    hp: user.stats.hp - beforeCronStats.hp - (oldCronNotif ? oldCronNotif.data.hp : 0),
    mp: user.stats.mp - beforeCronStats.mp - (oldCronNotif ? oldCronNotif.data.mp : 0),
  });

  // Analytics
  user.flags.cronCount += 1;
  trackCronAnalytics(analytics, user, _progress, options);

  return _progress;
}