import tkinter as tk
from tkinter import ttk, colorchooser
import random
import math
import time
import colorsys

class DarkFireworkApp:
    def __init__(self, root):
        self.root = root
        self.root.title("🖤 重色烟花模拟器 - 暗夜魅影")
        self.root.geometry("1200x800")
        self.root.configure(bg='#0A0A0A')  # 纯黑色背景
        
        # 重色配色方案
        self.dark_colors = [
            '#000000',  # 纯黑
            '#1A1A2E',  # 深蓝黑
            '#16213E',  # 午夜蓝
            '#0F3460',  # 深海蓝
            '#533483',  # 深紫
            '#4A235A',  # 葡萄紫
            '#641E16',  # 深褐红
            '#512E5F',  # 紫黑
            '#1B2631',  # 钢灰
            '#2C3E50',  # 湿沥青
            '#273746',  # 深灰蓝
            '#1C2833',  # 深蓝灰
            '#212F3C',  # 深蓝
            '#283747',  # 石墨
            '#2E4053',  # 深蓝
        ]
        
        # 亮色点缀
        self.accent_colors = [
            '#E74C3C',  # 深红
            '#C0392B',  # 深红
            '#8E44AD',  # 紫色
            '#9B59B6',  # 紫色
            '#2980B9',  # 深蓝
            '#3498DB',  # 蓝色
            '#2ECC71',  # 深绿
            '#27AE60',  # 绿色
            '#F1C40F',  # 金色
            '#F39C12',  # 橙色
        ]
        
        # 粒子系统
        self.particles = []
        self.fireworks = []
        self.sparks = []
        
        # 当前颜色
        self.current_color = '#000000'
        self.current_accent = '#E74C3C'
        self.dark_mode = True
        
        # 动画控制
        self.animating = True
        self.last_time = time.time()
        
        # 创建界面
        self.setup_ui()
        
        # 开始动画
        self.root.after(100, self.animate)
    
    def setup_ui(self):
        """创建暗黑风格界面"""
        # 主画布
        self.canvas = tk.Canvas(
            self.root,
            bg='#0A0A0A',
            highlightthickness=0
        )
        self.canvas.pack(fill=tk.BOTH, expand=True)
        
        # 创建渐变背景
        self.create_gradient_background()
        
        # 标题
        title = self.canvas.create_text(
            600, 40,
            text="🖤 重色烟花模拟器 | 暗夜魅影 🌌",
            font=('Microsoft YaHei', 28, 'bold'),
            fill='#E0E0E0',
            tags='title'
        )
        
        # 控制面板
        self.create_control_panel()
        
        # 绑定事件
        self.canvas.bind('<Button-1>', self.on_canvas_click)
        self.canvas.bind('<B1-Motion>', self.on_canvas_drag)
        
        # 初始发射几朵烟花
        self.root.after(500, self.launch_initial_fireworks)
    
    def create_gradient_background(self):
        """创建渐变背景"""
        for i in range(0, 800, 5):
            # 从深黑到暗蓝的渐变
            intensity = 5 + int(10 * (i / 800))
            color = f'#0{intensity:02x}1{intensity:02x}2{intensity:02x}'
            self.canvas.create_line(0, i, 1200, i, fill=color, width=5)
        
        # 添加一些暗色星星
        for _ in range(50):
            x = random.randint(0, 1200)
            y = random.randint(0, 800)
            size = random.uniform(0.3, 1.2)
            brightness = random.uniform(0.3, 0.7)
            color = f'#{int(brightness*40):02x}{int(brightness*60):02x}{int(brightness*80):02x}'
            self.canvas.create_oval(
                x - size, y - size,
                x + size, y + size,
                fill=color, outline='',
                tags='star'
            )
    
    def create_control_panel(self):
        """创建控制面板"""
        # 控制面板背景
        self.canvas.create_rectangle(
            20, 100, 320, 500,
            fill='#1A1A1A',
            outline='#333333',
            width=2,
            tags='control_bg'
        )
        
        # 控制面板标题
        self.canvas.create_text(
            170, 130,
            text="⚙️ 控制面板",
            font=('Microsoft YaHei', 16, 'bold'),
            fill='#E0E0E0',
            tags='controls_title'
        )
        
        y = 170
        
        # 颜色选择标签
        self.canvas.create_text(
            50, y,
            text="主色:",
            font=('Microsoft YaHei', 12),
            fill='#CCCCCC',
            anchor='w',
            tags='color_label'
        )
        
        # 当前颜色显示
        self.color_display = self.canvas.create_rectangle(
            100, y - 10, 140, y + 10,
            fill=self.current_color,
            outline='#666666',
            width=1,
            tags='color_display'
        )
        
        # 颜色选择按钮
        self.canvas.create_rectangle(
            150, y - 15, 250, y + 15,
            fill='#333333',
            outline='#666666',
            width=1,
            tags='color_btn_bg'
        )
        
        self.canvas.create_text(
            200, y,
            text="🎨 选择主色",
            font=('Microsoft YaHei', 10),
            fill='#CCCCCC',
            tags='color_btn'
        )
        
        self.canvas.tag_bind('color_btn', '<Button-1>', lambda e: self.choose_main_color())
        self.canvas.tag_bind('color_btn_bg', '<Button-1>', lambda e: self.choose_main_color())
        
        y += 40
        
        # 点缀色选择
        self.canvas.create_text(
            50, y,
            text="点缀:",
            font=('Microsoft YaHei', 12),
            fill='#CCCCCC',
            anchor='w',
            tags='accent_label'
        )
        
        self.accent_display = self.canvas.create_rectangle(
            100, y - 10, 140, y + 10,
            fill=self.current_accent,
            outline='#666666',
            width=1,
            tags='accent_display'
        )
        
        self.canvas.create_rectangle(
            150, y - 15, 250, y + 15,
            fill='#333333',
            outline='#666666',
            width=1,
            tags='accent_btn_bg'
        )
        
        self.canvas.create_text(
            200, y,
            text="✨ 选择点缀",
            font=('Microsoft YaHei', 10),
            fill='#CCCCCC',
            tags='accent_btn'
        )
        
        self.canvas.tag_bind('accent_btn', '<Button-1>', lambda e: self.choose_accent_color())
        self.canvas.tag_bind('accent_btn_bg', '<Button-1>', lambda e: self.choose_accent_color())
        
        y += 50
        
        # 预设按钮
        presets = [
            ("⚫ 纯黑风暴", '#000000', '#E74C3C'),
            ("🌌 暗夜星空", '#1A1A2E', '#9B59B6'),
            ("🟣 深紫魅影", '#4A235A', '#F1C40F'),
            ("🔴 暗红血月", '#641E16', '#FFFFFF'),
            ("🔵 深海幽蓝", '#0F3460', '#2ECC71'),
        ]
        
        for i, (name, main, accent) in enumerate(presets):
            btn_y = y + i * 35
            self.canvas.create_rectangle(
                50, btn_y - 15, 250, btn_y + 15,
                fill='#2C3E50',
                outline='#34495E',
                width=1,
                tags=f'preset_bg_{i}'
            )
            
            self.canvas.create_text(
                150, btn_y,
                text=name,
                font=('Microsoft YaHei', 10),
                fill='#ECF0F1',
                tags=f'preset_{i}'
            )
            
            self.canvas.tag_bind(f'preset_{i}', '<Button-1>', 
                                lambda e, m=main, a=accent: self.set_preset(m, a))
            self.canvas.tag_bind(f'preset_bg_{i}', '<Button-1>', 
                                lambda e, m=main, a=accent: self.set_preset(m, a))
        
        y += len(presets) * 35 + 20
        
        # 全屏爆发按钮
        self.canvas.create_rectangle(
            50, y - 15, 250, y + 15,
            fill='#C0392B',
            outline='#E74C3C',
            width=1,
            tags='burst_bg'
        )
        
        self.canvas.create_text(
            150, y,
            text="💥 暗黑爆发",
            font=('Microsoft YaHei', 12, 'bold'),
            fill='white',
            tags='burst_btn'
        )
        
        self.canvas.tag_bind('burst_btn', '<Button-1>', self.fullscreen_burst)
        self.canvas.tag_bind('burst_bg', '<Button-1>', self.fullscreen_burst)
        
        y += 40
        
        # 清空按钮
        self.canvas.create_rectangle(
            50, y - 15, 150, y + 15,
            fill='#7F8C8D',
            outline='#95A5A6',
            width=1,
            tags='clear_bg'
        )
        
        self.canvas.create_text(
            100, y,
            text="🧹 清空",
            font=('Microsoft YaHei', 10),
            fill='white',
            tags='clear_btn'
        )
        
        self.canvas.tag_bind('clear_btn', '<Button-1>', self.clear_fireworks)
        self.canvas.tag_bind('clear_bg', '<Button-1>', self.clear_fireworks)
        
        # 自动模式按钮
        self.auto_mode = False
        self.canvas.create_rectangle(
            170, y - 15, 270, y + 15,
            fill='#16A085',
            outline='#1ABC9C',
            width=1,
            tags='auto_bg'
        )
        
        self.auto_text = self.canvas.create_text(
            220, y,
            text="🤖 自动: 关",
            font=('Microsoft YaHei', 10),
            fill='white',
            tags='auto_btn'
        )
        
        self.canvas.tag_bind('auto_btn', '<Button-1>', self.toggle_auto_mode)
        self.canvas.tag_bind('auto_bg', '<Button-1>', self.toggle_auto_mode)
        
        # 状态信息
        self.status_text = self.canvas.create_text(
            600, 770,
            text="点击任意位置发射重色烟花 | 当前: 纯黑",
            font=('Microsoft YaHei', 10),
            fill='#95A5A6',
            tags='status_text'
        )
    
    def launch_initial_fireworks(self):
        """发射初始烟花"""
        for _ in range(3):
            x = random.randint(400, 800)
            y = 800
            target_y = random.randint(200, 500)
            
            self.fireworks.append({
                'x': x, 'y': y,
                'vx': random.uniform(-0.5, 0.5),
                'vy': -random.uniform(6, 9),
                'target_y': target_y,
                'main_color': '#000000',
                'accent_color': '#E74C3C',
                'size': random.uniform(3, 6),
                'count': random.randint(150, 250),
                'type': random.choice(['dark_circle', 'dark_star', 'smoke']),
                'exploded': False
            })
    
    def on_canvas_click(self, event):
        """画布点击事件"""
        if 20 <= event.x <= 320 and 100 <= event.y <= 500:
            return
        
        x, y = event.x, event.y
        
        self.fireworks.append({
            'x': x, 'y': 800,
            'vx': random.uniform(-1.5, 1.5),
            'vy': -random.uniform(6, 10),
            'target_y': y,
            'main_color': self.current_color,
            'accent_color': self.current_accent,
            'size': random.uniform(3, 7),
            'count': random.randint(150, 300),
            'type': random.choice(['dark_circle', 'dark_star', 'smoke', 'glow']),
            'exploded': False
        })
    
    def on_canvas_drag(self, event):
        """画布拖拽事件 - 绘制烟花轨迹"""
        if random.random() < 0.3:
            x, y = event.x, event.y
            
            # 创建拖尾火花
            for _ in range(3):
                angle = random.uniform(0, 2 * math.pi)
                speed = random.uniform(1, 3)
                vx = math.cos(angle) * speed
                vy = math.sin(angle) * speed
                
                self.sparks.append({
                    'x': x, 'y': y,
                    'vx': vx, 'vy': vy,
                    'color': self.current_color,
                    'size': random.uniform(0.5, 2),
                    'life': 1.0,
                    'decay': random.uniform(0.02, 0.05)
                })
    
    def choose_main_color(self):
        """选择主色"""
        color = colorchooser.askcolor(title="选择主色（暗色）", initialcolor=self.current_color)[1]
        if color:
            self.current_color = color
            self.canvas.itemconfig('color_display', fill=color)
            self.update_status(f"主色已设为: {color}")
    
    def choose_accent_color(self):
        """选择点缀色"""
        color = colorchooser.askcolor(title="选择点缀色", initialcolor=self.current_accent)[1]
        if color:
            self.current_accent = color
            self.canvas.itemconfig('accent_display', fill=color)
            self.update_status(f"点缀色已设为: {color}")
    
    def set_preset(self, main_color, accent_color):
        """设置预设"""
        self.current_color = main_color
        self.current_accent = accent_color
        self.canvas.itemconfig('color_display', fill=main_color)
        self.canvas.itemconfig('accent_display', fill=accent_color)
        
        # 根据预设名称更新状态
        if main_color == '#000000':
            self.update_status("预设: 纯黑风暴")
        elif main_color == '#1A1A2E':
            self.update_status("预设: 暗夜星空")
        elif main_color == '#4A235A':
            self.update_status("预设: 深紫魅影")
        elif main_color == '#641E16':
            self.update_status("预设: 暗红血月")
        elif main_color == '#0F3460':
            self.update_status("预设: 深海幽蓝")
    
    def fullscreen_burst(self, event=None):
        """全屏爆发"""
        for _ in range(15):
            x = random.randint(0, 1200)
            y = random.randint(0, 800)
            
            # 创建大规模爆炸
            for _ in range(3):
                self.explode_firework(
                    x + random.randint(-50, 50),
                    y + random.randint(-50, 50),
                    self.current_color,
                    self.current_accent,
                    random.uniform(4, 8),
                    random.randint(200, 400),
                    random.choice(['dark_circle', 'smoke', 'glow'])
                )
        
        self.update_status("💥 暗黑全屏爆发！")
    
    def clear_fireworks(self, event=None):
        """清空烟花"""
        self.fireworks.clear()
        self.particles.clear()
        self.sparks.clear()
        self.update_status("已清空所有烟花")
    
    def toggle_auto_mode(self, event=None):
        """切换自动模式"""
        self.auto_mode = not self.auto_mode
        status = "开" if self.auto_mode else "关"
        self.canvas.itemconfig('auto_btn', text=f"🤖 自动: {status}")
        
        if self.auto_mode:
            self.start_auto_launch()
    
    def start_auto_launch(self):
        """启动自动发射"""
        if self.auto_mode:
            # 随机发射烟花
            if random.random() < 0.3 and len(self.fireworks) < 10:
                x = random.randint(400, 800)
                y = 800
                target_y = random.randint(200, 500)
                
                self.fireworks.append({
                    'x': x, 'y': y,
                    'vx': random.uniform(-1, 1),
                    'vy': -random.uniform(6, 9),
                    'target_y': target_y,
                    'main_color': self.current_color,
                    'accent_color': self.current_accent,
                    'size': random.uniform(3, 6),
                    'count': random.randint(150, 250),
                    'type': random.choice(['dark_circle', 'dark_star', 'smoke']),
                    'exploded': False
                })
            
            # 继续自动发射
            self.root.after(random.randint(500, 2000), self.start_auto_launch)
    
    def update_status(self, text):
        """更新状态信息"""
        self.canvas.itemconfig('status_text', text=text)
    
    def explode_firework(self, x, y, main_color, accent_color, size, count, type_):
        """烟花爆炸效果 - 重色版本"""
        for _ in range(count):
            angle = random.uniform(0, 2 * math.pi)
            speed = random.uniform(1, 10)
            vx = math.cos(angle) * speed
            vy = math.sin(angle) * speed
            
            # 随机选择使用主色或点缀色
            if random.random() < 0.7:  # 70%概率使用主色
                particle_color = main_color
            else:  # 30%概率使用点缀色
                particle_color = accent_color
            
            life = random.uniform(0.8, 2.0)
            decay = random.uniform(0.005, 0.02)
            
            particle = {
                'x': x, 'y': y,
                'vx': vx, 'vy': vy,
                'ax': 0, 'ay': 0.15,  # 较轻的重力
                'color': particle_color,
                'size': random.uniform(size * 0.3, size * 1.2),
                'life': life,
                'decay': decay,
                'type': type_,
                'rotation': random.uniform(0, 360),
                'rotation_speed': random.uniform(-3, 3),
                'glow': random.random() < 0.3  # 30%概率有光晕
            }
            self.particles.append(particle)
        
        # 添加烟雾效果
        if type_ in ['smoke', 'glow']:
            for _ in range(count // 2):
                self.create_smoke(x, y, main_color)
    
    def create_smoke(self, x, y, color):
        """创建烟雾效果"""
        angle = random.uniform(0, 2 * math.pi)
        speed = random.uniform(0.5, 3)
        vx = math.cos(angle) * speed
        vy = math.sin(angle) * speed
        
        # 烟雾使用更浅的颜色
        r, g, b = int(color[1:3], 16), int(color[3:5], 16), int(color[5:7], 16)
        r = min(255, r + 30)
        g = min(255, g + 30)
        b = min(255, b + 30)
        smoke_color = f'#{r:02x}{g:02x}{b:02x}'
        
        self.particles.append({
            'x': x, 'y': y,
            'vx': vx, 'vy': vy,
            'ax': 0, 'ay': -0.05,  # 烟雾上升
            'color': smoke_color,
            'size': random.uniform(3, 8),
            'life': random.uniform(1.5, 3.0),
            'decay': random.uniform(0.01, 0.03),
            'type': 'smoke',
            'rotation': 0,
            'rotation_speed': 0,
            'glow': False
        })
    
    def draw_dark_particle(self, particle):
        """绘制重色粒子"""
        x, y = particle['x'], particle['y']
        size = particle['size'] * particle['life']
        color = particle['color']
        
        if particle['type'] == 'dark_circle':
            # 暗色圆形粒子
            if particle.get('glow'):
                # 有光晕效果
                glow_size = size * 1.5
                r, g, b = int(color[1:3], 16), int(color[3:5], 16), int(color[5:7], 16)
                glow_color = f'#{max(0, r-20):02x}{max(0, g-20):02x}{max(0, b-20):02x}'
                self.canvas.create_oval(
                    x - glow_size, y - glow_size,
                    x + glow_size, y + glow_size,
                    fill=glow_color, outline='',
                    tags='particle'
                )
            
            return self.canvas.create_oval(
                x - size, y - size,
                x + size, y + size,
                fill=color, outline='',
                tags='particle'
            )
        
        elif particle['type'] == 'dark_star':
            # 暗色星形
            points = []
            star_size = size * 1.2
            for i in range(5):
                angle = math.radians(particle['rotation'] + 72 * i)
                px = x + math.cos(angle) * star_size
                py = y + math.sin(angle) * star_size
                points.extend([px, py])
                
                angle2 = math.radians(particle['rotation'] + 72 * i + 36)
                px2 = x + math.cos(angle2) * star_size * 0.4
                py2 = y + math.sin(angle2) * star_size * 0.4
                points.extend([px2, py2])
            
            return self.canvas.create_polygon(
                points,
                fill=color, outline='',
                tags='particle'
            )
        
        elif particle['type'] == 'smoke':
            # 烟雾效果
            smoke_size = size * (1 + 0.3 * math.sin(time.time() * 2))
            return self.canvas.create_oval(
                x - smoke_size, y - smoke_size,
                x + smoke_size, y + smoke_size,
                fill=color, outline='',
                tags='particle'
            )
        
        else:  # glow
            # 发光效果
            glow_size = size * (1 + 0.2 * math.sin(time.time() * 3))
            return self.canvas.create_oval(
                x - glow_size, y - glow_size,
                x + glow_size, y + glow_size,
                fill=color, outline='',
                tags='particle'
            )
    
    def animate(self):
        """动画循环"""
        current_time = time.time()
        
        # 清除上一帧
        self.canvas.delete('particle')
        self.canvas.delete('firework')
        self.canvas.delete('spark')
        
        # 更新烟花
        for fw in self.fireworks[:]:
            fw['x'] += fw['vx']
            fw['y'] += fw['vy']
            
            if not fw['exploded']:
                # 绘制上升的烟花
                trail_color = fw['main_color']
                
                # 轨迹
                for i in range(5):
                    trail_x = fw['x'] - fw['vx'] * i * 0.4
                    trail_y = fw['y'] - fw['vy'] * i * 0.4
                    trail_size = fw['size'] * (1 - i * 0.3)
                    
                    self.canvas.create_oval(
                        trail_x - trail_size, trail_y - trail_size,
                        trail_x + trail_size, trail_y + trail_size,
                        fill=trail_color, outline='',
                        tags='firework'
                    )
                
                # 烟花主体
                if fw['type'] == 'glow':
                    # 发光主体
                    glow_size = fw['size'] * 1.5
                    self.canvas.create_oval(
                        fw['x'] - glow_size, fw['y'] - glow_size,
                        fw['x'] + glow_size, fw['y'] + glow_size,
                        fill=fw['accent_color'], outline='',
                        tags='firework'
                    )
                
                self.canvas.create_oval(
                    fw['x'] - fw['size'], fw['y'] - fw['size'],
                    fw['x'] + fw['size'], fw['y'] + fw['size'],
                    fill=fw['main_color'], outline='#444444',
                    width=1, tags='firework'
                )
                
                # 检查是否需要爆炸
                if fw['y'] <= fw['target_y']:
                    fw['exploded'] = True
                    self.explode_firework(
                        fw['x'], fw['y'], 
                        fw['main_color'], fw['accent_color'],
                        fw['size'], fw['count'], fw['type']
                    )
            else:
                self.fireworks.remove(fw)
        
        # 更新粒子
        for particle in self.particles[:]:
            particle['vx'] += particle['ax']
            particle['vy'] += particle['ay']
            particle['x'] += particle['vx']
            particle['y'] += particle['vy']
            
            particle['life'] -= particle['decay']
            particle['rotation'] += particle['rotation_speed']
            
            if particle['life'] <= 0:
                self.particles.remove(particle)
                continue
            
            self.draw_dark_particle(particle)
            
            # 拖尾效果
            if random.random() < 0.4:
                trail_size = particle['size'] * particle['life'] * 0.3
                trail_x = particle['x'] - particle['vx'] * 0.5
                trail_y = particle['y'] - particle['vy'] * 0.5
                
                self.canvas.create_oval(
                    trail_x - trail_size, trail_y - trail_size,
                    trail_x + trail_size, trail_y + trail_size,
                    fill=particle['color'], outline='',
                    tags='particle'
                )
        
        # 更新火花
        for spark in self.sparks[:]:
            spark['x'] += spark['vx']
            spark['y'] += spark['vy']
            spark['life'] -= spark['decay']
            
            if spark['life'] <= 0:
                self.sparks.remove(spark)
                continue
            
            size = spark['size'] * spark['life']
            self.canvas.create_oval(
                spark['x'] - size, spark['y'] - size,
                spark['x'] + size, spark['y'] + size,
                fill=spark['color'], outline='',
                tags='spark'
            )
        
        # 更新状态
        status = f"🎆 活跃烟花: {len(self.fireworks)} ✨ 活跃粒子: {len(self.particles)}"
        self.canvas.itemconfig('status_text', text=status)
        
        # 下一帧
        if self.animating:
            self.root.after(16, self.animate)

def main():
    """主函数"""
    print("="*60)
    print("🖤 重色烟花模拟器 v1.0")
    print("="*60)
    print("特色功能:")
    print("⚫ 暗黑系配色 - 黑、深蓝、深紫、暗红等重色")
    print("🌌 渐变背景 - 从深黑到暗蓝的渐变夜空")
    print("✨ 双色系统 - 主色 + 点缀色组合")
    print("💥 特效丰富 - 烟雾、光晕、星形、圆形等多种效果")
    print("🎮 交互多样 - 点击发射、拖拽轨迹、自动模式")
    print("🎨 预设丰富 - 5种精心设计的重色预设")
    print("="*60)
    print("使用说明:")
    print("1. 点击画布任意位置发射重色烟花")
    print("2. 在画布上拖拽鼠标绘制烟花轨迹")
    print("3. 使用预设或自定义颜色")
    print("4. 点击'💥暗黑爆发'观看全屏效果")
    print("5. 开启'🤖自动'模式自动发射")
    print("6. 点击'🧹清空'清除所有效果")
    print("="*60)
    print("程序启动中...")
    
    root = tk.Tk()
    app = DarkFireworkApp(root)
    root.mainloop()

if __name__ == "__main__":
    main()