import { GCacheTool, GLog, MongoBaseService } from "cgserver";
import { MongoBaseModel } from "cgserver";
import _ from "underscore";
import { PlayerInfo } from "../../GameCard/Logic/Table/CardSeat";
import { GSubRedisSer } from "../../Platform/HallWebServer/SubRedisServer";
import { EErrorCode } from "../Config/_error_";
import { ns_common } from "../Config/_ini_";
import { ExtUserModel, GExtUserSer, UserMatchInfo } from "./ExtUserService";
import { GMatchSer, MatchModel } from "./MatchService";
import { GMonitorSer, MonitorModel } from "./MonitorService";

export class MatchPlayer extends PlayerInfo
{
    reenter_time=0
    table_id=-1
    rank=-1
    constructor(user:ExtUserModel)
    {
        super(user,0)
    }
}
export enum EMatchState
{
    Waiting,
    Playing,
    Cancel,
    End
}
export class MatchInsModel extends MongoBaseModel
{
    //instance_id match_id+"_"+time
    id=""
    match_id=0
    /**
     * 这个是用来记录的，开赛的时候在赋值，
     */
    match:MatchModel=null
    start_time=0
    end_time=0
    players:{[user_id:number]:MatchPlayer}={}
    player_num=0
    blind_index=-1//当前的盲注级别
    state=EMatchState.Waiting
}
export class CreateMatchInsInfo
{
    id=""
    start_time=0
    match_id=0
}
export class MatchInsService extends MongoBaseService<MatchInsModel>
{
    protected _noplayers=<any>{}
    constructor()
    {
        super("match_ins",MatchInsModel)
        let mim = new MatchInsModel()
        for(let key in mim)
        {
            this._noplayers[key]=1
        }
        delete this._noplayers["players"]
        setInterval(()=>
        {
            this.getAllWithState(true)
        },5*1000)
    }
    async getAllWithState(force=false)
    {
        let time = Date.now()
        let key = "cache_matchins_all"
        let all:MatchInsModel[]=GCacheTool.get(key)
        if(all&&!force)
        {
            return all
        }
        all = await this.gets(null,{"$or":[{state:EMatchState.Playing},{start_time:{"$gt":Date.now()}}]})||[]
        let mms:MonitorModel[] = await GMonitorSer.gets({id:1,player_left_num:1})||[]
        for(let i=0;i<mms.length;++i)
        {
            for(let k=0;k<all.length;++k)
            {
                if(all[k].id==mms[i].id)
                {
                    all[k]["player_left_num"]=mms[i].player_left_num
                }
            }
        }
        GCacheTool.add(key,all,10*1000)
        let dttime = Date.now()-time
        return all
    }
    async getById(ins_id:string)
    {
        let mim:MatchInsModel=null
        let all = await this.getAllWithState()
        let index = all.findIndex((item)=>
        {
            return item.id==ins_id
        })
        if(index>=0)
        {
            mim=all[index]
        }
        else
        {
            mim = await super.getById(ins_id)
        }
        return mim
    }
    async onSignup(user:ExtUserModel,ins_id:string)
    {
        let rs={errcode:null,player:<MatchPlayer>null,umi:<UserMatchInfo>null}
        let player_key = `players.${user.id}`
        this._noplayers[player_key]=1
        let pre_time=0
        let mim:MatchInsModel = await this.get(this._noplayers,{id:ins_id,"$or":[{state:EMatchState.Waiting},{state:EMatchState.Playing}]})
        pre_time=Date.now()
        delete this._noplayers[player_key]
        if(!mim)
        {
            //终局无法报名
            rs.errcode=EErrorCode.Cannot_Singup_ForLastTable
            return rs
        }
        if(mim.state==EMatchState.Cancel)
        {
            rs.errcode=EErrorCode.No_Match_Ins
            return rs
        }
        mim.match=mim.match||await GMatchSer.getById(mim.match_id)
        //终局
        if(mim.state==EMatchState.Playing&&mim.player_num<=9)
        {
            return rs
        }
        pre_time=Date.now()
        mim.players=mim.players||{}
        let mp:MatchPlayer=mim.players[user.id]
        let exist=false
        if(mp)
        {
            exist=true
        }
        let time = Date.now()
        //还没开始随便报名
        if(time<mim.start_time)
        {
            if(mp)
            {
                rs.errcode=EErrorCode.Repeat_Singup
                return rs
            }
        }
        //游戏已经开始
        else
        {
            if(mp)
            {
                if(mp.point>0)
                {
                    rs.errcode=EErrorCode.Repeat_Singup
                    return rs
                }
                else if(mp.reenter_time>=mim.match.reenter_count)
                {
                    rs.errcode=EErrorCode.Cannot_Singup
                    return rs
                }
            }
        }
        if(!mp)
        {
            if(mim.player_num>=mim.match.max_user)
            {
                rs.errcode=EErrorCode.Cannot_Singup_ForMaxUser
                return rs
            }
            mp=new MatchPlayer(user)
        }
        //初始金币
        mp.point=mim.match.coin
        if(time>mim.start_time)
        {
            mp.reenter_time+=1
        }
        let sign_rs = await GExtUserSer.onSignUp(user.id,ins_id,mim.match)
        pre_time=Date.now()
        if(sign_rs.errcode)
        {
            rs.errcode=sign_rs.errcode
            return rs
        }
        rs.umi=sign_rs.umi
        if(!exist)
        {
            let model = {
                "$set":{},
                "$inc":{player_num:1}
            }
            model["$set"][player_key]=mp
            let mongo_rs = await this.updateOne(model,{_id:mim._id})
            pre_time=Date.now()
            if(mongo_rs.errcode)
            {
                rs.errcode=mongo_rs.errcode
                return rs
            }
        }
        else
        {
            await this.updateOne({"$set":{"$inc":{"players.reenter_time":1}}},{_id:mim._id,"players.user_id":user.id})
            pre_time=Date.now()
        }
        //比赛如果已经开启就通知到那边去一下
        if(ns_common.GIsTest||time>=mim.start_time)
        {
            await GSubRedisSer.publish({
                cmd:"matchsignup",
                ins_id:mim.id,
                user_id:user.id
            })
            pre_time=Date.now()
        }
        mim = await this.getById(ins_id)
        if(mim)
        {
            mim.players[mp.id]=mp
            mim.player_num+=1
        }
        rs.player=mp
        return rs
    }
    /**
     * 获取或者创建
     * @param cmii 
     * @returns 
     */
    async getCreateIns(cmii:CreateMatchInsInfo)
    {
        let matchInsM:MatchInsModel = await this.getById(cmii.id)
        if(matchInsM)
        {
            return matchInsM
        }
        let matchM = await GMatchSer.getById(cmii.match_id)
        if(!matchM)
        {
            return null
        }
        matchInsM=new MatchInsModel()
        matchInsM.id=cmii.id
        matchInsM.match_id=cmii.match_id
        matchInsM.start_time=cmii.start_time
        matchInsM.players={}
        matchInsM.blind_index=0
        let rs = await this.insert(matchInsM)
        if(rs.errcode)
        {
            return null
        }
        matchInsM._id=rs.rs.insertedId
        return matchInsM
    }
    async getPlayerInfo(ins_id:string,user_id:number)
    {
        let model = {}
        model[`players.${user_id}`]=1
        let one:MatchInsModel = await this.get(model,{id:ins_id})
        if(!one||!one.players)
        {
            return null
        }
        return one.players[user_id]
    }
    async onCancel(ins_id:string)
    {
        await this.updateOne({state:EMatchState.Cancel},{id:ins_id})
        return
    }
}
export let GMatchInsSer=new MatchInsService()