import { Application, ChannelService, HandlerService, } from 'pinus';
import { ActivityModel, ActivityModelType } from '../../../db/Activity';
import { ServerlistModel } from '../../../db/Serverlist';
import { reloadResources } from '../../../pubUtils/data';
import { _getActivitiesByType, _getActivityById, _getActivities } from '../../../services/activity/activityService';

export default function (app: Application) {
    new HandlerService(app, {});
    return new ActivityRemote(app);
}

export class ActivityRemote {

    constructor(private app: Application) {
        this.app = app;
        this.channelService = app.get('channelService');
        this.loadActivities();
    }

    private channelService: ChannelService;
    private activityByServer: Map<number, number[]> = new Map();  // serverId => activityId[];
    private activities: Map<number, ActivityModelType> = new Map(); // activityId => activity
    private activityByType: Map<number, Map<number, number[]>> = new Map(); // serverId => type => activityId[];
    private groupToServer: Map<number, number[]> = new Map(); // group => serverId[];

    /**
     * 重载json资源
     */
    public async reloadResources() {
        reloadResources();
    }

    private async loadActivities() {
        let servers = await ServerlistModel.getAllServerList();
        for(let { serverId, activityGroupId } of servers) {
            for(let groupId of activityGroupId) {
                if(!this.groupToServer.has(groupId)) {
                    this.groupToServer.set(groupId, []);
                }
                this.groupToServer.get(groupId).push(serverId);
            }
        }

        let activities = await ActivityModel.findOpenAndComingActivityes();
        for(let activity of activities) {
            this.activities.set(activity.activityId, activity);
            let servers = this.groupToServer.get(activity.activityId)||[];
            for(let serverId of servers) {
                if(!this.activityByServer.has(serverId)) {
                    this.activityByServer.set(serverId, []);
                }
                this.activityByServer.get(serverId).push(activity.activityId);

                if(!this.activityByType.has(serverId)) {
                    this.activityByType.set(serverId, new Map());
                }
                if(!this.activityByType.get(serverId).has(activity.type)) {
                    this.activityByType.get(serverId).set(activity.type, []);
                }
                this.activityByType.get(serverId).get(activity.type).push(activity.activityId);
            }
        }

        this.app.set('activityByServer', this.activityByServer);
        this.app.set('activityByType', this.activityByType);
        this.app.set('activities', this.activities);
    }

    public async updateActivities(activities: ActivityModelType[]) {
        for(let activity of activities) {
            let { activityId, groupId, type } = activity;
            // 'activities'
            this.activities.set(activityId, activity);
            let serverIds = this.groupToServer.get(groupId)||[]; // 现在这个group对应的serverIds
            // 'activityByServer' & 'activityByType'
            // 将原来的都删掉，再塞入
            for(let [serverId, activityIds] of this.activityByServer) {
                let index = activityIds.indexOf(activityId);
                if(index != -1) this.activityByServer.get(serverId).splice(index);
            }
            for(let [serverId, typeToActivities] of this.activityByType) {
                for(let [type, activityIds] of typeToActivities) {
                    let index = activityIds.indexOf(activityId);
                    if(index != -1) this.activityByType.get(serverId).get(type).splice(index);
                }
            }
            // 塞入
            for(let serverId of serverIds) {
                if(!this.activityByServer.has(serverId)) {
                    this.activityByServer.set(serverId, []);
                }
                this.activityByServer.get(serverId).push(activityId);

                if(!this.activityByType.has(serverId)) {
                    this.activityByType.set(serverId, new Map());
                }
                if(!this.activityByType.get(serverId).has(type)) {
                    this.activityByType.get(serverId).set(type, []);
                }
                this.activityByType.get(serverId).get(type).push(activityId);
            }
            
        }
    }

    public async deleteActivities(activityIds: number[]) {
        for(let activityId of activityIds) {
            // 'activities'
            this.activities.delete(activityId);
            // 'activityByServer' & 'activityByType'
            // 将原来的都删掉
            for(let [serverId, activityIds] of this.activityByServer) {
                let index = activityIds.indexOf(activityId);
                if(index != -1) this.activityByServer.get(serverId).splice(index);
            }
            for(let [serverId, typeToActivities] of this.activityByType) {
                for(let [type, activityIds] of typeToActivities) {
                    let index = activityIds.indexOf(activityId);
                    if(index != -1) this.activityByType.get(serverId).get(type).splice(index);
                }
            }
        }
    }

    public getActivityById(activityId: number) {
        return _getActivityById(activityId);
    }

    public getActivitiesByType(serverId: number, type: number) {
        return _getActivitiesByType(serverId, type);
    }

    public getActivities() {
        return _getActivities();
    }
}