import unittest

from SugarRush1000 import SugarRush1000

def no_cluster_grid():
    return [
            (
                ["B" if col % 2 == 0 else "E" for col in range(7)]
                if row % 2 == 0
                else ["E" if col % 2 == 0 else "B" for col in range(7)]
            )
            for row in range(7)
        ]

def print_mid_result(tag, res):
    print(f"\n======={tag}=========")
    for index, grid in enumerate(res["middle_grids"]):
        print(f"step{index+1}---")
        print(f"倍数点数")
        print("   ",end="")
        for i in range(7):
            print(f"{i} ",end=" ")
        print()
        for i,row in enumerate(res["middle_multipliers"][index]):
            print(f"{i} {row}")
        print(f"消除符号")
        for symbol in res["middle_grid_remove_symbols"][index]:
            print(symbol)
        print(f"score:{res['middle_score'][index]}")
        for row in grid:
            print(row)


class TestSugarRushLogic(unittest.TestCase):
    def setUp(self):
        self.bet = 1.0

    def test_basic_cascade_and_drop(self):
        # 0. 准备数据：构造一个即将消除的场景
        # 假设中间一行全是 'A'，且数量 >=5
        # 为了演示，我们假设 rows=7, cols=7，手动构造特定列

        # 构造一个特定网格：第3行全是 A (7个)，其他是 B
        custom_grid = no_cluster_grid()
        custom_grid[3] = ["A"] * 7

    
        game = SugarRush1000(bet=self.bet, mock_grid=custom_grid)
        game.drop_sequence = ["C", "C", "C", "C", "A", "A", "A"]  # 预设掉落全是 C

        # 1. 执行 Spin
        result = game.doSpin()

        # 2. 断言验证
        self.assertEqual(result["win"], 1.75)

        # 验证网格状态：第3行的 A 应该消失，顶部的 B 应该掉下来，顶部变成 C
        # 原第3行变空，上方的第0,1,2行掉落填补，顶部第0行填入新符号 C
        # 所以最终第0行应该是 C，第3行应该是原来的第2行 (B)
        self.assertEqual(result["grid"][0][0], "C")  # 顶部掉入了新符号
        self.assertEqual(result["grid"][3][0], "B")  # 原本上面的 B 掉下来了

        print("✅ 测试通过：基础翻转与掉落逻辑正常")

    def test_multiplier_mechanic(self):
        # 准备数据：测试乘数翻倍
        custom_grid = no_cluster_grid()
        custom_grid[0] = ["A"] * 7  # 设置一个乘数点
        
        game = SugarRush1000(bet=self.bet, mock_grid=custom_grid)
        game.drop_sequence = ["C", "C", "C", "C", "C", "C", "C",
                              "C", "C", "C", "C", "C", "C", "C",
                              "C", "A", "B", "C", "D", "A", "B"]  # 预设掉落全是 C
        result = game.doSpin()

        self.assertEqual(result["middle_multipliers"][3][0][0], 4)
        self.assertEqual(result["win"], 16.75)
        print("✅ 测试通过：乘数翻倍逻辑正常")

    def test_scatter_trigger(self):
        # 0. 准备数据：放置 3 个 Scatter
        custom_grid = no_cluster_grid()
        custom_grid[0][0] = "S"
        custom_grid[1][1] = "S"
        custom_grid[2][2] = "S"

        game = SugarRush1000(bet=self.bet, mock_grid=custom_grid)
        result = game.doSpin()

        # 1. 断言
        self.assertEqual(result["free_spins_remaining"], 10)  # 3个 Scatter 应得 10 次
        self.assertTrue("触发免费旋转" in result["message"])

        print("✅ 测试通过：Scatter 触发逻辑正常")

    def test_max_win_cap(self):
        # 0. 准备数据：构造一个巨大的赢利场景
        # 比如很多高价值符号，且带有高倍乘数
        custom_grid = no_cluster_grid()
        custom_grid[0] = ["A"] * 7  # 一行A
        custom_grid[1][0] = "S"     # 10次免费旋转，但是达到上限后应该清0
        custom_grid[2][1] = "S"
        custom_grid[3][2] = "S"
        game = SugarRush1000(bet=self.bet, mock_grid=custom_grid)
        game.drop_sequence = ["A" for _ in range(7) for _ in range(11)]

        result = game.doSpin()

        # 1. 断言
        max_win = 25000 * self.bet
        # 即使全屏超高赔率，赢利也不能超过 25000
        self.assertLessEqual(result["win"], max_win)
        if result["win"] >= max_win:
            self.assertEqual(result["free_spins_remaining"], 0)  # 达到上限应结束

        print("✅ 测试通过：最大赢奖上限逻辑正常")


if __name__ == "__main__":
    unittest.main(argv=["first-arg-is-ignored"], exit=False)