package game_mj_changsha;

import com.taurus.permanent.TPServer;

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

public class Main {
    public static void main(String[] args) {
		TPServer.me().start();
//		// 统计每张牌出现的次数
//
       /* List<Integer> handCards = new ArrayList<>();
        List<Integer> resultList = new ArrayList<>();
        handCards.add(103);
        handCards.add(103);
        handCards.add(103);
        handCards.add(204);
        handCards.add(204);
        handCards.add(204);
        handCards.add(206);
        handCards.add(206);
        handCards.add(205);
        handCards.add(205);

//
        resultList.add(106);
        resultList.add(109);
        resultList.add(101);
        resultList.add(102);
        resultList.add(103);
        resultList.add(203);
        resultList.add(208);
        resultList.add(206);
        resultList.add(206);
        resultList.add(203);
        resultList.add(201);
        resultList.add(106);
        resultList.add(205);
//
//
//
//
//
//
//		// 统计每张牌出现的次数
//		Map<Integer, Integer> cardCountMap = new HashMap<>();
//		for (Integer card : handCards) {
//			cardCountMap.put(card, cardCountMap.getOrDefault(card, 0) + 1);
//		}
//
//		System.out.println("统计结果: " + cardCountMap);
//
//		List<Integer> singleCards = new ArrayList<>();
//
//		// 遍历手牌，计算哪些是单张
//		for (Map.Entry<Integer, Integer> entry : cardCountMap.entrySet()) {
//			int card = entry.getKey();
//			int count = entry.getValue();
//
//			// 计算剩余单张的数量
//			int remainder = count % 2;  // 取模2，奇数就有一个单张
//			if (remainder == 1) {
//				singleCards.add(card);
//			}
//
//		}
//
//		System.out.println("单张牌: " + singleCards);
//
//		Map<Integer, Integer> danzhangCountMap = new HashMap<>();
//
//		for (Integer card2 : singleCards) {
//			danzhangCountMap.put(card2, 0);
//		}
//
//
//		for (Integer card3 : resultList) {
//			if (danzhangCountMap.containsKey(card3)) {
//				danzhangCountMap.put(card3, danzhangCountMap.get(card3) + 1);
//			}
//		}
//
//// 找到最大的出现次数
//		Integer maxCount = danzhangCountMap.values().stream()
//				.max(Integer::compareTo)
//				.orElse(0);
//
//// 找出出现次数等于最大次数的牌
//		List<Integer> maxCards = danzhangCountMap.entrySet().stream()
//				.filter(entry -> entry.getValue().equals(maxCount))
//				.map(Map.Entry::getKey)
//				.collect(Collectors.toList());
//
//		List<Integer> threeCardsFromMax = maxCards.stream()
//				.filter(card3 -> Collections.frequency(handCards, card3) == 3)
//				.collect(Collectors.toList());
//
//		if (threeCardsFromMax.size() >0){
//			List<Integer> zeroCountCards = threeCardsFromMax.stream()
//					.filter(card -> danzhangCountMap.getOrDefault(card, 0) == 0)
//					.collect(Collectors.toList());
//			System.out.println("出现次数为0的牌: " + zeroCountCards);
//			// 从maxCards中移除
//			if (!zeroCountCards.isEmpty()) {
//				maxCards.removeAll(zeroCountCards);
//				System.out.println("移除后maxCards: " + maxCards);
//			}
//		}
//
//		System.out.println("maxCards中出现3次的牌: " + threeCardsFromMax);
//
//		System.out.println("maxCards中出现3次的牌: " + threeCardsFromMax);
//		if (threeCardsFromMax.size() > 0) {
//			System.out.println(threeCardsFromMax.get(0));
//		}
//
//
//		Integer minCard = maxCards.isEmpty() ? null : maxCards.get(0);
//		System.out.println(minCard);

        //分析碰碰胡是否听牌
//		boolean b = hasThreeKeziAndTwoPairs(handCards);
//		System.out.println(b);

        List<Integer> pengCard = new ArrayList<>();
        pengCard.add(102);
        pengCard.add(102);
        pengCard.add(102);
        int i = countPengGroups(handCards,pengCard); //刻子的数量
        boolean isPengPengHu = hasThreeKeziAndTwoPairs(handCards,pengCard);
        if (isPengPengHu){
            System.out.println("--------------------------------碰碰胡4刻子----==========================");
            Map<String, List<?>> stringListMap = separateKeziAndRemaining(handCards);
            List<?> remaining = stringListMap.get("remaining");
            Map<Integer, Integer> danzhangCountMap = new HashMap<>();
            //循环获取剩余的牌
            for (Object remaining1 : remaining) {
                danzhangCountMap.put((Integer) remaining1, 0);
            }

            for (Integer card3 : resultList) {
                if (danzhangCountMap.containsKey(card3)) {
                    danzhangCountMap.put(card3, danzhangCountMap.get(card3) + 1);
                }
            }

            Integer maxCount = danzhangCountMap.values().stream()
                    .max(Integer::compareTo)
                    .orElse(0);


            List<Integer> maxCards = danzhangCountMap.entrySet().stream()
                    .filter(entry -> entry.getValue().equals(maxCount))
                    .map(Map.Entry::getKey)
                    .collect(Collectors.toList());

            Integer maxCard = maxCards.isEmpty() ? null : maxCards.get(0);
            System.out.println("==========碰碰胡----====maxCard++++++++++++++++++++++++++++++" + maxCard);
            System.out.println(maxCard);
//            return String.valueOf(maxCard);

        }
        */

    }

    //分析碰碰胡是否听牌
    public static 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;
    }


    private static Map<String, List<?>> separateKeziAndRemaining(List<Integer> handCards) {
        List<List<Integer>> keziList = new ArrayList<>();
        Set<Integer> remainingCardsSet = new HashSet<>();  // 使用Set去重

        if (handCards == null || handCards.isEmpty()) {
            Map<String, List<?>> result = new HashMap<>();
            result.put("kezi", keziList);
            result.put("remaining", new ArrayList<>());
            return result;
        }

        // 统计每张牌的数量
        Map<Integer, Integer> countMap = new HashMap<>();
        for (Integer card : handCards) {
            countMap.put(card, countMap.getOrDefault(card, 0) + 1);
        }

        // 分离刻子
        for (Map.Entry<Integer, Integer> entry : countMap.entrySet()) {
            int card = entry.getKey();
            int count = entry.getValue();

            if (count >= 3) {
                // 添加刻子
                List<Integer> kezi = new ArrayList<>();
                for (int i = 0; i < 3; i++) {
                    kezi.add(card);
                }
                keziList.add(kezi);

                // 如果还有剩余，加入Set去重
                if (count > 3) {
                    remainingCardsSet.add(card);
                }
            } else {
                // 全部加入剩余牌Set
                remainingCardsSet.add(card);
            }
        }

        // 将Set转换为List
        List<Integer> remainingCards = new ArrayList<>(remainingCardsSet);

        Map<String, List<?>> result = new HashMap<>();
        result.put("kezi", keziList);
        result.put("remaining", remainingCards);
        return result;
    }


    private static int countPengGroups(List<Integer> handCards, List<Integer> pengCard) {
        List<Integer> handCards2 = new ArrayList<>();
        handCards2.addAll(handCards);
        handCards2.addAll(pengCard);
        System.out.println("碰碰胡 handCards2 ++++++++++++++++" + handCards2);

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

//        logInfo("手牌花色分组: " + suitGroupMap.keySet().size() + " 种花色");

        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;
    }
}