import random
import csv
import json
import os
from datetime import datetime


class MazeGenerator:
    def __init__(self, size, filename, name="Default Maze"):
        # 迷宫基础元素
        self.ROUTE = '0'
        self.WALL = '1'
        # 特殊元素
        self.BOSS = 'b'
        self.START = 's'
        self.END = 'e'
        self.TRAP = 't'
        self.MECHANISM = 'l'
        self.GOLD = 'g'

        self.size = size
        self.maze = []
        self.filename = filename
        self.name = name  # 迷宫名称
        self.special_elements = []  # 存储特殊元素的位置和值
        self.history_mazes = []
    def initialize_maze(self):
        """初始化迷宫，全部填充为墙"""
        self.maze = [[self.WALL for _ in range(self.size)] for _ in range(self.size)]

    def create_maze(self, x1, y1, x2, y2):
        """递归分割法生成迷宫，墙壁始终在偶数坐标"""
        def getWallIndex(start, length):
            assert length >= 3
            wall_index = random.randint(start + 1, start + length - 2)
            if wall_index % 2 == 1:
                wall_index -= 1
            return wall_index

        def isValid(x, y):
            return 0 <= x < self.size and 0 <= y < self.size

        def isMovable(x, y):
            return self.maze[y][x] != self.WALL

        def generateHoles(x, y, width, height, wall_x, wall_y):
            holes = []
            hole_entrys = [
                (random.randint(x, wall_x - 1), wall_y),
                (random.randint(wall_x + 1, x + width - 1), wall_y),
                (wall_x, random.randint(y, wall_y - 1)),
                (wall_x, random.randint(wall_y + 1, y + height - 1))
            ]
            margin_entrys = [
                (x, wall_y), (x + width - 1, wall_y),
                (wall_x, y), (wall_x, y + height - 1)
            ]
            adjacent_entrys = [
                (x - 1, wall_y), (x + width, wall_y),
                (wall_x, y - 1), (wall_x, y + height)
            ]
            for i in range(4):
                adj_x, adj_y = adjacent_entrys[i]
                if isValid(adj_x, adj_y) and isMovable(adj_x, adj_y):
                    mx, my = margin_entrys[i]
                    self.maze[my][mx] = self.ROUTE
                else:
                    holes.append(hole_entrys[i])
            ignore_hole = random.randint(0, len(holes) - 1)
            for i in range(len(holes)):
                if i != ignore_hole:
                    hx, hy = holes[i]
                    self.maze[hy][hx] = self.ROUTE

        def recursiveDivision(x, y, width, height):
            if width < 3 or height < 3:
                return
            wall_x = getWallIndex(x, width)
            wall_y = getWallIndex(y, height)
            for i in range(x, x + width):
                self.maze[wall_y][i] = self.WALL
            for i in range(y, y + height):
                self.maze[i][wall_x] = self.WALL
            generateHoles(x, y, width, height, wall_x, wall_y)
            recursiveDivision(x, y, wall_x - x, wall_y - y)
            recursiveDivision(x, wall_y + 1, wall_x - x, y + height - wall_y - 1)
            recursiveDivision(wall_x + 1, y, x + width - wall_x - 1, wall_y - y)
            recursiveDivision(wall_x + 1, wall_y + 1, x + width - wall_x - 1, y + height - wall_y - 1)
            self.history_mazes.append([[__ for __ in _] for _ in self.maze])
            
        # 先全部通路
        self.maze = [[self.ROUTE for _ in range(self.size)] for _ in range(self.size)]
        # 四周加墙
        for x in range(self.size):
            self.maze[0][x] = self.WALL
            self.maze[self.size - 1][x] = self.WALL
        for y in range(self.size):
            self.maze[y][0] = self.WALL
            self.maze[y][self.size - 1] = self.WALL
        # 递归分割
        try:
            recursiveDivision(1, 1, self.size - 2, self.size - 2)
        except:
            self.create_maze(x1, y1, x2, y2)  # 如果递归失败，重新尝试
    def set_random_exits(self):
        """随机设置迷宫入口和出口"""
        available = self.get_available_cells()
        if len(available) < 2:
            raise ValueError("迷宫空间不足，无法设置随机出入口")
        start, end = random.sample(available, 2)
        self.maze[start[0]][start[1]] = self.START
        self.maze[end[0]][end[1]] = self.END
        self.special_elements.extend([(start[0], start[1], self.START), (end[0], end[1], self.END)])
    def get_history_mazes(self):
        for idx,i in enumerate(self.history_mazes):
            if i == self.history_mazes[idx-1]:
               del self.history_mazes[idx]
             
        return self.history_mazes
    
    def get_available_cells(self):
        """获取所有可通行单元格"""
        cells = []
        for i in range(1, self.size - 1):
            for j in range(1, self.size - 1):
                if self.maze[i][j] == self.ROUTE:
                    cells.append((i, j))
        return cells

    def place_special_elements(self, boss_count=0, traps_range=(3, 8),
                               mechanisms_range=(2, 6), skill_traps=5,gold_range=(3,8)):
        """放置特殊元素（支持技能触发陷阱）- 不包括Boss和机关，这些将在路径生成后放置"""
        available = self.get_available_cells()
        random.shuffle(available)

        # 计算所需单元格数量（不包括Boss和机关）
        required = 2 + random.randint(*traps_range) + skill_traps + random.randint(*gold_range)
        if len(available) < required:
            raise ValueError(f"空间不足，需要{required}个单元格，实际可用{len(available)}")

        # 放置出入口
        start, end = available.pop(), available.pop()
        self.special_elements.extend([(start[0], start[1], self.START), (end[0], end[1], self.END)])
        self.maze[start[0]][start[1]] = self.START
        self.maze[end[0]][end[1]] = self.END

        # 注释掉Boss放置，Boss将在路径生成后放置
        # # 放置BOSS
        # for _ in range(boss_count):
        #     pos = available.pop()
        #     val = random.randint(50, 100)
        #     self.special_elements.append((pos[0], pos[1], f"{self.BOSS}{val}"))
        #     self.maze[pos[0]][pos[1]] = f"{self.BOSS}{val}"

        # 放置普通陷阱
        traps = random.randint(*traps_range)
        for _ in range(traps):
            pos = available.pop()
            val = random.randint(5, 20)
            self.special_elements.append((pos[0], pos[1], f"{self.TRAP}{val}"))
            self.maze[pos[0]][pos[1]] = f"{self.TRAP}{val}"

        # 技能触发陷阱
        for _ in range(skill_traps):
            pos = available.pop()
            val = random.randint(5, 20)
            self.special_elements.append((pos[0], pos[1], f"{self.TRAP}{val}"))
            self.maze[pos[0]][pos[1]] = f"{self.TRAP}{val}"

        # 注释掉机关放置，机关将在路径生成后放置
        # # 放置机关
        # mechanisms = random.randint(*mechanisms_range)
        # for _ in range(mechanisms):
        #     pos = available.pop()
        #     val = random.randint(10, 30)
        #     self.special_elements.append((pos[0], pos[1], f"{self.MECHANISM}{val}"))
        #     self.maze[pos[0]][pos[1]] = f"{self.MECHANISM}{val}"
        
        # 放置金币
        gold_count = random.randint(*gold_range)
        for _ in range(gold_count):
            pos = available.pop()
            val = random.randint(10, 30)
            self.special_elements.append((pos[0], pos[1], f"{self.GOLD}{val}"))
            self.maze[pos[0]][pos[1]] = f"{self.GOLD}{val}"

    def generate(self, seed=None, traps_range=(3, 8),
                 mechanisms_range=(1, 1), skill_traps=5):
        """生成迷宫主方法 - Boss和机关将在路径生成后单独放置"""
        # 清除之前的历史记录
        self.history_mazes = []
        self.special_elements = []
        
        random.seed(seed or random.randint(0, 1000))
        self.initialize_maze()
        self.create_maze(1, 1, self.size - 2, self.size - 2)
        self.patch_maze_edges()  # 自动修正边界
        self.place_special_elements(0, traps_range, mechanisms_range, skill_traps)  # boss_count=0, mechanisms也不在这里放置
        print(f"成功生成迷宫: {self.name} (Boss和机关将在路径生成后放置)")

    def export_to_csv(self, filename):
        """导出迷宫到CSV文件"""
        try:
            with open(filename, 'w', newline='') as f:
                writer = csv.writer(f)
                for row in self.maze:
                    writer.writerow(row)
            print(f"迷宫已导出至: {os.path.abspath(filename)}")
        except Exception as e:
            print(f"导出失败: {str(e)}")

    def read_from_csv(self):
        """从CSV读取迷宫数据"""
        try:
            with open(self.filename, 'r', newline='') as f:
                reader = csv.reader(f)
                self.maze = [list(map(self._parse_element, row)) for row in reader]
            self.size = len(self.maze)
            print(f"成功从{os.path.abspath(self.filename)}读取迷宫")
            return True
        except Exception as e:
            print(f"读取失败: {str(e)}")
            return False

    def _parse_element(self, elem):
        """解析CSV中的元素类型"""
        if elem == 's': return self.START
        if elem == 'e': return self.END
        if elem.startswith('b'): return self.BOSS
        if elem.startswith('t'): return self.TRAP
        if elem.startswith('l'): return self.MECHANISM
        if elem.startswith('g'): return self.GOLD

        return int(elem)

    def print_maze(self):
        """打印迷宫到控制台（带元素标识）"""
        symbols = {
            self.WALL: '■', self.ROUTE: '·', self.START: 'S',
            self.END: 'E', self.BOSS: 'B', self.TRAP: 'T',
            self.GOLD: 'G','|':'|','-':'—',
        }
        for row in self.maze:
            display = []
            for cell in row:
                symbol = symbols.get(((str)(cell))[0], ((str)(cell))[0])
                display.append(str(symbol))
            print(' '.join(display))
    def read_csv(self):
        l = []
        with open(f'{self.filename}', 'r', newline='') as f:
            reader = csv.reader(f)
            for row in reader:
                l.append(row)
        return l
    def patch_maze_edges(self):
        
        """只在不破坏联通性的前提下，修正右侧和下侧边界的多余通路（加墙）"""
        n = self.size
        if n %2==1:
            return 
        candidates = []
        # 倒数第二列（右侧）
        x = n - 2
        for y in range(1, n-1):
            if self.maze[y][x] == self.ROUTE:
                right = self.maze[y][x+1] if x+1 < n else self.WALL
                down = self.maze[y+1][x] if y+1 < n else self.WALL
                if right == self.ROUTE or down == self.ROUTE:
                    candidates.append((y, x))
        # 倒数第
        # 二行（下侧）
        y = n - 2
        for x in range(1, n-1):
            if self.maze[y][x] == self.ROUTE:
                right = self.maze[y][x+1] if x+1 < n else self.WALL
                down = self.maze[y+1][x] if y+1 < n else self.WALL
                if right == self.ROUTE or down == self.ROUTE:
                    candidates.append((y, x))
        # 逐个尝试加墙，确保联通
        for y, x in candidates:
            old = self.maze[y][x]
            self.maze[y][x] = self.WALL
            if not self.is_maze_connected():
                self.maze[y][x] = old  # 恢复
        self.history_mazes.append([[__ for __ in _] for _ in self.maze])

    def is_maze_connected(self):
        """检查迷宫是否连通（深度优先搜索）"""
        visited = [[False] * self.size for _ in range(self.size)]

        def dfs(x, y):
            if x < 0 or x >= self.size or y < 0 or y >= self.size:
                return
            if visited[y][x] or self.maze[y][x] == self.WALL:
                return
            visited[y][x] = True
            dfs(x + 1, y)
            dfs(x - 1, y)
            dfs(x, y + 1)
            dfs(x, y - 1)

        # 从左上角开始搜索
        dfs(1, 1)

        # 检查是否所有通路都被访问
        for y in range(1, self.size - 1):
            for x in range(1, self.size - 1):
                if self.maze[y][x] == self.ROUTE and not visited[y][x]:
                    return False
        return True

    def export_to_json(self, filename):
        """导出迷宫到JSON文件"""
        try:
            import json
            from datetime import datetime
            
            # 转换迷宫格式
            json_maze = self._convert_to_json_format()
            
            # 创建JSON数据结构
            json_data = {
                "maze": json_maze,
                "metadata": {
                    "name": self.name,
                    "size": self.size,
                    "export_time": datetime.now().isoformat() if 'datetime' in globals() else None,
                    "special_elements_count": len(self.special_elements)
                }
            }
            
            with open(filename, 'w', encoding='utf-8') as f:
                json.dump(json_data, f, indent=2, ensure_ascii=False)
            print(f"迷宫已导出至: {os.path.abspath(filename)}")
        except Exception as e:
            print(f"JSON导出失败: {str(e)}")
    
    def _convert_to_json_format(self):
        """
        将内部迷宫格式转换为JSON格式
        '1' -> '#', '0' -> ' ', 's' -> 'S', 'e' -> 'E'
        'g数字' -> 'G', 't数字' -> 'T', 'l数字' -> 'L', 'b数字' -> 'B'
        """
        json_maze = []
        for row in self.maze:
            json_row = []
            for cell in row:
                cell_str = str(cell)
                if cell_str == '1':
                    json_row.append('#')
                elif cell_str == '0':
                    json_row.append(' ')
                elif cell_str == 's':
                    json_row.append('S')
                elif cell_str == 'e':
                    json_row.append('E')
                elif cell_str.startswith('g'):
                    json_row.append('G')
                elif cell_str.startswith('t'):
                    json_row.append('T')
                elif cell_str.startswith('l'):
                    json_row.append('L')
                elif cell_str.startswith('b'):
                    json_row.append('B')
                else:
                    json_row.append(' ')  # 默认为通路
            json_maze.append(json_row)
        return json_maze

    def place_boss_on_path(self, path, boss_count=1):
        """
        在给定路径上随机放置Boss
        
        Args:
            path: 路径列表，格式为[(y1, x1), (y2, x2), ...]
            boss_count: 要放置的Boss数量，默认为1
        
        Returns:
            list: 放置Boss的位置列表
        """
        if not path or len(path) < 3:
            print("路径太短，无法放置Boss")
            return []
        
        # 排除起点和终点，只在中间路径上放置Boss
        middle_path = path[1:-1]  # 去掉第一个（起点）和最后一个（终点）
        
        if len(middle_path) < boss_count:
            print(f"路径中间位置不足，只能放置{len(middle_path)}个Boss")
            boss_count = len(middle_path)
        
        # 随机选择Boss放置位置
        boss_positions = random.sample(middle_path, boss_count)
        placed_bosses = []
        
        for pos in boss_positions:
            y, x = pos
            # 只在通路位置放置Boss，避免覆盖特殊元素
            if self.maze[y][x] == self.ROUTE or str(self.maze[y][x]).startswith('p'):
                val = random.randint(50, 100)
                boss_element = f"{self.BOSS}{val}"
                self.maze[y][x] = boss_element
                self.special_elements.append((y, x, boss_element))
                placed_bosses.append((y, x, val))
                print(f"在路径位置 ({y}, {x}) 放置Boss，血量: {val}")
        
        return placed_bosses

    def place_mechanisms_on_path(self, path, mechanisms_count=1, mechanisms_range=(1, 1)):
        """
        在给定路径上随机放置机关
        
        Args:
            path: 路径列表，格式为[(y1, x1), (y2, x2), ...]
            mechanisms_count: 要放置的机关数量，默认为1
            mechanisms_range: 机关数量范围，当mechanisms_count为None时使用
        
        Returns:
            list: 放置机关的位置列表
        """
        if not path or len(path) < 3:
            print("路径太短，无法放置机关")
            return []
        
        # 如果没有指定机关数量，使用默认值1
        if mechanisms_count is None:
            mechanisms_count = 1
        
        # 排除起点和终点，只在中间路径上放置机关
        middle_path = path[1:-1]  # 去掉第一个（起点）和最后一个（终点）
        
        # 过滤掉已经被Boss和其他特殊元素占据的位置
        available_positions = []
        for pos in middle_path:
            y, x = pos
            cell_str = str(self.maze[y][x])
            # 只在通路位置或路径标记位置放置机关，避免覆盖Boss和其他特殊元素
            if (self.maze[y][x] == self.ROUTE or cell_str.startswith('p')) and not cell_str.startswith('b'):
                available_positions.append(pos)
        
        if len(available_positions) < mechanisms_count:
            print(f"路径中可用位置不足，只能放置{len(available_positions)}个机关")
            mechanisms_count = len(available_positions)
        
        if mechanisms_count <= 0:
            print("无可用位置放置机关")
            return []
        
        # 随机选择机关放置位置，确保不重复
        mechanism_positions = random.sample(available_positions, mechanisms_count)
        placed_mechanisms = []
        
        for pos in mechanism_positions:
            y, x = pos
            # 再次检查位置是否可用（避免重复放置）
            if self.maze[y][x] == self.ROUTE or str(self.maze[y][x]).startswith('p'):
                val = random.randint(10, 30)
                mechanism_element = f"{self.MECHANISM}{val}"
                self.maze[y][x] = mechanism_element
                self.special_elements.append((y, x, mechanism_element))
                placed_mechanisms.append((y, x, val))
                print(f"在路径位置 ({y}, {x}) 放置机关，奖励: {val}")
        
        return placed_mechanisms

def main():
    # 示例1: 生成带技能陷阱的迷宫
    generator = MazeGenerator(
        size=20,
        filename="dungeon_maze.csv"
    )
    generator.generate(
        seed=666
    )
    generator.print_maze()
    generator.export_to_csv("d.csv")
    for i in generator.history_mazes:
        print(i[3:])

    reader = MazeGenerator(size=1, filename="d.csv")
    if reader.read_from_csv():
        print("\n读取的迷宫:")
        reader.print_maze()
    for i in generator.get_history_mazes():
        for j in i:
            print(j)
        print()

if __name__ == "__main__":
    main()