// 周基金
import moment = require('moment');
import { SHOP_REFRESH_TYPE } from '../../consts';
import { ActivityModelType } from '../../db/Activity';
import { ActivityMonthlyFundModelType } from '../../db/ActivityMonthlyFund';
import { getZeroPointOfTimeD } from '../../pubUtils/timeUtil';
import { deltaDays } from '../../pubUtils/util';
import { ActivityBase } from './activityField';

interface MonthlyFundRewardInDb {
    dayIndex: number;   // 第几天
    reward: string;     // 每天签到的奖励 type&id&count
}

interface MonthlyFundPageInDb {
    pageIndex: number;
    name: string;
    productID: string;      // 商品id，商品表
    price: number;          // 购买价格
    onceReward: string;     // 购买后立刻可以获得的奖励 type&id&count
    rewards: MonthlyFundRewardInDb[]; // 每天签到可领取的奖励
    rebate: number;         // 显示用的返利倍数
    buyEndDay: number;      // 购买截止时间
}

interface MonthlyFundDataInDb {
    list: MonthlyFundPageInDb[];
}

class MonthlyFundReward {
    dayIndex: number;   // 第几天
    reward: string;     // 每天签到的奖励 type&id&count
    hasReceived: boolean = false;  // 是否领取过

    constructor(data: MonthlyFundRewardInDb) {
        this.dayIndex = data.dayIndex;
        this.reward = data.reward;
    }

    public setHasReceived() {
        this.hasReceived = true;
    }
}

class MonthlyFundPage {
    pageIndex: number;      // 第几页
    name: string;           // 基金
    productID: string;      // 商品id，商品表
    price: number;          // 购买价格
    onceReward: string;     // 购买后立刻可以获得的奖励 type&id&count
    rebate: number;          // 显示用的返利倍数
    showBeginTime: number = 0; // 显示的开始时间
    buyEndTime: number = 0;     // 购买截止时间
    rewards: MonthlyFundReward[] = []; // 每天签到可领取的奖励

    hasBought: boolean = false; // 是否购买了

    constructor(dataObj: MonthlyFundPageInDb, beginTime: number) {
        this.pageIndex = dataObj.pageIndex;
        this.name = dataObj.name;
        this.productID = dataObj.productID;
        this.price = dataObj.price;
        this.onceReward = dataObj.onceReward;
        this.rebate = dataObj.rebate;
        this.showBeginTime = beginTime;
        this.buyEndTime = beginTime + dataObj.buyEndDay * 86400000;
        for(let reward of (dataObj.rewards||[])) {
            this.rewards.push(new MonthlyFundReward(reward));
        }
    }

    public setPlayerRecord(playerData: ActivityMonthlyFundModelType) {
        if(!playerData) return;
        this.hasBought = true;
        for(let { dayIndex } of playerData.record) {
            let reward = this.rewards.find(cur => cur.dayIndex == dayIndex);
            if(reward || playerData.hasReceivedAll) reward.setHasReceived();
        }
    }

    public findSignReward(dayIndex: number) {
        return this.rewards.find(cur => cur.dayIndex == dayIndex);
    }

    public hasReceivedAll() {
        return !this.rewards.find(cur => !cur.hasReceived);
    }

    public canShow() {
        if(this.buyEndTime < Date.now() && !this.hasBought) return null;
        if(this.hasReceivedAll()) return null
        return this;
    }
}

export class MonthlyFundData extends ActivityBase {
    list: MonthlyFundPage[] = [];

    constructor(activityData: ActivityModelType, createTime: number, serverTime: number) {
        super(activityData, createTime, serverTime)
        this.initData(activityData.data)
    }

    public initData(data: string): void {
        let dataObj: MonthlyFundDataInDb = JSON.parse(data);
        if(!dataObj) return;
        let zeroPoint = getZeroPointOfTimeD(this.beginTime, SHOP_REFRESH_TYPE.MONTHLY);
        for(let data of (dataObj.list||[])) {
            let obj = new MonthlyFundPage(data, zeroPoint.getTime());
            if(obj) this.list.push(obj);
        }
        this.roundIndex = parseInt(moment(this.beginTime).format('YYYYMM'));
        this.todayIndex = deltaDays(zeroPoint, new Date) + 1;
    }

    public setPlayerRecords(playerDatas: ActivityMonthlyFundModelType[]) {
        for(let playerData of playerDatas) {
            let data = this.list.find(cur => cur.pageIndex == playerData.pageIndex);
            if(data) data.setPlayerRecord(playerData);
        }
    }

    public findPage(pageIndex: number) {
        return this.list.find(cur => cur.pageIndex == pageIndex);
    }

    public findByProductID(productID: string) {
        return this.list.find(cur => cur.productID == productID);
    }

    public getShowResult() {
        let canShow = false;
        for(let list of this.list) {
            if(list.canShow()) canShow = true;
        }
        if(!canShow) return null;

        return {
            ...this.getBaseKeys(),
            list: this.list
        }
    }
}