import { CardRoom, ExtRoomModel } from "./CardRoom";
import { RoomModel, GRoomSer } from "../../../Common/Service/RoomService";
import { CardServer } from "../CardServer";
import { CardTable } from "../Table/CardTable";
import { GConfigSer } from "../../../Common/Service/ConfigService";

export abstract class CardRoomManager
{
    protected _server:CardServer=null
    get server()
    {
        return this._server
    }
    //id cardroom
    protected _rooms=new Map<number,CardRoom>()
    get rooms()
    {
        return this._rooms
    }
    async getRoomInfos(club_id:number)
    {
        let roomInfos = {}
        for(let id in this._rooms)
        {
            let r:CardRoom = this._rooms[id]
            if(!club_id
                ||r.roomCfg.club_id==club_id)
            {
                roomInfos[id] = r.getRoomInfo()    
            }
        }
        for(let id in roomInfos)
        {
            roomInfos[id]=await roomInfos[id]
        }
        return roomInfos
    }
    async getAdminRoomInfos()
    {
        let ris=[]
        for(let id in this._rooms)
        {
            let r:CardRoom = this._rooms[id]
            ris.push(r.getAdminInfo())
        }
        for(let i=0;i<ris.length;++i)
        {
            ris[i]=await ris[i]
        }
        return ris
    }
    getAdminDetailPage(room_id:number,page:number,page_num:number)
    {
        let rstbs=[]
        room_id=room_id||-1
        if(room_id>0)
        {
            let room = this._rooms[room_id]
            if(room)
            {
                rstbs=room.getAdminDetailPage(page,page_num)||[]
            }
            return rstbs
        }
        page_num=page_num||20
        let tbs=new Array<CardTable>()
        let alltbs=this._server.tableMgr.tables
        for(let table_id in alltbs)
        {
            tbs.push(alltbs[table_id])
        }
        tbs.sort((a,b)=>
        {
            return a.create_time-b.create_time
        })
        
        for(let i=page*page_num;i<(page+1)*page_num&&i<tbs.length;++i)
        {
            rstbs.push(tbs[i].adminInfo)
        }
        return {tableInfos:rstbs,table_num:tbs.length}
    }
    getRoomById(room_id:number):CardRoom
    {
        if(!room_id)
        {
            return null
        }
        return this._rooms[room_id]
    }
    init(server:CardServer)
    {
        this._server = server
        this._init()
    }
    protected async _init()
    {
        let roomCfgs = await GRoomSer.gets(null,{game_name:this._server.name})
        for(let i=0;i<roomCfgs.length;++i)
        {
            let cfg:RoomModel = roomCfgs[i]
            let room = this.createRoom(cfg)
            this._rooms[cfg._id] = room
            console.log(this._server.name+" room(level="+cfg.level+"  id="+cfg._id+") init success!")
        }
        this.refreshRoomGameCfg()
    }
    /**
     * 刷新配置，后台动态修改了房间信息
     */
    async refreshRoomCfg(room_id:string)
    {
        if(!room_id)
        {
            return
        }
        let room_cfg = await GRoomSer.getById(room_id)
        if(!room_cfg)
        {
            let room:CardRoom = this._rooms[room_id]
            room.roomCfg.dismiss=true
            this._rooms[room_id]=null
            delete this._rooms[room_id]
        }
        else
        {
            let room:CardRoom = this._rooms[room_id]
            if(room)
            {
                room.init(this._server,<ExtRoomModel>room_cfg)
            }
            else
            {
                let room = this.createRoom(room_cfg)
                this._rooms[room_cfg.id] = room
                console.log(this._server.name+" room(level="+room_cfg.level+"  id="+room_cfg.id+") init success!")
            }
        }
    }
    /**
     * 需要被重载
     * 刷新配置，后台动态修改了默认的玩法配置
     */
    async refreshRoomGameCfg()
    {
        let cfg = await GConfigSer.get(null,{game_name:this._server.name})
        for(let room_id in this._rooms)
        {
            let room:CardRoom = this._rooms[room_id]
            room.cfgCtdm=cfg
            let tables=room.tables
            for(let i=0;i<tables.length;++i)
            {
                tables[i].needUpdateGameCfg=true
            }
        }
    }
    getRoomByLevel(level:number)
    {
        for(let room_id in this._rooms)
        {
            let r:CardRoom = this._rooms[room_id]
            if(r.roomCfg.level==level)
            {
                return r
            }
        }
        return null
    }
    async getRoomInfo(room_id:number)
    {
        let r:CardRoom = this._rooms[room_id]
        if(!r)
        {
            return null
        }
        let ri = await r.getRoomInfo()
        return ri
    }
    onTableDismiss(table_id)
    {
        for(let room_id in this._rooms)
        {
            let room:CardRoom = this._rooms[room_id]
            let ret = room.onTableDismiss(table_id)
            if(ret)
            {
                return true
            }
        }
        return false
    }
    abstract createRoom(cfg:RoomModel):CardRoom
}