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

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: '服务错误，请稍等'});
    }
  }

  // noinspection JSAnnotator
  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,
        sessionType: obj.sessionType
      };

      delete obj.sessionKey;
      delete obj.appVersion;
      delete obj.sessionType;

      // 计算用户剩余次数校验
      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 (value.chance) {
            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 = arr[index].maxValue;
          }
        });

        // 比较概率获取中奖奖品
        // 随机生成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 {
            // 查询有没有等于type1(谢谢惠顾)的商品 如果没有 返回概率最商品
            getPrize = null;
            for (let item of prize) {
              if (item.type === 1) {
                getPrize = item;
                break;
              }
            }
          }
        }
        if (getPrize.type === 1) {
          sendResult.code = 200;
          getPrize.desc = '对不起，您没有中奖';
        } else if (getPrize.type === 2) {
        // 调用java接口
          sendResult = await this.get({data: {
            method: 'app.redpac.addRedpac',
            actSource: 1001,
            uid: uid,
            redpacToken: getPrize.value}
          });
          if (sendResult && sendResult.code === 200) {
            getPrize.desc = '恭喜您获得' + sendResult.data.amount + '元红包';
          }
        } else if (getPrize.type === 3) {
          sendResult = await this.get({
            method: 'app.coupons.couponsSend',
            uid: uid,
            coupon_send_token: getPrize.value
          });
          if (sendResult && sendResult.code === 200) {
            getPrize.desc = '恭喜您获得' + getPrize.name + '优惠券';
          }
        } else if (getPrize.type === 4) {
          sendResult.code = 200;
          getPrize.desc = '恭喜您获得' + getPrize.name;
        }

        // 插入数据库
        if (sendResult.code !== 200) {
          getPrize = null;
          for (let item of prize) {
            if (item.type === 1) {
              getPrize = item;
              break;
            }
          }
          getPrize.desc = '对不起，您没有中奖';
        }
        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: '服务错误，请稍等'});
    }
  }

  async getUserPrize(obj) {
    try {
      return await ActWheelSurfUser.findAll({include: [{
        model: ActWheelSurfPrize,
        as: 'ActWheelSurfPrize',
      }, {
        model: ActWheelSurfConf,
        as: 'ActWheelSurfConf',
      }],
        where: obj
      });
    } catch (e) {
      return Promise.reject({code: 305, result: false, msg: '服务错误，请稍等'});
    }
  }
}

module.exports = ActWheelSurfModel;