package taurus.util;

import hunan.HandAnalysis;

import java.util.*;
import java.util.stream.Collectors;

public class NewChangshaSuanFaTest {

    public int drawnCards; //摸牌
    public static List<Integer> tinCards = new ArrayList<>();
    public static boolean isTin = false;

    public static boolean isChi =false;

    public static boolean isPeng=false;

    //清一色
    //碰碰胡
    //七小对
    //将将胡




    public String newOutCardSuanFa(List<Integer> cardInhand, List<Integer> pengCard, List<Integer> chowGroup, List<Integer> resultList) {
        List<Integer> handCards = new ArrayList<>(cardInhand);
        handCards.sort(Integer::compareTo);
        int i = countPengGroups(handCards, pengCard); //刻子的数量
        boolean jiangHu = isJiangHu(handCards);//将将胡
        boolean isPengPengHu = hasThreeKeziAndTwoPairs(handCards, pengCard);//碰碰胡
        boolean hasBigSuit = isAllSameSuit(handCards, pengCard); // 清一色花色
        int pisCardsCount = countPairs(handCards);//分析七小对



        return "";
    }


    private int countPengGroups(List<Integer> handCards, List<Integer> pengCard) {
        List<Integer> handCards2 = new ArrayList<>();
        handCards2.addAll(handCards);
        handCards2.addAll(pengCard);


        // 按花色分组
        Map<Integer, List<Integer>> suitGroupMap = new HashMap<>();
        for (Integer card : handCards2) {
            int suit = card / 100;
            suitGroupMap.computeIfAbsent(suit, k -> new ArrayList<>()).add(card);
        }



        int keziCount = 0;

        // 对每个花色分别统计刻子
        for (Map.Entry<Integer, List<Integer>> entry : suitGroupMap.entrySet()) {
            int suit = entry.getKey();
            List<Integer> suitCards = entry.getValue();

            // 统计该花色下每张牌的数量
            Map<Integer, Integer> valueCountMap = new HashMap<>();
            for (Integer card : suitCards) {
                int value = card % 100;
                valueCountMap.put(value, valueCountMap.getOrDefault(value, 0) + 1);
            }

            // 找出该花色的刻子
            for (Map.Entry<Integer, Integer> valueEntry : valueCountMap.entrySet()) {
                if (valueEntry.getValue() >= 3) {
                    keziCount++;
                    int cardValue = suit * 100 + valueEntry.getKey();
//                    logInfo("找到刻子: " + getCardName(cardValue) + " (花色:" + getSuitName(suit) +
//                            ", 点数:" + valueEntry.getKey() + ", 数量:" + valueEntry.getValue() + ")");
                }
            }
        }

//        logInfo("手牌中共找到 " + keziCount + " 组刻子");
        return keziCount;
    }

    private boolean isJiangHu(List<Integer> handCards) {
        // 统计手牌中258牌的数量
        int count258 = 0;

        for (Integer card : handCards) {
            if (is258Card(card)) {
                count258++;
            }
        }

        // 判断258牌是否大于7张
        return count258 >= 10;
    }
    private boolean is258Card(int card) {
        // 假设牌型编码规则：
        // 101-109: 一万到九万
        // 201-209: 一筒到九筒
        // 301-309: 一条到九条

        // 获取牌的数字（个位数）
        int cardValue = card % 10;

        // 258牌的数字必须是2、5、8
        if (cardValue == 2 || cardValue == 5 || cardValue == 8) {
            // 确保是万、筒、条（排除风牌等）
            int cardType = card / 100;
            return true;
        }

        return false;
    }

    public boolean hasThreeKeziAndTwoPairs(List<Integer> handCards, List<Integer> pengCard) {
        List<Integer> handCards2 = new ArrayList<>();
        handCards2.addAll(handCards);
        handCards2.addAll(pengCard);

        // 统计每张牌出现的次数
        Map<Integer, Integer> cardCountMap = new HashMap<>();
        for (Integer card : handCards2) {
            cardCountMap.put(card, cardCountMap.getOrDefault(card, 0) + 1);
        }

        int keziCount = 0;  // 刻子数（三张相同）
        int pairCount = 0;  // 对子数（两张相同）

        // 统计刻子和对子
        for (int count : cardCountMap.values()) {
            if (count >= 3) {
                // 如果有3张或以上，可以算作一个刻子
                keziCount++;
                // 如果有4张，剩余的1张不能算对子，但可能算单张
                if (count >= 4) {
                    // 4张可以看作1个刻子+1张单牌，或者如果有需要可以调整
                    // 这里暂时不额外处理
                }
            } else if (count == 2) {
                pairCount++;
            }
        }

        // 检查是否有至少3个刻子和至少2个对子
        return keziCount >= 3 && pairCount >= 2;
    }

    public boolean isAllSameSuit(List<Integer> handCards, List<Integer> pengCard) {
        // 统计各花色的牌数量
        Map<Integer, Integer> suitCountMap = new HashMap<>();
        List<Integer> handCards2 = new ArrayList<>();
        handCards2.addAll(handCards);
        handCards2.addAll(pengCard);

        for (Integer card : handCards2) {
            int suit = card / 100; // 获取花色，100=万，200=筒，300=条
            suitCountMap.put(suit, suitCountMap.getOrDefault(suit, 0) + 1);
        }

        // 检查是否有花色的牌数量超过8张
        for (Map.Entry<Integer, Integer> entry : suitCountMap.entrySet()) {
            int suit = entry.getKey();

            int count = entry.getValue();

            if (count >= 10) {
//                String suitName = getSuitName(suit);
//                logInfo("检测到可能的清一色花色: " + suitName + ", 数量: " + count);
                return true;
            }
        }

        return false;
    }

    public int countPairs(List<Integer> handCards) {
        // 1. 先根据花色和点数排序
        List<Integer> sortedCards = new ArrayList<>(handCards);
        sortedCards.sort((a, b) -> {
            int suitA = a / 100;
            int suitB = b / 100;
            int rankA = a % 100;
            int rankB = b % 100;

            // 先按花色排序，再按点数排序
            if (suitA != suitB) {
                return suitA - suitB;
            }
            return rankA - rankB;
        });

        // 2. 统计对子
        int pairCount = 0;
        for (int i = 0; i < sortedCards.size() - 1; i++) {
            if (sortedCards.get(i).equals(sortedCards.get(i + 1))) {
                pairCount++;
                i++; // 跳过下一张
            }
        }

        return pairCount;
    }


    private Integer findIsolatedCardInFei6(List<Integer> feiCandidates) {
        // 统计每张牌的出现次数
        Map<Integer, Integer> countMap = new HashMap<>();
        for (int card : feiCandidates) {
            countMap.put(card, countMap.getOrDefault(card, 0) + 1);
        }

        // 寻找出现次数为 1 的牌（非对子）
        for (int card : feiCandidates) {
            if (countMap.get(card) == 1) {
                return card;
            }
        }

        // 如果没有非对子的牌，返回 null 或选择第一张牌等策略
        return feiCandidates.get(0);
    }
}
