# main.py
import sys
import os
import random
import json
from PyQt5.QtWidgets import QApplication, QLabel, QWidget
from PyQt5.QtCore import Qt, QTimer, QRect, QPoint, QPropertyAnimation, QEasingCurve
from PyQt5.QtGui import QPixmap, QPainter, QFont


class BubbleLabel(QLabel):
    """独立的气泡标签类，避免透明窗口的渲染问题"""
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowFlags(
            Qt.FramelessWindowHint |
            Qt.WindowStaysOnTopHint |
            Qt.Tool
        )
        self.setAttribute(Qt.WA_TranslucentBackground)
        self.setWordWrap(True)
        # 改进气泡样式：更醒目的背景和文字
        self.setStyleSheet("""
            background-color: rgba(255, 248, 220, 240); /* 淡黄色背景，带透明度 */
            border: 2px solid #FFA500; /* 橙色边框 */
            border-radius: 12px;
            padding: 10px;
            color: #2F4F4F; /* 深灰色文字 */
            font-family: "Microsoft YaHei", "SimHei", sans-serif;
            font-size: 11pt;
            font-weight: bold; /* 加粗文字 */
        """)
        self.setFont(QFont("Microsoft YaHei", 11, QFont.Bold))
        self.setAlignment(Qt.AlignCenter)
        self.hide()
        self.pet_ref = None  # 引用桌宠对象，用于位置更新

    def set_pet_reference(self, pet):
        """设置桌宠引用"""
        self.pet_ref = pet

    def update_position(self):
        """更新气泡位置，跟随桌宠"""
        if not self.pet_ref or not self.isVisible():
            return
            
        # 计算气泡位置（在宠物头顶上方）
        pet_x = self.pet_ref.x()
        pet_y = self.pet_ref.y()
        pet_width = self.pet_ref.width()
     
        bubble_width = self.width()
        bubble_height = self.height()
        
        bubble_x = pet_x + (pet_width - bubble_width) // 2
        bubble_y = pet_y - bubble_height - 15
        
        # 获取屏幕尺寸进行边界检查
        screen = QApplication.primaryScreen().geometry()
        bubble_x = max(5, min(bubble_x, screen.width() - bubble_width - 5))
        bubble_y = max(5, bubble_y)
        
        self.move(bubble_x, bubble_y)


class DesktopPet(QWidget):
    def __init__(self):
        super().__init__()
        # 移动相关参数 
        self.edge_margin = 50  # 距离屏幕边缘的安全距离（像素）
        self.moving = False  # 当前是否正在移动
        self.move_animation = None  # 移动动画对象
        
        self.init_ui()
        self.load_config()
        self.setup_behavior()
        self.setup_interaction()
        self.setup_animation()

    def init_ui(self):
        """初始化界面：设置窗口为无边框、透明、置顶"""
        self.setWindowFlags(
            Qt.FramelessWindowHint |        # 无边框窗口
            Qt.WindowStaysOnTopHint |       # 始终置顶
            Qt.SubWindow                    # 子窗口（不在任务栏显示）
        )
        self.setAttribute(Qt.WA_TranslucentBackground)  # 背景透明
        self.setAttribute(Qt.WA_TransparentForMouseEvents, False)  # 接收鼠标事件

        # 创建标签用于显示宠物图像
        self.pet_label = QLabel(self)
        self.pet_label.setAlignment(Qt.AlignCenter)

        # 创建独立的气泡窗口
        self.bubble_label = BubbleLabel()
        self.bubble_label.set_pet_reference(self)  # 设置桌宠引用
        
        # 设置宠物类型为小女孩
        self.current_pet = "girl"
        self.load_pet_sprites()

        # 设置初始大小和位置
        if self.sprite_frames.get("idle"):
            first_frame = self.sprite_frames["idle"][0]
            self.resize(first_frame.width(), first_frame.height())
            self.pet_label.setPixmap(first_frame)
            self.pet_label.resize(first_frame.width(), first_frame.height())
        else:
            self.resize(36, 44)
            self.pet_label.resize(36, 44)
            print("警告：未找到宠物图片，使用默认尺寸")

        # 初始位置：屏幕右下角
        screen_geo = QApplication.primaryScreen().geometry()
        initial_x = screen_geo.width() - self.width() - self.edge_margin
        initial_y = screen_geo.height() - self.height() - self.edge_margin
        self.move(initial_x, initial_y)

    def load_pet_sprites(self):
        """加载宠物精灵图并切割成单帧动画"""
        self.frame_counts = {
            "idle": 8,
            "walk": 6,        # 向左走
            "walk_down": 8,   # 向下走
            "walk_right": 6,  # 向右走
            "walk_up": 8      # 向上走
        }
        
        pet_dir = f"pets/{self.current_pet}"
        if not os.path.exists(pet_dir):
            print(f"警告：宠物资源目录 {pet_dir} 不存在！")
            self.sprite_frames = {}
            return

        self.sprite_frames = {}
        
        for action, frame_count in self.frame_counts.items():
            img_path = os.path.join(pet_dir, f"{action}.png")
            if not os.path.exists(img_path):
                print(f"警告：动作图片 {img_path} 不存在！")
                continue
            
            full_sprite = QPixmap(img_path)
            if full_sprite.isNull():
                print(f"警告：无法加载图片 {img_path}！")
                continue
            
            frame_width = full_sprite.width() // frame_count
            frame_height = full_sprite.height()
            
            frames = []
            for i in range(frame_count):
                frame = QPixmap(frame_width, frame_height)
                frame.fill(Qt.transparent)
                
                painter = QPainter(frame)
                painter.drawPixmap(0, 0, full_sprite, 
                                 i * frame_width, 0,
                                 frame_width, frame_height)
                painter.end()
                
                frames.append(frame)
            
            self.sprite_frames[action] = frames
            print(f"成功加载动作 '{action}'：{frame_count} 帧")

    def load_config(self):
        """加载互动文本配置"""
        config_path = "config/dialogues.json"
        if os.path.exists(config_path):
            with open(config_path, "r", encoding="utf-8") as f:
                self.dialogues = json.load(f)
        else:
            self.dialogues = {
                "click": ["你好呀！点击我有惊喜～"],
                "idle": ["我在发呆...好无聊呀"],
                "walk": ["我去左边看看！"],
                "walk_right": ["右边有什么呢？"],
                "walk_down": ["下面好像有好玩的！"],
                "walk_up": ["上面的风景真好！"],
                "greet": ["主人好！我来陪你啦！"],
                "drag_start": ["哎呀！要带我去哪里？"],
                "drag_end": ["到啦！这里不错～"]
            }

    def setup_interaction(self):
        """设置用户交互：点击、拖拽"""
        self.is_dragging = False
        self.drag_start_pos = QPoint()
        self.mouse_press_pos = QPoint()

    def mousePressEvent(self, event):
        """鼠标按下"""
        if event.button() == Qt.LeftButton:
            # 如果正在自动移动，停止移动
            if self.moving:
                if self.move_animation:
                    self.move_animation.stop()
                self.moving = False
                self.state = "idle"
                self.current_frame_index = 0
            
            self.drag_start_pos = event.globalPos() - self.frameGeometry().topLeft()
            self.mouse_press_pos = event.pos()
            self.is_dragging = False
            event.accept()

    def mouseMoveEvent(self, event):
        """鼠标移动：实现拖拽"""
        if event.buttons() & Qt.LeftButton:
            if not self.is_dragging:
                if (event.pos() - self.mouse_press_pos).manhattanLength() > 5:
                    self.is_dragging = True
                    # 停止自动移动
                    if self.moving:
                        if self.move_animation:
                            self.move_animation.stop()
                        self.moving = False
                        self.state = "idle"
                        self.current_frame_index = 0
                    
                    # 使用随机选择拖拽开始对话
                    drag_start_options = self.dialogues.get("drag_start", ["哎呀！要带我去哪里？"])
                    self.show_bubble(random.choice(drag_start_options))
            
            if self.is_dragging:
                self.move(event.globalPos() - self.drag_start_pos)
                # 更新气泡位置（如果气泡正在显示）
                self.bubble_label.update_position()
                event.accept()

    def mouseReleaseEvent(self, event):
        """鼠标释放：结束拖拽或处理点击"""
        if event.button() == Qt.LeftButton:
            if self.is_dragging:
                self.is_dragging = False
                # 使用随机选择拖拽结束对话
                drag_end_options = self.dialogues.get("drag_end", ["到啦！这里不错～"])
                self.show_bubble(random.choice(drag_end_options))
            else:
                self.show_bubble(random.choice(self.dialogues.get("click", ["不要戳我啦！"])))
            event.accept()

    def setup_behavior(self):
        """设置自主行为"""
        self.state = "idle"
        self.state_timer = QTimer(self)
        self.state_timer.timeout.connect(self.update_state)
        self.state_timer.start(6000)  # 每6秒切换状态

        # 行为权重调整，增加移动行为的概率
        self.behavior_weights = {
            "idle": 25,
            "walk": 20,         # 向左
            "walk_down": 15,    # 向下
            "walk_right": 20,   # 向右
            "walk_up": 20       # 向上
        }

    def setup_animation(self):
        """设置帧动画定时器"""
        self.current_frame_index = 0
        self.animation_timer = QTimer(self)
        self.animation_timer.timeout.connect(self.update_animation_frame)
        self.animation_timer.start(120)  # 约8帧/秒

        # 添加位置更新定时器，用于自动移动时更新气泡位置
        self.position_update_timer = QTimer(self)
        self.position_update_timer.timeout.connect(self.update_bubble_position)
        self.position_update_timer.start(50)  # 每50ms更新一次位置

    def update_bubble_position(self):
        """定时更新气泡位置（用于动画移动时）"""
        if self.bubble_label.isVisible():
            self.bubble_label.update_position()

    def update_state(self):
        """根据权重随机切换状态，并触发移动"""
        if self.moving or self.is_dragging:
            return  # 如果正在移动或被拖拽，不切换状态
            
        states = list(self.behavior_weights.keys())
        weights = list(self.behavior_weights.values())
        new_state = random.choices(states, weights=weights, k=1)[0]
        
        if new_state != self.state:
            self.state = new_state
            self.current_frame_index = 0
            
            # 显示状态对话
            if self.state == "idle":
                self.show_bubble(random.choice(self.dialogues.get("idle", ["我在发呆..."])))
            elif self.state in self.dialogues:
                self.show_bubble(random.choice(self.dialogues[self.state]))
            else:
                # 如果没有特定对话，使用通用walk对话
                self.show_bubble(random.choice(self.dialogues.get("walk", ["我去散步啦！"])))
            
            # 如果是移动状态，开始移动
            if self.state != "idle":
                self.start_moving()

    def start_moving(self):
        """开始向指定方向移动"""
        if self.moving:
            return
            
        self.moving = True
        screen = QApplication.primaryScreen().geometry()
        
        # 获取当前位置
        current_x = self.x()
        current_y = self.y()
        pet_width = self.width()
        pet_height = self.height()
        
        # 计算移动目标位置
        move_distance = random.randint(80, 150)  # 随机移动距离
        
        if self.state == "walk":  # 向左
            target_x = current_x - move_distance
            target_y = current_y
        elif self.state == "walk_right":  # 向右
            target_x = current_x + move_distance
            target_y = current_y
        elif self.state == "walk_down":  # 向下
            target_x = current_x
            target_y = current_y + move_distance
        elif self.state == "walk_up":  # 向上
            target_x = current_x
            target_y = current_y - move_distance
        else:
            self.moving = False
            return
        
        # 边界检查：确保目标位置在安全范围内
        min_x = self.edge_margin
        max_x = screen.width() - pet_width - self.edge_margin
        min_y = self.edge_margin
        max_y = screen.height() - pet_height - self.edge_margin
        
        target_x = max(min_x, min(target_x, max_x))
        target_y = max(min_y, min(target_y, max_y))
        
        # 如果目标位置和当前位置相同，说明被边界限制了，切换回idle
        if abs(target_x - current_x) < 5 and abs(target_y - current_y) < 5:
            self.moving = False
            self.state = "idle"
            self.current_frame_index = 0
            return
        
        # 创建移动动画
        self.move_animation = QPropertyAnimation(self, b"geometry")
        self.move_animation.setDuration(2000)  # 2秒移动完成
        self.move_animation.setStartValue(QRect(current_x, current_y, pet_width, pet_height))
        self.move_animation.setEndValue(QRect(target_x, target_y, pet_width, pet_height))
        self.move_animation.setEasingCurve(QEasingCurve.InOutQuad)
        
        # 动画结束时的回调
        self.move_animation.finished.connect(self.on_move_finished)
        self.move_animation.start()

    def on_move_finished(self):
        """移动完成后的回调"""
        self.moving = False
        self.move_animation = None
        # 移动完成后自动切换回idle状态
        self.state = "idle"
        self.current_frame_index = 0

    def update_animation_frame(self):
        """更新当前显示的动画帧"""
        frames = self.sprite_frames.get(self.state, [])
        if not frames:
            frames = self.sprite_frames.get("idle", [])
            if not frames:
                return
        
        self.current_frame_index = (self.current_frame_index + 1) % len(frames)
        current_frame = frames[self.current_frame_index]
        
        self.pet_label.setPixmap(current_frame)
        self.pet_label.resize(current_frame.width(), current_frame.height())

    def show_bubble(self, text):
        """显示对话气泡"""
        if not text or not text.strip():
            return

        # 设置气泡文本
        self.bubble_label.setText(text)
        self.bubble_label.adjustSize()
        
        # 确保气泡尺寸合理
        bubble_width = max(80, min(self.bubble_label.width(), 220))
        bubble_height = self.bubble_label.height()
        
        # 重新设置尺寸
        self.bubble_label.resize(bubble_width, bubble_height)
        self.bubble_label.setText(text)
        
        # 初始位置设置
        self.bubble_label.update_position()
        self.bubble_label.show()
        
        # 2秒后隐藏
        QTimer.singleShot(2000, self.bubble_label.hide)


if __name__ == "__main__":
    app = QApplication(sys.argv)
    app.setQuitOnLastWindowClosed(False)

    pet = DesktopPet()
    pet.show()

    # 启动欢迎语
    QTimer.singleShot(1000, lambda: pet.show_bubble(
        random.choice(pet.dialogues.get("greet", ["你好！"]))
    ))

    sys.exit(app.exec_())