import tkinter as tk
from tkinter import ttk, messagebox, scrolledtext
import requests
import json
import hashlib
import random
from datetime import datetime
import threading
import os

class TranslatorApp:
    def __init__(self, root):
        self.root = root
        self.root.title("🌍 智能翻译器")
        self.root.geometry("1000x600")
        self.root.configure(bg='#f5f5f5')
        
        # 设置窗口位置
        self.center_window()
        
        # 支持的语言
        self.languages = {
            '自动检测': 'auto',
            '中文': 'zh',
            '英语': 'en',
            '日语': 'ja',
            '韩语': 'ko',
            '法语': 'fr',
            '德语': 'de',
            '西班牙语': 'es',
            '俄语': 'ru',
            '阿拉伯语': 'ar',
            '葡萄牙语': 'pt',
            '意大利语': 'it'
        }
        
        # 翻译引擎
        self.translation_engines = ["百度翻译", "谷歌翻译", "有道翻译"]
        self.current_engine = "百度翻译"
        
        # 历史记录
        self.history = []
        self.load_history()
        
        # 创建界面
        self.create_ui()
        
    def center_window(self):
        """窗口居中"""
        self.root.update_idletasks()
        width = 1000
        height = 600
        screen_width = self.root.winfo_screenwidth()
        screen_height = self.root.winfo_screenheight()
        x = (screen_width - width) // 2
        y = (screen_height - height) // 2
        self.root.geometry(f"{width}x{height}+{x}+{y}")
    
    def create_ui(self):
        """创建用户界面"""
        # 主框架
        main_frame = tk.Frame(self.root, bg='#f5f5f5', padx=20, pady=20)
        main_frame.pack(fill=tk.BOTH, expand=True)
        
        # 标题栏
        self.create_header(main_frame)
        
        # 控制区域
        self.create_controls(main_frame)
        
        # 翻译区域
        self.create_translation_area(main_frame)
        
        # 状态栏
        self.create_statusbar(main_frame)
    
    def create_header(self, parent):
        """创建标题栏"""
        header_frame = tk.Frame(parent, bg='#f5f5f5')
        header_frame.pack(fill=tk.X, pady=(0, 20))
        
        # 标题
        title_label = tk.Label(header_frame, text="🌍 智能翻译器", 
                              font=("Microsoft YaHei", 24, "bold"),
                              fg="#2c3e50", bg='#f5f5f5')
        title_label.pack(side=tk.LEFT)
        
        # 引擎选择
        engine_frame = tk.Frame(header_frame, bg='#f5f5f5')
        engine_frame.pack(side=tk.RIGHT)
        
        tk.Label(engine_frame, text="引擎:", font=("Microsoft YaHei", 10),
                fg="#34495e", bg='#f5f5f5').pack(side=tk.LEFT, padx=5)
        
        self.engine_var = tk.StringVar(value=self.current_engine)
        engine_combo = ttk.Combobox(engine_frame, 
                                   textvariable=self.engine_var,
                                   values=self.translation_engines,
                                   state="readonly",
                                   width=12,
                                   font=("Microsoft YaHei", 10))
        engine_combo.pack(side=tk.LEFT)
        
    def create_controls(self, parent):
        """创建控制区域"""
        control_frame = tk.Frame(parent, bg='#f5f5f5')
        control_frame.pack(fill=tk.X, pady=(0, 20))
        
        # 源语言
        tk.Label(control_frame, text="从:", font=("Microsoft YaHei", 11),
                fg="#2c3e50", bg='#f5f5f5').grid(row=0, column=0, padx=5)
        
        self.src_lang_var = tk.StringVar(value="自动检测")
        src_lang_combo = ttk.Combobox(control_frame, 
                                     textvariable=self.src_lang_var,
                                     values=list(self.languages.keys()),
                                     state="readonly",
                                     width=15,
                                     font=("Microsoft YaHei", 10))
        src_lang_combo.grid(row=0, column=1, padx=5)
        
        # 目标语言
        tk.Label(control_frame, text="到:", font=("Microsoft YaHei", 11),
                fg="#2c3e50", bg='#f5f5f5').grid(row=0, column=2, padx=5)
        
        self.tgt_lang_var = tk.StringVar(value="英语")
        tgt_lang_combo = ttk.Combobox(control_frame, 
                                     textvariable=self.tgt_lang_var,
                                     values=[k for k in self.languages.keys() if k != "自动检测"],
                                     state="readonly",
                                     width=15,
                                     font=("Microsoft YaHei", 10))
        tgt_lang_combo.grid(row=0, column=3, padx=5)
        
        # 交换按钮
        swap_btn = tk.Button(control_frame, text="⇄", 
                           command=self.swap_languages,
                           font=("Microsoft YaHei", 12, "bold"),
                           bg="#3498db", fg="white",
                           relief=tk.FLAT, width=3)
        swap_btn.grid(row=0, column=4, padx=10)
        
        # 控制按钮
        btn_frame = tk.Frame(control_frame, bg='#f5f5f5')
        btn_frame.grid(row=0, column=5, padx=20, sticky=tk.W)
        
        tk.Button(btn_frame, text="📄 粘贴", 
                 command=self.paste_text,
                 font=("Microsoft YaHei", 10),
                 bg="#2ecc71", fg="white",
                 relief=tk.FLAT, width=8).pack(side=tk.LEFT, padx=2)
        
        tk.Button(btn_frame, text="🧹 清空", 
                 command=self.clear_input,
                 font=("Microsoft YaHei", 10),
                 bg="#e74c3c", fg="white",
                 relief=tk.FLAT, width=8).pack(side=tk.LEFT, padx=2)
        
        tk.Button(btn_frame, text="📋 复制", 
                 command=self.copy_output,
                 font=("Microsoft YaHei", 10),
                 bg="#3498db", fg="white",
                 relief=tk.FLAT, width=8).pack(side=tk.LEFT, padx=2)
        
        # 字数统计
        count_frame = tk.Frame(control_frame, bg='#f5f5f5')
        count_frame.grid(row=0, column=6, padx=20)
        
        self.char_count = tk.Label(count_frame, text="字符: 0", 
                                  font=("Microsoft YaHei", 9),
                                  fg="#7f8c8d", bg='#f5f5f5')
        self.char_count.pack()
    
    def create_translation_area(self, parent):
        """创建翻译区域"""
        trans_frame = tk.Frame(parent, bg='#f5f5f5')
        trans_frame.pack(fill=tk.BOTH, expand=True)
        
        # 输入区域
        input_frame = tk.LabelFrame(trans_frame, text="输入文本", 
                                   font=("Microsoft YaHei", 11, "bold"),
                                   bg='white', fg="#2c3e50",
                                   padx=10, pady=10)
        input_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=(0, 10))
        
        self.input_text = scrolledtext.ScrolledText(input_frame, 
                                                   font=("Microsoft YaHei", 12),
                                                   wrap=tk.WORD,
                                                   height=20,
                                                   bg='#f8f9fa',
                                                   relief=tk.FLAT)
        self.input_text.pack(fill=tk.BOTH, expand=True)
        
        # 绑定文本变化事件
        self.input_text.bind('<KeyRelease>', self.update_counts)
        
        # 输出区域
        output_frame = tk.LabelFrame(trans_frame, text="翻译结果", 
                                    font=("Microsoft YaHei", 11, "bold"),
                                    bg='white', fg="#2c3e50",
                                    padx=10, pady=10)
        output_frame.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True, padx=(10, 0))
        
        self.output_text = scrolledtext.ScrolledText(output_frame, 
                                                    font=("Microsoft YaHei", 12),
                                                    wrap=tk.WORD,
                                                    height=20,
                                                    bg='#f8f9fa',
                                                    relief=tk.FLAT,
                                                    state=tk.DISABLED)
        self.output_text.pack(fill=tk.BOTH, expand=True)
        
        # 翻译按钮
        btn_frame = tk.Frame(parent, bg='#f5f5f5')
        btn_frame.pack(fill=tk.X, pady=20)
        
        self.translate_btn = tk.Button(btn_frame, text="🚀 开始翻译", 
                                      command=self.translate,
                                      font=("Microsoft YaHei", 14, "bold"),
                                      bg="#1abc9c", fg="white",
                                      relief=tk.RAISED,
                                      padx=40, pady=10)
        self.translate_btn.pack()
    
    def create_statusbar(self, parent):
        """创建状态栏"""
        status_frame = tk.Frame(parent, bg='#ecf0f1', height=30)
        status_frame.pack(fill=tk.X, pady=(20, 0))
        status_frame.pack_propagate(False)
        
        self.status_var = tk.StringVar(value="就绪")
        status_label = tk.Label(status_frame, textvariable=self.status_var,
                               font=("Microsoft YaHei", 9),
                               fg="#7f8c8d", bg='#ecf0f1')
        status_label.pack(side=tk.LEFT, padx=10)
    
    def update_counts(self, event=None):
        """更新字数统计"""
        text = self.input_text.get("1.0", tk.END).strip()
        char_count = len(text)
        self.char_count.config(text=f"字符: {char_count}")
    
    def swap_languages(self):
        """交换语言"""
        src = self.src_lang_var.get()
        tgt = self.tgt_lang_var.get()
        
        if src == "自动检测":
            self.src_lang_var.set(tgt)
            self.tgt_lang_var.set("自动检测")
        else:
            self.src_lang_var.set(tgt)
            self.tgt_lang_var.set(src)
        
        # 交换文本
        input_text = self.input_text.get("1.0", tk.END).strip()
        self.output_text.config(state=tk.NORMAL)
        output_text = self.output_text.get("1.0", tk.END).strip()
        
        if output_text:
            self.input_text.delete("1.0", tk.END)
            self.input_text.insert("1.0", output_text)
            self.output_text.delete("1.0", tk.END)
            self.output_text.insert("1.0", input_text)
        
        self.output_text.config(state=tk.DISABLED)
        self.update_counts()
        self.status_var.set("语言已交换")
    
    def paste_text(self):
        """粘贴文本"""
        try:
            text = self.root.clipboard_get()
            self.input_text.insert(tk.INSERT, text)
            self.update_counts()
            self.status_var.set("已粘贴文本")
        except:
            self.status_var.set("粘贴失败")
    
    def clear_input(self):
        """清空输入"""
        self.input_text.delete("1.0", tk.END)
        self.update_counts()
        self.status_var.set("已清空输入")
    
    def copy_output(self):
        """复制输出"""
        self.output_text.config(state=tk.NORMAL)
        output_text = self.output_text.get("1.0", tk.END).strip()
        self.output_text.config(state=tk.DISABLED)
        
        if output_text:
            self.root.clipboard_clear()
            self.root.clipboard_append(output_text)
            self.status_var.set("译文已复制")
        else:
            self.status_var.set("没有可复制的内容")
    
    def translate(self):
        """执行翻译"""
        text = self.input_text.get("1.0", tk.END).strip()
        if not text:
            messagebox.showwarning("提示", "请输入要翻译的文本")
            return
        
        src_lang = self.languages.get(self.src_lang_var.get(), "auto")
        tgt_lang = self.languages.get(self.tgt_lang_var.get(), "en")
        engine = self.engine_var.get()
        
        # 更新状态
        self.status_var.set("正在翻译...")
        self.translate_btn.config(state=tk.DISABLED, text="翻译中...")
        
        # 在新线程中翻译
        thread = threading.Thread(target=self._translate_thread,
                                args=(text, src_lang, tgt_lang, engine))
        thread.daemon = True
        thread.start()
    
    def _translate_thread(self, text, src_lang, tgt_lang, engine):
        """翻译线程"""
        try:
            if engine == "百度翻译":
                result = self.baidu_translate(text, src_lang, tgt_lang)
            elif engine == "谷歌翻译":
                result = self.google_translate(text, src_lang, tgt_lang)
            elif engine == "有道翻译":
                result = self.youdao_translate(text, src_lang, tgt_lang)
            else:
                result = self.mock_translate(text, engine)
            
            # 在主线程中更新结果
            self.root.after(0, self._update_result, result, text, src_lang, tgt_lang, engine)
            
        except Exception as e:
            error_msg = f"翻译失败: {str(e)}"
            self.root.after(0, self._show_error, error_msg)
    
    def _update_result(self, result, text, src_lang, tgt_lang, engine):
        """更新翻译结果"""
        self.output_text.config(state=tk.NORMAL)
        self.output_text.delete("1.0", tk.END)
        self.output_text.insert("1.0", result)
        self.output_text.config(state=tk.DISABLED)
        
        # 保存到历史记录
        self.save_to_history(text, result, src_lang, tgt_lang, engine)
        
        # 恢复按钮
        self.translate_btn.config(state=tk.NORMAL, text="🚀 开始翻译")
        self.status_var.set("翻译完成")
    
    def _show_error(self, error_msg):
        """显示错误"""
        self.output_text.config(state=tk.NORMAL)
        self.output_text.delete("1.0", tk.END)
        self.output_text.insert("1.0", error_msg)
        self.output_text.config(state=tk.DISABLED)
        
        self.translate_btn.config(state=tk.NORMAL, text="🚀 开始翻译")
        self.status_var.set("翻译失败")
    
    def baidu_translate(self, text, src_lang, tgt_lang):
        """百度翻译"""
        # 这里需要替换为你的百度翻译API信息
        appid = "你的APPID"
        key = "你的密钥"
        
        if appid == "你的APPID" or key == "你的密钥":
            return self.mock_translate(text, "百度翻译")
        
        salt = str(random.randint(32768, 65536))
        sign_str = appid + text + salt + key
        sign = hashlib.md5(sign_str.encode()).hexdigest()
        
        url = "https://fanyi-api.baidu.com/api/trans/vip/translate"
        params = {
            'q': text,
            'from': src_lang,
            'to': tgt_lang,
            'appid': appid,
            'salt': salt,
            'sign': sign
        }
        
        response = requests.get(url, params=params, timeout=10)
        data = response.json()
        
        if 'trans_result' in data:
            return '\n'.join([item['dst'] for item in data['trans_result']])
        else:
            error_msg = data.get('error_msg', '翻译失败')
            raise Exception(f"百度翻译错误: {error_msg}")
    
    def google_translate(self, text, src_lang, tgt_lang):
        """谷歌翻译"""
        try:
            url = "https://translate.googleapis.com/translate_a/single"
            params = {
                'client': 'gtx',
                'sl': src_lang,
                'tl': tgt_lang,
                'dt': 't',
                'q': text
            }
            
            response = requests.get(url, params=params, timeout=10)
            data = response.json()
            
            if data and len(data) > 0 and data[0]:
                return ''.join([item[0] for item in data[0]])
            else:
                return self.mock_translate(text, "谷歌翻译")
                
        except:
            return self.mock_translate(text, "谷歌翻译")
    
    def youdao_translate(self, text, src_lang, tgt_lang):
        """有道翻译"""
        return self.mock_translate(text, "有道翻译")
    
    def mock_translate(self, text, engine):
        """模拟翻译（用于演示）"""
        translations = {
            "hello": "你好",
            "world": "世界",
            "thank you": "谢谢",
            "good morning": "早上好",
            "how are you": "你好吗",
            "i love programming": "我喜欢编程",
            "artificial intelligence": "人工智能",
            "machine learning": "机器学习"
        }
        
        text_lower = text.lower()
        for eng, chi in translations.items():
            if eng in text_lower:
                return f"【{engine}模拟翻译】\n{chi}"
        
        return f"【{engine}模拟翻译】\n{text} -> 翻译结果示例"
    
    def save_to_history(self, src_text, tgt_text, src_lang, tgt_lang, engine):
        """保存到历史记录"""
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        record = {
            "time": timestamp,
            "source": src_text,
            "target": tgt_text,
            "src_lang": src_lang,
            "tgt_lang": tgt_lang,
            "engine": engine
        }
        self.history.append(record)
        
        # 保持最近50条记录
        if len(self.history) > 50:
            self.history = self.history[-50:]
        
        # 保存到文件
        self.save_history()
    
    def save_history(self):
        """保存历史记录"""
        try:
            with open("translation_history.json", "w", encoding="utf-8") as f:
                json.dump(self.history, f, ensure_ascii=False, indent=2)
        except:
            pass
    
    def load_history(self):
        """加载历史记录"""
        try:
            if os.path.exists("translation_history.json"):
                with open("translation_history.json", "r", encoding="utf-8") as f:
                    self.history = json.load(f)
        except:
            self.history = []

def main():
    """主函数"""
    root = tk.Tk()
    app = TranslatorApp(root)
    root.mainloop()

if __name__ == "__main__":
    main()