import { CardServer } from '../CardServer';
import { GFCfg } from 'cgserver';
import { CardTable, CardCreateTableDataModel } from './CardTable';
import { EErrorCode } from "../../Config/_error_";
import { ns_card } from '../../Config/_ini_';
import { ExtUserModel, GExtUserSer } from '../../../Common/Service/ExtUserService';
import { GClubSer as GClubSer } from '../../../Common/Service/ClubService';
import { GTableSer, TableModel } from '../../../Common/Service/TableService';
import { GUserCreateTableSer } from '../../../Common/Service/UserCreateTableService';

export class TableManager
{
    protected _tables=new Map<number,CardTable>()//保存所有的桌子
    get tables()
    {
        return this._tables
    }
    protected _table_cls=null
    protected _server:CardServer=null
    constructor(table_cls,server:CardServer)
    {
        this._table_cls = table_cls
        this._server = server
    }
    createMatchTable(ctdm:CardCreateTableDataModel)
    {
        //为积分场等没有创建者的，构造一个，免得出bug
        let creator = new ExtUserModel()
        creator.id=-1
        creator.account_id=-1
        creator.nickname="System"
        creator.sex=1
        creator.logo="1"
        creator.coin=99999
        creator.crystal = 99999
        creator.bank_pwd="999999"
        creator.bank_coin=999999

        ctdm.table_type = ns_card.ETableType.Match
        ctdm.need_end_record = true
        ctdm.total_num=999999
        ctdm.fee_type = ns_card.EFeeType.Free
        ctdm.auto_sitdown=true
        ctdm.auto_prepare=true
        ctdm.auto_start=false
        ctdm.need_end_record=false
        return this.createTable(ctdm,creator)
    }
    createScoreTable(ctdm:CardCreateTableDataModel)
    {
        //为积分场等没有创建者的，构造一个，免得出bug
        let creator = new ExtUserModel()
        creator.id=-1
        creator.account_id=-1
        creator.nickname="System"
        creator.sex=1
        creator.logo="1"
        creator.coin=99999
        creator.crystal = 99999
        creator.bank_pwd="999999"
        creator.bank_coin=999999

        ctdm.table_type = ns_card.ETableType.Score
        ctdm.need_end_record = false
        ctdm.total_num=999999
        ctdm.fee_type = ns_card.EFeeType.Free
        ctdm.auto_start=true
        return this.createTable(ctdm,creator)
    }
    async createFriendTable(ctdm:CardCreateTableDataModel,create_user_id:number)
    {
        ctdm.table_type = ns_card.ETableType.Friend
        let rs={table:<CardTable>null,errcode:null}
        let creator:ExtUserModel = null
        creator = await GExtUserSer.getById(create_user_id)
        if(!creator)
        {
            return rs
        }
        if(ctdm.fee_type==ns_card.EFeeType.Creator)
        {
            let table_crystal = this._server.cfg.All[ctdm.total_num]
            if(!table_crystal)
            {
                rs.errcode = EErrorCode.Wrong_Param
                return rs
            }
            if(creator.crystal<table_crystal)
            {
                rs.errcode = EErrorCode.Not_Enough_Crystal
                return rs
            }
            //该处不扣除，只检测，一局结束后再扣除
        }
        return this.createTable(ctdm,creator)
    }
    async createClubFriendTable(ctdm:CardCreateTableDataModel,create_user_id:number,club_id:number)
    {
        ctdm.table_type = ns_card.ETableType.ClubFriend
        let rs={table:<CardTable>null,errcode:null}
        let club = await GClubSer.get(club_id)
        if(!club)
        {
            rs.errcode = EErrorCode.No_Club_By_Id
            return rs
        }
        if(!club.allow_anyone_create)
        {
            let is_admin=false
            for(let i=0;i<club["admin_user_ids"].length;++i)
            {
                if(club["admin_user_ids"][i]==create_user_id)
                {
                    is_admin = true
                    break
                }
            }
            if(!is_admin)
            {
                rs.errcode = EErrorCode.Only_Admin_Can_Create
                return rs
            }
        }
        else if(!GClubSer.isInClub(create_user_id,club_id))
        { 
            rs.errcode = EErrorCode.Not_In_Club
            return rs
        }
        let creator = await GExtUserSer.getById(create_user_id)
        if(ctdm.fee_type==ns_card.EFeeType.Club)
        {
            if(club.club_for_create_fee!=1)
            {
                rs.errcode = EErrorCode.Club_Unsported_Fund
                return rs
            }
            let table_crystal = this._server.cfg.All[ctdm.total_num]
            
            // if(ctdm.game_type==ns_card.EGameType.BRMP)
            // {
            //     table_crystal = this._server.cfg.All_BR[cftdm.total_num]
            // }

            if(!table_crystal)
            {
                rs.errcode = EErrorCode.Wrong_Param
                return rs
            }
            if(club.crystal<table_crystal)
            {
                rs.errcode = EErrorCode.Not_Enough_Crystal
                return rs
            }
            //该处不扣除，只检测，一局结束后再扣除
        }
        else if(ctdm.fee_type==ns_card.EFeeType.Creator)
        {
            let table_crystal = this._server.cfg.All[ctdm.total_num]
            // if(ctdm.game_type==ns_card.EGameType.BRMP)
            // {
            //     table_crystal = this._server.cfg.All_BR[ctdm.total_num]
            // }
            if(!table_crystal)
            {
                rs.errcode = EErrorCode.Wrong_Param
                return rs
            }
            if(creator.crystal<table_crystal)
            {
                rs.errcode = EErrorCode.Not_Enough_Crystal
                return rs
            }
            //该处不扣除，只检测，一局结束后再扣除
        }
        return this.createTable(ctdm,creator)
    }
    async createTable(ctdm:CardCreateTableDataModel,creator:ExtUserModel)
    {
        let rs={table:<CardTable>null,errcode:null}
        let table_id = await GTableSer.getNewTableId()
        let table = <CardTable>(new this._table_cls(table_id,this._server))
        table.creator = creator
        let errcode = table.init(ctdm)
        if(errcode)
        {
            rs.errcode = errcode
            return rs
        }
        this._addTable(table,creator)
        rs.table = table
        GUserCreateTableSer.add(table.creator.id,table.id)
        return rs
    }
    protected _addTable(table:CardTable,create_user)
    {
        this._tables[table.id] = table
        let tm = new TableModel()
        tm.table_id = table.id
        tm.process = 0
        tm.create_data = JSON.stringify(table.ctdm)
        if(create_user)
        {
            let user = 
            {
                id:create_user.id,
                nickname:create_user.nickname,
                logo:create_user.logo,
            }
            tm.create_user_data = JSON.stringify(user)
        }
        tm.server_name = table.server.name
        tm.game_code = table.server.code
        tm.game_host = GFCfg.internet_host
        tm.game_port = table.server.cfg.port
        GTableSer.insert(tm)
    }
    getTableByTableId(table_id:number):CardTable
    {
        if(!table_id)
        {
            return null
        }
        return this._tables[table_id]
    }
    getTableByUserId(user_id:number):CardTable
    {
        let seat = this._server.seatMgr.getSeatByUserId(user_id)
        if(!seat)
        {
            return null
        }
        return seat.table
    }
    /**
     * 介意只让table调用
     * @param table_id 
     */
    onDismissTable(table_id:number)
    {
        GTableSer.deleteOne({table_id:table_id})
        let table:CardTable = this._tables[table_id]
        if(!table)
        {
            return
        }
        if(table.server.roomMgr)
        {
            table.server.roomMgr.onTableDismiss(table_id)
        }
        this._tables[table_id].onDestory()
        this._tables[table_id] = null
        delete this._tables[table_id]
    }
    /**
     * 建议只让table调用,table的redis信息不会立刻清除
     * @param table_id 
     * @param record_id? 
     */
    onWeaklyDismissTable(table_id,record_id?)
    {
        //十分钟后删除，，先就占用
        GTableSer.endAutoRemove(table_id,10*60,record_id)
        let table:CardTable = this._tables[table_id]
        if(!table)
        {
            return
        }
        table.server.roomMgr.onTableDismiss(table_id)
        this._tables[table_id].onDestory()
        this._tables[table_id] = null
        delete this._tables[table_id]
    }
}