import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
import { CounterModel } from './Counter';
import { COUNTER, ACTIVITY_TYPE } from '../consts';

/**
  * 活动合集
*/
@index({ activityId: 1 })

class ActivityType {
    @prop({ required: true })
    index: number;                  // 活动集合内部id，防止activityType有重复的情况
    
    @prop({ required: true, enum: ACTIVITY_TYPE })
    activityType: ACTIVITY_TYPE;     // 活动类型
}

export default class Activity_GroupType extends BaseModel {
    @prop({ required: true })
    groupType: number;				// 类型id，创建时自增

    @prop({ required: true })
    groupTypeName: string;          // 类型名

    @prop({ required: true, type: ActivityType, _id: false })
    activityTypes: ActivityType[];   // 活动类型集合

    public static async findByGroupType(groupType: number) {
        let result: ActivityGroupTypeInter = await ActivityGroupTypeModel.findOne({ groupType }).lean();
        return result;
    }

    public static async createActivityGroupType(groupTypeName: string, types: number[], uid = 1) {
        let activityTypes = types.map((value, index) => {
            return { index: index + 1, activityType: value };
        });
        let groupType = await CounterModel.getNewCounter(COUNTER.ACTIVITY_GROUP_TYPE);

        let result: ActivityGroupTypeInter = await ActivityGroupTypeModel.findOneAndUpdate({ groupType }, {
            $setOnInsert: { groupTypeName, activityTypes, createdBy: uid }, $set: { updatedBy: uid }
        }, { new: true, upsert: true }).lean();
        return result;
    }

    public static async updateActivityGroupType(groupType: number, groupTypeName: string, types: number[], uid = 1) {
        let activityTypes = types.map((value, index) => {
            return { index: index + 1, activityType: value };
        });

        let result: ActivityGroupTypeInter = await ActivityGroupTypeModel.findOneAndUpdate({ groupType }, {
            $set: { groupTypeName, activityTypes, updatedBy: uid }
        }, { new: true }).lean();
        return result;
    }

    public static async deleteActivityGroupType(groupType: number) {
        let result = await ActivityGroupTypeModel.deleteMany({ groupType });
        return result;
    }

    private static getSearchObj(form: { groupType?: number, groupTypeName?: string }) {
        let searchObj = {};
        if(form.groupType != undefined) searchObj['groupType'] = form.groupType;
        if(form.groupTypeName != undefined) searchObj['groupTypeName'] = form.groupTypeName;
        return searchObj;
    }

    //查询
    public static async findByCondition(page: number, pageSize: number, sortField: string, sortOrder: string, form: { groupType?: number, groupTypeName?: string } = {}) {
        let searchObj = this.getSearchObj(form);
        let sort = {};
        if(sortField && sortOrder) {
            if(sortOrder == 'ascend') {
                sort[sortField] = 1;
            } else if (sortOrder == 'descend') {
                sort[sortField] = -1;
            }
        }
        const result: ActivityGroupTypeInter[] = await ActivityGroupTypeModel.find(searchObj, { _id: 0 }).limit(pageSize).skip((page - 1) * pageSize).sort(sort).lean({ getters: true, virtuals: true });
        return result;
      }
    

    // 获得活动数量
    public static async countByCondition(form: { groupType?: number, groupTypeName?: string } = {}) {
        let searchObj = this.getSearchObj(form);
        const result = await ActivityGroupTypeModel.count(searchObj);
        return result;
    }

}

export const ActivityGroupTypeModel = getModelForClass(Activity_GroupType);

export interface ActivityGroupTypeInter extends Pick<DocumentType<Activity_GroupType>, keyof Activity_GroupType> {
  id: number;
};
export type ActivityGroupTypeUpdate = Partial<ActivityGroupTypeInter>; // 将所有字段变成可选项