/* eslint-disable array-callback-return */
const {ActWheelSurfConf, ActWheelSurfPrize, ActWheelSurfUser, Activity} = require('../../../db');
const md5 = require('yoho-md5');
const _ = require('lodash');

class ActWheelSurfModel extends global.yoho.BaseModel {
  constructor(ctx) {
    super(ctx);
    this.cache = global.yoho.cache;
  }

  async getNowConf(obj) {
    try {
      let data = await this.cache.get(md5('act' + obj.act_id));

      // 获取当前活动基础信息，从redis里面取prize和conf，如果没有则查表再放入redis
      if (data) {
        data = JSON.parse(data);
      } else {
        data = {};

        // 从redis取，如果没有则去数据查询，然后再到放到redis
        // 获取活动基础
        data.conf = await ActWheelSurfConf.findOne({where: {act_id: obj.act_id}});

        // 获取当前活动奖品
        data.prize = await ActWheelSurfPrize.count({where: {act_id: obj.act_id}});
        this.cache.set(md5('act' + obj.act_id), data);
      }

      // 获取当去用户剩余次数
      let residueCount;

      // 判断用户是否登录 如果没登录就取当前活动最大次数
      if (obj.uid) {
        // 每日最大次数
        if (!data.conf.times_type) {
          // 获取当天0点和23：59：59
          let endTime = new Date(new Date(new Date().toLocaleDateString()).getTime() + 24 * 60 * 60 * 1000 - 1);
          let startTime = new Date(new Date(new Date().toLocaleDateString()).getTime());

          obj.create_time = {gt: startTime, lte: endTime};
          residueCount = data.conf.day_limit_times - await ActWheelSurfUser.count({
            where: obj
          });
        } else {
          // 活动最大次数
          residueCount = data.conf.act_total_times - await ActWheelSurfUser.count({where: obj});
        }
      } else {
        residueCount = data.conf.times_type ? data.conf.act_total_times : data.conf.day_limit_times;
      }
      data.residueCount = residueCount;
      return Promise.resolve(data);
    } catch (e) {
      return Promise.reject({code: 305, result: false, msg: '服务错误，请稍等'});
    }
  }

  async goPrize(obj) {
    try {
      // 校验有效活动时间
      let act = await Activity.findOne({where: {id: obj.act_id}});
      let nowDate = new Date();

      nowDate = parseInt(nowDate.getTime() / 1000);
      if (act.startTime > nowDate) {
        return Promise.reject({code: 301, result: false, msg: '活动未开始'});
      }
      if (act.endTime < nowDate) {
        return Promise.reject({code: 302, result: false, msg: '活动已过期'});
      }

      // 获取活动信息
      let conf = await ActWheelSurfConf.findOne({where: {act_id: obj.act_id}});
      let residueCount;
      let uid = {
        toString: () => {
          return _.parseInt(obj.uid);
        },
        sessionKey: obj.sessionKey,
        appVersion: obj.appVersion,
        appSessionType: obj.appSessionType
      };

      delete obj.sessionKey;
      delete obj.appVersion;
      delete obj.appSessionType;

      // 计算用户剩余次数校验
      if (!conf.times_type) {
                // 获取当天0点和23：59：59
        let endTime = new Date(new Date(new Date().toLocaleDateString()).getTime() + 24 * 60 * 60 * 1000 - 1);
        let startTime = new Date(new Date(new Date().toLocaleDateString()).getTime());

        obj.create_time = {gt: startTime, lte: endTime};
        residueCount = conf.day_limit_times - await ActWheelSurfUser.count({
          where: obj
        });
      } else {
        // 活动最大次数
        residueCount = conf.act_total_times - await ActWheelSurfUser.count({where: obj});
      }

      if (residueCount > 0) {
        // 获取抽取到奖品
        // 获取奖品信息
        let prize = await ActWheelSurfPrize.findAll({where: {act_id: obj.act_id}});

        // 获取每个奖品获取它们的中奖范围
        let arr = {}, oldValue;

        prize.map(function(value, index) {
          if (typeof(oldValue) === 'undefined') {
            arr[index] = {maxValue: value.chance, leastValue: 0};
          } else {
            let maxValue = value.chance + oldValue;
            let leastValue = oldValue;

            arr[index] = {maxValue, leastValue};
          }
          oldValue = value.chance;
        });

        // 比较概率获取中奖奖品
        // 随机生成0-100的随机数
        let random = Math.random() * 100;

        // 判定随机数在奖品池子取件 选定中奖奖品
        let getPrize, sendResult, result;

        for (let i in arr) {
          if (arr[i].maxValue > random && arr[i].leastValue <= random) {
            getPrize = prize[i];
            break;
          }
        }
        if (getPrize.type !== 1) {
        // 校验剩余库存
          if (getPrize.total_left > 0) {
              // 减库存
            await getPrize.decrement('total_left');
          } else {
            return Promise.reject({code: 303, result: false, msg: '获取失败，商品库存不足'});
          }
        }

        if (getPrize.type === 2) {
        // 调用java接口
          sendResult = await this.get({data: {
            method: 'app.redpac.addRedpac',
            actSource: 1001,
            uid: uid,
            redpacToken: getPrize.value}
          });
        } else if (getPrize.type === 3) {
          return Promise.reject({code: 306, result: false, msg: '优惠券接口还未开放'});
        }

        // 插入数据库
        if (sendResult.code === 200) {
          result = await ActWheelSurfUser.create({act_id: obj.act_id, uid: obj.uid, prize_id: getPrize.id});
        }
        if (result) {
          delete getPrize.chance;
          delete getPrize.create_time;
          delete getPrize.total;
          delete getPrize.total_left;
          delete getPrize.value;
          return Promise.resolve(getPrize);
        } else {
          return Promise.reject({code: 305, result: false, msg: '服务错误，请稍等'});
        }
      } else {
        return Promise.reject({code: 304, result: false, msg: '用户使用次数不足'});
      }
    } catch (e) {
      return Promise.reject({code: 305, result: false, msg: '服务错误，请稍等'});
    }
  }

}

module.exports = ActWheelSurfModel;