import pygame
import sys
import time
import json
import os

# 初始化pygame
pygame.init()

# 设置窗口尺寸
WIDTH, HEIGHT = 900, 700
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("PyTranslate - 多语言翻译工具")

# 颜色定义
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
GRAY = (200, 200, 200)
LIGHT_GRAY = (240, 240, 240)
BLUE = (30, 144, 255)
DARK_BLUE = (25, 25, 112)
LIGHT_BLUE = (173, 216, 230)
GREEN = (50, 205, 50)
RED = (220, 20, 60)
ORANGE = (255, 165, 0)
PURPLE = (138, 43, 226)

# 字体
font_small = pygame.font.SysFont(None, 28)
font_medium = pygame.font.SysFont(None, 32)
font_large = pygame.font.SysFont(None, 48)
font_title = pygame.font.SysFont(None, 60, bold=True)

# 模拟翻译函数（实际使用时可以替换为真实API）
def translate_text(text, source_lang, target_lang):
    """
    模拟翻译函数
    在实际应用中，这里会调用翻译API（如Google Translate，百度翻译等）
    """
    # 模拟网络延迟
    time.sleep(0.1)
    
    # 模拟翻译结果
    translations = {
        "hello": {
            "zh": "你好",
            "es": "Hola",
            "fr": "Bonjour",
            "de": "Hallo",
            "ja": "こんにちは",
            "ko": "안녕하세요",
            "ru": "Привет"
        },
        "good morning": {
            "zh": "早上好",
            "es": "Buenos días",
            "fr": "Bonjour",
            "de": "Guten Morgen",
            "ja": "おはようございます",
            "ko": "좋은 아침",
            "ru": "Доброе утро"
        },
        "thank you": {
            "zh": "谢谢",
            "es": "Gracias",
            "fr": "Merci",
            "de": "Danke",
            "ja": "ありがとう",
            "ko": "감사합니다",
            "ru": "Спасибо"
        },
        "how are you": {
            "zh": "你好吗",
            "es": "¿Cómo estás?",
            "fr": "Comment allez-vous?",
            "de": "Wie geht es dir?",
            "ja": "お元気ですか",
            "ko": "어떻게 지내세요?",
            "ru": "Как дела?"
        },
        "goodbye": {
            "zh": "再见",
            "es": "Adiós",
            "fr": "Au revoir",
            "de": "Auf Wiedersehen",
            "ja": "さようなら",
            "ko": "안녕히 가세요",
            "ru": "До свидания"
        },
        "i love programming": {
            "zh": "我爱编程",
            "es": "Me encanta programar",
            "fr": "J'adore programmer",
            "de": "Ich liebe Programmieren",
            "ja": "プログラミングが大好きです",
            "ko": "나는 프로그래밍을 사랑합니다",
            "ru": "Я люблю программировать"
        }
    }
    
    # 检查是否有预设翻译
    text_lower = text.strip().lower()
    if text_lower in translations and target_lang in translations[text_lower]:
        return translations[text_lower][target_lang]
    
    # 否则生成模拟翻译
    # 在实际应用中，这里应该调用真正的翻译API
    lang_names = {
        "zh": "中文", "es": "西班牙语", "fr": "法语", 
        "de": "德语", "ja": "日语", "ko": "韩语", "ru": "俄语"
    }
    
    # 返回模拟翻译结果
    return f"[{lang_names.get(target_lang, target_lang)}翻译]: {text}"

# 语言数据
languages = [
    {"code": "auto", "name": "自动检测", "flag": "🌐"},
    {"code": "zh", "name": "中文", "flag": "🇨🇳"},
    {"code": "en", "name": "英语", "flag": "🇺🇸"},
    {"code": "es", "name": "西班牙语", "flag": "🇪🇸"},
    {"code": "fr", "name": "法语", "flag": "🇫🇷"},
    {"code": "de", "name": "德语", "flag": "🇩🇪"},
    {"code": "ja", "name": "日语", "flag": "🇯🇵"},
    {"code": "ko", "name": "韩语", "flag": "🇰🇷"},
    {"code": "ru", "name": "俄语", "flag": "🇷🇺"},
    {"code": "ar", "name": "阿拉伯语", "flag": "🇸🇦"},
    {"code": "pt", "name": "葡萄牙语", "flag": "🇵🇹"},
    {"code": "it", "name": "意大利语", "flag": "🇮🇹"},
]

# 翻译历史记录
translation_history = []

# 输入框类
class InputBox:
    def __init__(self, x, y, w, h, text='', max_chars=500, is_source=True):
        self.rect = pygame.Rect(x, y, w, h)
        self.color = LIGHT_GRAY
        self.text = text
        self.font = pygame.font.SysFont(None, 32)
        self.active = False
        self.max_chars = max_chars
        self.is_source = is_source  # 是否为源语言输入框
        self.cursor_visible = True
        self.cursor_timer = 0
        
    def handle_event(self, event):
        if event.type == pygame.MOUSEBUTTONDOWN:
            # 如果点击了输入框，激活它
            if self.rect.collidepoint(event.pos):
                self.active = True
                self.color = WHITE
            else:
                self.active = False
                self.color = LIGHT_GRAY
                
        if event.type == pygame.KEYDOWN:
            if self.active:
                if event.key == pygame.K_RETURN:
                    return True  # 表示按下了回车
                elif event.key == pygame.K_BACKSPACE:
                    self.text = self.text[:-1]
                else:
                    # 限制输入字符数
                    if len(self.text) < self.max_chars:
                        self.text += event.unicode
        return False
    
    def update(self):
        # 光标闪烁效果
        self.cursor_timer += 1
        if self.cursor_timer >= 30:  # 每30帧切换一次
            self.cursor_visible = not self.cursor_visible
            self.cursor_timer = 0
            
    def draw(self, surface):
        # 绘制输入框背景
        pygame.draw.rect(surface, self.color, self.rect, border_radius=10)
        pygame.draw.rect(surface, BLACK, self.rect, 2, border_radius=10)
        
        # 绘制文本
        text_surface = self.font.render(self.text, True, BLACK)
        surface.blit(text_surface, (self.rect.x + 10, self.rect.y + 10))
        
        # 如果输入框为空且不活跃，显示提示文本
        if self.text == '' and not self.active:
            hint_text = "在此输入要翻译的文本..." if self.is_source else "翻译结果将显示在这里..."
            hint_surface = self.font.render(hint_text, True, (150, 150, 150))
            surface.blit(hint_surface, (self.rect.x + 10, self.rect.y + 10))
        
        # 绘制光标（如果活跃且光标可见）
        if self.active and self.cursor_visible:
            cursor_x = self.rect.x + 10 + text_surface.get_width()
            cursor_rect = pygame.Rect(cursor_x, self.rect.y + 10, 2, self.font.get_height())
            pygame.draw.rect(surface, BLACK, cursor_rect)

# 按钮类
class Button:
    def __init__(self, x, y, w, h, text, color=BLUE, hover_color=DARK_BLUE):
        self.rect = pygame.Rect(x, y, w, h)
        self.text = text
        self.color = color
        self.hover_color = hover_color
        self.current_color = color
        self.font = font_medium
        
    def handle_event(self, event):
        if event.type == pygame.MOUSEMOTION:
            if self.rect.collidepoint(event.pos):
                self.current_color = self.hover_color
            else:
                self.current_color = self.color
                
        if event.type == pygame.MOUSEBUTTONDOWN:
            if self.rect.collidepoint(event.pos):
                return True
        return False
    
    def draw(self, surface):
        pygame.draw.rect(surface, self.current_color, self.rect, border_radius=10)
        pygame.draw.rect(surface, BLACK, self.rect, 2, border_radius=10)
        
        text_surface = self.font.render(self.text, True, WHITE)
        text_rect = text_surface.get_rect(center=self.rect.center)
        surface.blit(text_surface, text_rect)

# 语言选择按钮类
class LanguageButton:
    def __init__(self, x, y, w, h, language):
        self.rect = pygame.Rect(x, y, w, h)
        self.language = language
        self.selected = False
        self.font = pygame.font.SysFont(None, 24)
        
    def handle_event(self, event):
        if event.type == pygame.MOUSEBUTTONDOWN:
            if self.rect.collidepoint(event.pos):
                return True
        return False
    
    def draw(self, surface):
        # 绘制按钮背景
        if self.selected:
            pygame.draw.rect(surface, LIGHT_BLUE, self.rect, border_radius=8)
            pygame.draw.rect(surface, BLUE, self.rect, 2, border_radius=8)
        else:
            pygame.draw.rect(surface, LIGHT_GRAY, self.rect, border_radius=8)
            pygame.draw.rect(surface, GRAY, self.rect, 2, border_radius=8)
        
        # 绘制语言信息
        flag_text = self.font.render(self.language["flag"], True, BLACK)
        surface.blit(flag_text, (self.rect.x + 10, self.rect.y + 5))
        
        lang_text = self.font.render(self.language["name"], True, BLACK)
        surface.blit(lang_text, (self.rect.x + 50, self.rect.y + 5))

# 历史记录条目类
class HistoryItem:
    def __init__(self, source_text, translated_text, source_lang, target_lang):
        self.source_text = source_text
        self.translated_text = translated_text
        self.source_lang = source_lang
        self.target_lang = target_lang
        self.time = time.strftime("%H:%M:%S")
        
    def draw(self, surface, x, y, width):
        # 创建历史记录条目表面
        item_rect = pygame.Rect(x, y, width, 70)
        pygame.draw.rect(surface, LIGHT_GRAY, item_rect, border_radius=8)
        pygame.draw.rect(surface, GRAY, item_rect, 1, border_radius=8)
        
        # 绘制源文本
        source_font = pygame.font.SysFont(None, 20)
        source_text = source_font.render(f"{self.source_text[:30]}..." if len(self.source_text) > 30 else self.source_text, True, BLACK)
        surface.blit(source_text, (x + 10, y + 10))
        
        # 绘制翻译文本
        trans_text = source_font.render(f"{self.translated_text[:30]}..." if len(self.translated_text) > 30 else self.translated_text, True, DARK_BLUE)
        surface.blit(trans_text, (x + 10, y + 30))
        
        # 绘制语言信息
        lang_text = source_font.render(f"{self.source_lang} → {self.target_lang} | {self.time}", True, (100, 100, 100))
        surface.blit(lang_text, (x + 10, y + 50))
        
        return item_rect.height

# 创建界面元素
# 输入框
input_box = InputBox(50, 150, 800, 150, is_source=True)
output_box = InputBox(50, 400, 800, 150, is_source=False)

# 按钮
translate_button = Button(350, 320, 200, 50, "翻译", BLUE, DARK_BLUE)
swap_button = Button(700, 100, 150, 40, "交换语言", ORANGE, (200, 120, 0))
clear_button = Button(600, 320, 150, 50, "清空", RED, (180, 0, 50))
history_button = Button(50, 570, 150, 40, "历史记录", GREEN, (0, 180, 50))
speak_source_button = Button(700, 570, 180, 40, "朗读原文", PURPLE, (160, 30, 200))
speak_translation_button = Button(700, 620, 180, 40, "朗读翻译", PURPLE, (160, 30, 200))

# 语言选择按钮
source_lang_buttons = []
target_lang_buttons = []
button_width = 120
button_height = 35
button_start_x = 50
button_start_y = 100

# 创建源语言选择按钮
for i, lang in enumerate(languages):
    x = button_start_x + (i % 7) * (button_width + 10)
    y = button_start_y + (i // 7) * (button_height + 5)
    btn = LanguageButton(x, y, button_width, button_height, lang)
    source_lang_buttons.append(btn)

# 默认选择中文
source_lang_buttons[1].selected = True
selected_source_lang = languages[1]

# 创建目标语言选择按钮
for i, lang in enumerate(languages):
    x = button_start_x + (i % 7) * (button_width + 10)
    y = button_start_y + 300 + (i // 7) * (button_height + 5)
    btn = LanguageButton(x, y, button_width, button_height, lang)
    target_lang_buttons.append(btn)

# 默认选择英语
target_lang_buttons[2].selected = True
selected_target_lang = languages[2]

# 历史记录面板
history_panel_visible = False
history_scroll_offset = 0

# 主循环
clock = pygame.time.Clock()
running = True

# 添加一些示例历史记录
translation_history.append(HistoryItem("Hello", "你好", "英语", "中文"))
translation_history.append(HistoryItem("Good morning", "早上好", "英语", "中文"))
translation_history.append(HistoryItem("Thank you", "谢谢", "英语", "中文"))
translation_history.append(HistoryItem("I love programming", "我爱编程", "英语", "中文"))
translation_history.append(HistoryItem("How are you?", "你好吗", "英语", "中文"))

while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
            
        # 处理输入框事件
        if input_box.handle_event(event):
            # 按下回车键进行翻译
            if input_box.text.strip():
                translated = translate_text(input_box.text, selected_source_lang["code"], selected_target_lang["code"])
                output_box.text = translated
                
                # 添加到历史记录
                history_item = HistoryItem(
                    input_box.text,
                    translated,
                    selected_source_lang["name"],
                    selected_target_lang["name"]
                )
                translation_history.insert(0, history_item)
                
                # 限制历史记录数量
                if len(translation_history) > 20:
                    translation_history.pop()
        
        # 处理按钮事件
        if translate_button.handle_event(event):
            if input_box.text.strip():
                translated = translate_text(input_box.text, selected_source_lang["code"], selected_target_lang["code"])
                output_box.text = translated
                
                # 添加到历史记录
                history_item = HistoryItem(
                    input_box.text,
                    translated,
                    selected_source_lang["name"],
                    selected_target_lang["name"]
                )
                translation_history.insert(0, history_item)
                
                # 限制历史记录数量
                if len(translation_history) > 20:
                    translation_history.pop()
        
        if swap_button.handle_event(event):
            # 交换源语言和目标语言
            source_lang_index = languages.index(selected_source_lang)
            target_lang_index = languages.index(selected_target_lang)
            
            # 交换选择状态
            source_lang_buttons[source_lang_index].selected = False
            target_lang_buttons[target_lang_index].selected = False
            
            source_lang_buttons[target_lang_index].selected = True
            target_lang_buttons[source_lang_index].selected = True
            
            # 更新选中的语言
            selected_source_lang, selected_target_lang = selected_target_lang, selected_source_lang
            
            # 交换文本
            if input_box.text and output_box.text:
                input_box.text, output_box.text = output_box.text, input_box.text
        
        if clear_button.handle_event(event):
            # 清空输入和输出
            input_box.text = ""
            output_box.text = ""
        
        if history_button.handle_event(event):
            # 显示/隐藏历史记录面板
            history_panel_visible = not history_panel_visible
        
        if speak_source_button.handle_event(event):
            # 朗读原文（模拟功能）
            if input_box.text:
                print(f"朗读原文: {input_box.text}")  # 实际应用中这里会调用TTS API
        
        if speak_translation_button.handle_event(event):
            # 朗读翻译（模拟功能）
            if output_box.text:
                print(f"朗读翻译: {output_box.text}")  # 实际应用中这里会调用TTS API
        
        # 处理语言选择按钮事件
        for i, btn in enumerate(source_lang_buttons):
            if btn.handle_event(event):
                # 取消所有源语言按钮的选择状态
                for b in source_lang_buttons:
                    b.selected = False
                
                # 设置当前按钮为选中状态
                btn.selected = True
                selected_source_lang = languages[i]
        
        for i, btn in enumerate(target_lang_buttons):
            if btn.handle_event(event):
                # 取消所有目标语言按钮的选择状态
                for b in target_lang_buttons:
                    b.selected = False
                
                # 设置当前按钮为选中状态
                btn.selected = True
                selected_target_lang = languages[i]
        
        # 处理鼠标滚轮事件（历史记录滚动）
        if event.type == pygame.MOUSEBUTTONDOWN and history_panel_visible:
            if event.button == 4:  # 滚轮向上
                history_scroll_offset = max(0, history_scroll_offset - 20)
            elif event.button == 5:  # 滚轮向下
                history_scroll_offset += 20
    
    # 更新输入框光标
    input_box.update()
    
    # 绘制界面
    screen.fill(WHITE)
    
    # 绘制标题
    title_text = font_title.render("PyTranslate", True, BLUE)
    screen.blit(title_text, (WIDTH // 2 - title_text.get_width() // 2, 20))
    
    subtitle_text = font_small.render("多语言翻译工具", True, DARK_BLUE)
    screen.blit(subtitle_text, (WIDTH // 2 - subtitle_text.get_width() // 2, 80))
    
    # 绘制源语言区域
    source_text = font_medium.render("源语言:", True, BLACK)
    screen.blit(source_text, (50, 120))
    
    # 绘制源语言选择按钮
    for btn in source_lang_buttons:
        btn.draw(screen)
    
    # 绘制目标语言区域
    target_text = font_medium.render("目标语言:", True, BLACK)
    screen.blit(target_text, (50, 370))
    
    # 绘制目标语言选择按钮
    for btn in target_lang_buttons:
        btn.draw(screen)
    
    # 绘制交换按钮
    swap_button.draw(screen)
    
    # 绘制输入框
    input_box.draw(screen)
    output_box.draw(screen)
    
    # 绘制按钮
    translate_button.draw(screen)
    clear_button.draw(screen)
    
    # 绘制朗读和历史记录按钮
    history_button.draw(screen)
    speak_source_button.draw(screen)
    speak_translation_button.draw(screen)
    
    # 绘制翻译方向指示
    lang_direction = font_medium.render(f"{selected_source_lang['name']} → {selected_target_lang['name']}", True, DARK_BLUE)
    screen.blit(lang_direction, (WIDTH // 2 - lang_direction.get_width() // 2, 330))
    
    # 绘制历史记录面板
    if history_panel_visible:
        # 绘制半透明背景
        history_bg = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA)
        history_bg.fill((0, 0, 0, 150))
        screen.blit(history_bg, (0, 0))
        
        # 绘制历史记录面板
        panel_rect = pygame.Rect(100, 100, WIDTH - 200, HEIGHT - 200)
        pygame.draw.rect(screen, WHITE, panel_rect, border_radius=15)
        pygame.draw.rect(screen, BLUE, panel_rect, 3, border_radius=15)
        
        # 绘制面板标题
        history_title = font_large.render("翻译历史", True, BLUE)
        screen.blit(history_title, (WIDTH // 2 - history_title.get_width() // 2, 120))
        
        # 绘制历史记录
        history_y = 180 - history_scroll_offset
        for i, item in enumerate(translation_history):
            if i >= 10:  # 只显示最近的10条记录
                break
                
            item_height = item.draw(screen, 120, history_y, WIDTH - 240)
            history_y += item_height + 10
        
        # 绘制关闭按钮
        close_button = Button(WIDTH - 150, 120, 30, 30, "X", RED, (180, 0, 50))
        if close_button.handle_event(pygame.event.Event(pygame.MOUSEBUTTONDOWN, {'pos': pygame.mouse.get_pos()})):
            # 如果点击了关闭按钮，隐藏历史记录面板
            if pygame.mouse.get_pressed()[0]:
                history_panel_visible = False
        close_button.draw(screen)
        
        # 如果没有历史记录，显示提示信息
        if not translation_history:
            no_history_text = font_medium.render("暂无翻译历史", True, GRAY)
            screen.blit(no_history_text, (WIDTH // 2 - no_history_text.get_width() // 2, HEIGHT // 2))
        
        # 显示历史记录数量
        history_count_text = font_small.render(f"共 {len(translation_history)} 条记录", True, GRAY)
        screen.blit(history_count_text, (WIDTH // 2 - history_count_text.get_width() // 2, HEIGHT - 80))
    
    # 绘制底部信息
    info_text = font_small.render("提示: 输入文本后点击'翻译'按钮或按Enter键进行翻译", True, (100, 100, 100))
    screen.blit(info_text, (WIDTH // 2 - info_text.get_width() // 2, HEIGHT - 30))
    
    # 更新显示
    pygame.display.flip()
    clock.tick(60)

# 退出pygame
pygame.quit()
sys.exit()