export let GTexasTool:TexasTool = null
//牌大小位1-52，和4取余为花色0-黑桃，1-方块，2-梅花，3-红桃 
//反向算法 用想要的(数字-2)*4+上述的类型值
//牌的值除以4向上取整+1（有余数的额外+1）1方块2，2梅花2，3红桃2，4黑桃2
export enum ECardType
{
    None            = 0, // 未知
    High            = 1, // 高牌
    OnePair         = 2, // 一对
    TwoPair         = 3, // 两对
    Tribble         = 4, // 三条
    Straight        = 5, // 顺子
    Flush           = 6, // 同花
    FullHouse       = 7, // 葫芦
    Quadruple       = 8, // 四条
    StraightFlush   = 9, // 同花顺
    RoyalFlush      = 10 // 皇家同花顺
}
/*
10皇家同花顺
9同花顺
8四条
7满堂彩（葫芦）
6同花
5顺子
4三条
3两对
2一对
1单牌
*/
class TexasTool
{
    getCardDetail(card:number)
    {
        let cd = {
            type:card%4,
            cd:Math.ceil(card/4)+1,
        }
        return cd
    }
    compare(rs0:{type:number,cards:Array<{type:number,cd:number}>,detailcards:any},rs1:{type:number,cards:Array<{type:number,cd:number}>,detailcards:any})
    {
        if(rs0.type>rs1.type)
        {
            return 1
        }
        if(rs0.type<rs1.type)
        {
            return -1
        }
        for(let i=0;i<rs0.cards.length;++i)
        {
            if(rs0.cards[i].cd>rs1.cards[i].cd)
            {
                return 1
            }
            if(rs0.cards[i].cd<rs1.cards[i].cd)
            {
                return -1
            }
        }
        return 0
    }
    getCardResult(user_cards:Array<number>,public_cards:Array<number>)
    {
        if(!user_cards||!public_cards||user_cards.length!=2||public_cards.length<3)
        {
            return null
        }
        let cards = user_cards.concat(public_cards)
        let allCards:Array<{type:number,cd:number}>=[]
        for(let i=0;i<cards.length;++i)
        {
            let card = {
                type:cards[i]%4,
                cd:Math.ceil(cards[i]/4)+1,
            }
            allCards.push(card)
        }
        let rs = this.getCardEnd(allCards)
        return rs
    }
    getCardEnd(allCards:Array<{type:number,cd:number}>)
    {
        if(!allCards)
        {
            return null
        }
        let totalNum = allCards.length
        if(totalNum < 5)
        {
            return null
        }

        // 遍历所有五张牌组合情况
        let cards = new Array<{[x: number]:{type:number,cd:number}}>()
        for(let i1 = 0;i1<totalNum - 4;++i1)
        {
            for(let i2 = i1 + 1;i2<totalNum - 3;++i2)
            {
                for(let i3 = i2 + 1;i3<totalNum - 2;++i3)
                {
                    for(let i4 = i3 + 1;i4<totalNum - 1;++i4)
                    {
                        for(let i5 = i4 + 1;i5<totalNum;++i5)
                        {
                            cards.push({
                                [i1]:allCards[i1],
                                [i2]:allCards[i2],
                                [i3]:allCards[i3],
                                [i4]:allCards[i4],
                                [i5]:allCards[i5],
                            })
                        }
                    }
                }
            }
        }

        // 对每一种排列组合判断牌型
        let preResult = this._getCardResult(cards[0])
        let preIndex = 1
        for(let i = 1;i<cards.length;++i)
        {
            let result = this._getCardResult(cards[i])
            let j = 0
            if(result.type == preResult.type)
            {
                while(result.cards[j] && preResult.cards[j] && result.cards[j].cd == preResult.cards[j].cd)
                {
                    j = j + 1
                }
                if(result.cards[j] && preResult.cards[j] && result.cards[j].cd > preResult.cards[j].cd)
                {
                    preResult = result
                    preIndex = i
                }
            }
            else if(result.type>preResult.type)
            {
                preResult = result
                preIndex = i
            }
        }
        return {type:preResult.type,cards:preResult.cards,detailcards:cards[preIndex]}
    }

    protected _getCardResult(cards:{[x: number]:{type:number,cd:number}})
    {
        let fiveCards = this._sortCards(cards)
        // 9同花顺
        let result = this._isTongHuaShun(fiveCards)
        if(result.ret)
        {
            if(result.cards[0].cd < 14)
            {
                return {type:9,cards:result.cards}
            }
            else
            {
                return {type:10,cards:result.cards}
            }
        }
        // 8四条
        result = this._isSiTiao(fiveCards)
        if(result.ret)
        {
            return {type:ECardType.Quadruple,cards:result.cards}
        }
        // 7满堂彩（葫芦）
        result = this._isHuLu(fiveCards)
        if(result.ret)
        {
            return {type:ECardType.FullHouse,cards:result.cards}
        }
        // 6同花
        result = this._isTongHua(fiveCards)
        if(result.ret)
        {
            return {type:ECardType.Flush,cards:result.cards}
        }
        // 5顺子
        result = this._isShunZi(fiveCards)
        if(result.ret)
        {
            return {type:ECardType.Straight,cards:result.cards}
        }
        // 4三条
        result = this._isSantiao(fiveCards)
        if(result.ret)
        {
            return {type:ECardType.Tribble,cards:result.cards}
        }
        // 3两对
        result = this._isLiangDui(fiveCards)
        if(result.ret)
        {
            return {type:ECardType.TwoPair,cards:result.cards}
        }
        // 2一对
        result = this._isYiDui(fiveCards)
        if(result.ret)
        {
            return {type:ECardType.OnePair,cards:result.cards}
        }
        // 1单牌
        //let cards = this._sortCards(fiveCards)
        return {type:ECardType.High,cards:fiveCards}
    }

    protected _sortCards(cards:{[x: number]:{type:number,cd:number}})
    {
        let temp = []
        for(let key in cards)
        {
            let card = cards[key]
            temp.push(card)
        }
        temp.sort((a, b)=>
        {
            return b.cd - a.cd
        } )
        return temp
    }
    // 是否同花顺
    protected _isTongHuaShun(fiveCards:Array<{type:number,cd:number}>)
    {
        let tongHua = this._isTongHua(fiveCards)
        if(!tongHua.ret)
        {
            // 不是同花
            return { ret:false,cards:null }
        }
        return this._isShunZi(fiveCards)
    }

    // 是否同花
    protected _isTongHua(fiveCards:Array<{type:number,cd:number}>)
    {
        let preType = -1
        for(let i=0;i<fiveCards.length;++i)
        {
            let card = fiveCards[i]
            if(preType<0)
            {
                preType = card.type
            }
            else if(preType != card.type)
            {
                return { ret:false }
            }
        }
        let result = { ret:true,cards:fiveCards.concat() }
        return result
    }

    // 是否顺子
    protected _isShunZi(fiveCards:Array<{type:number,cd:number}>)
    {
        for(let i = 1; i<4;++i)
        {
            let dt = fiveCards[i].cd - fiveCards[i + 1].cd
            if(dt != 1)
            {
                return { ret:false }
            }
        }
        if(fiveCards[0].cd == 14)
        {
            if(fiveCards[4].cd != 2 && fiveCards[1].cd != 13)
            {
                return { ret:false }
            }
            else
            {
                if(fiveCards[4].cd==2)
                {
                    return { ret:true, cards:[fiveCards[1], fiveCards[2], fiveCards[3], fiveCards[4], fiveCards[0]] }
                }
                else
                {
                    return { ret:true, cards:[fiveCards[0], fiveCards[1], fiveCards[2], fiveCards[3], fiveCards[4]] }
                }
            }
        }
        else if(fiveCards[0].cd - fiveCards[1].cd != 1)
        {
            return { ret:false }
        }
        return { ret:true, cards:[fiveCards[0], fiveCards[1], fiveCards[2], fiveCards[3], fiveCards[4]] }
    }

    // 是否四条
    protected _isSiTiao(fiveCards:Array<{type:number,cd:number}>)
    {
        let cards = fiveCards
        if(cards[1].cd != cards[2].cd || cards[2].cd != cards[3].cd)
        {
            return { ret:false }
        }
        if(cards[0].cd == cards[1].cd)
        {
            return { ret:true, cards:cards }
        }
        if(cards[3].cd == cards[4].cd)
        {
            let cd = cards.splice(0,1)[0]
            cards.push(cd)
            return { ret:true, cards:cards.concat() }
        }
        return { ret:false,cards:null }
    }

    // 是否满堂彩（葫芦）
    protected _isHuLu(fiveCards:Array<{type:number,cd:number}>)
    {
        let sanTiao = this._isSantiao(fiveCards)
        if(!sanTiao.ret)
        {
            // 不是满堂彩
            return { ret:false }
        }
        if(sanTiao.cards[3].cd != sanTiao.cards[4].cd)
        {
            return { ret:false }
        }
        return sanTiao
    }
    // 是否三条
    protected _isSantiao(fiveCards:Array<{type:number,cd:number}>)
    {
        for(let i = 0;i<3;++i)
        {
            let j = i + 1
            let k = j + 1
            if(fiveCards[i].cd == fiveCards[j].cd && fiveCards[j].cd == fiveCards[k].cd)
            {
                let card1 = null
                let card2 = null
                if(i==0)
                {
                    card1=fiveCards[3]
                    card2=fiveCards[4]
                }
                else if(i==1)
                {
                    card1=fiveCards[0]
                    card2=fiveCards[4]
                }
                else if(i==2)
                {
                    card1=fiveCards[0]
                    card2=fiveCards[1]
                }
                return { ret:true, cards:[fiveCards[i], fiveCards[j], fiveCards[k], card1, card2] }
            }
        }
        return { ret:false }
    }

    // 是否两对
    protected _isLiangDui(fiveCards:Array<{type:number,cd:number}>)
    {
        let yidui = this._isYiDui(fiveCards)
        if(!yidui.ret)
        {
            return { ret:false }
        }

        if(yidui.cards[2].cd == yidui.cards[3].cd)
        {
            if(yidui.cards[0].cd > yidui.cards[2].cd)
            {
                return yidui
            }
            return { ret:true, cards:[yidui.cards[2], yidui.cards[3], yidui.cards[0], yidui.cards[1], yidui.cards[4]] }
        }
        else if(yidui.cards[3].cd == yidui.cards[4].cd)
        {
            if(yidui.cards[0].cd > yidui.cards[3].cd)
            {
                return { ret:true, cards:[yidui.cards[0], yidui.cards[1], yidui.cards[3], yidui.cards[4], yidui.cards[2]] }
            }
            return { ret:true, cards:[yidui.cards[3], yidui.cards[4],yidui.cards[0], yidui.cards[1],yidui.cards[2]] }
        }
        return { ret:false }
    }

    // 是否一对
    protected _isYiDui(fiveCards:Array<{type:number,cd:number}>)
    {
        for(let i = 0;i<fiveCards.length - 1;++i)
        {
            let j = i + 1
            if(fiveCards[i].cd == fiveCards[j].cd)
            {
                let card = fiveCards[i]
                let tmp:{[x: number]:{type:number,cd:number}} = {}
                for(let index=0;index<fiveCards.length;++index)
                {
                    let cd = fiveCards[index]
                    if(cd.cd != card.cd)
                    {
                        tmp[index]=cd
                    }
                }
                let result = { ret:true, cards:[fiveCards[i], fiveCards[j]].concat(this._sortCards(tmp)) }
                return result
            }
        }
        return { ret:false,cards:null,other:null }
    }
}
GTexasTool = new TexasTool()