import tkinter as tk
from tkinter import ttk, messagebox
from datetime import datetime
import json

class OfflineCurrencyConverter:
    def __init__(self, root):
        self.root = root
        self.root.title("离线货币转换器")
        self.root.geometry("500x400")
        self.root.configure(bg='#f0f0f0')
        
        # 货币代码和名称
        self.currencies = {
            'USD': '美元', 'EUR': '欧元', 'GBP': '英镑', 
            'JPY': '日元', 'CNY': '人民币', 'HKD': '港币',
            'KRW': '韩元', 'AUD': '澳元', 'CAD': '加元',
            'SGD': '新加坡元', 'CHF': '瑞士法郎',
            'INR': '印度卢比', 'RUB': '俄罗斯卢布', 'BRL': '巴西雷亚尔'
        }
        
        # 硬编码的汇率数据（相对于USD）
        self.base_rates = {
            'USD': 1.0,      # 美元
            'EUR': 0.92,     # 欧元
            'GBP': 0.79,     # 英镑
            'JPY': 149.0,    # 日元
            'CNY': 7.20,     # 人民币
            'HKD': 7.82,     # 港币
            'KRW': 1315.0,   # 韩元
            'AUD': 1.52,     # 澳元
            'CAD': 1.36,     # 加元
            'SGD': 1.36,     # 新加坡元
            'CHF': 0.90,     # 瑞士法郎
            'INR': 83.0,     # 印度卢比
            'RUB': 92.0,     # 俄罗斯卢布
            'BRL': 4.95      # 巴西雷亚尔
        }
        
        # 汇率更新时间
        self.last_update = "2024-01-01 (离线数据)"
        
        # 创建界面
        self.setup_ui()
        
        # 绑定事件
        self.setup_bindings()
    
    def setup_ui(self):
        """设置用户界面"""
        # 标题
        title_label = ttk.Label(
            self.root, 
            text="💰 离线货币转换器", 
            font=('Microsoft YaHei', 14, 'bold'),
            background='#f0f0f0'
        )
        title_label.pack(pady=15)
        
        # 说明标签
        info_label = ttk.Label(
            self.root,
            text="使用离线汇率数据，可手动更新汇率",
            font=('Microsoft YaHei', 9),
            foreground='#666',
            background='#f0f0f0'
        )
        info_label.pack()
        
        # 主框架
        main_frame = ttk.Frame(self.root, padding="20")
        main_frame.pack(fill=tk.BOTH, expand=True)
        
        # 金额输入
        amount_frame = ttk.Frame(main_frame)
        amount_frame.pack(fill=tk.X, pady=8)
        
        ttk.Label(amount_frame, text="金额:", font=('Microsoft YaHei', 10)).pack(side=tk.LEFT, padx=5)
        self.amount_var = tk.StringVar(value="100")
        self.amount_entry = ttk.Entry(
            amount_frame, 
            textvariable=self.amount_var,
            width=20,
            font=('Microsoft YaHei', 10)
        )
        self.amount_entry.pack(side=tk.LEFT, padx=5)
        self.amount_entry.select_range(0, tk.END)
        self.amount_entry.icursor(tk.END)
        
        # 从货币选择
        from_frame = ttk.Frame(main_frame)
        from_frame.pack(fill=tk.X, pady=8)
        
        ttk.Label(from_frame, text="从货币:", font=('Microsoft YaHei', 10)).pack(side=tk.LEFT, padx=5)
        self.from_currency = ttk.Combobox(
            from_frame,
            values=list(self.currencies.keys()),
            state='readonly',
            width=12,
            font=('Microsoft YaHei', 10)
        )
        self.from_currency.set('USD')
        self.from_currency.pack(side=tk.LEFT, padx=5)
        
        self.from_name_label = ttk.Label(
            from_frame, 
            text=self.currencies['USD'],
            width=8,
            font=('Microsoft YaHei', 10)
        )
        self.from_name_label.pack(side=tk.LEFT, padx=5)
        
        # 转换箭头
        arrow_frame = ttk.Frame(main_frame)
        arrow_frame.pack(pady=5)
        
        self.swap_btn = ttk.Button(
            arrow_frame,
            text="⇄ 交换货币",
            command=self.swap_currencies,
            width=12
        )
        self.swap_btn.pack()
        
        # 到货币选择
        to_frame = ttk.Frame(main_frame)
        to_frame.pack(fill=tk.X, pady=8)
        
        ttk.Label(to_frame, text="到货币:", font=('Microsoft YaHei', 10)).pack(side=tk.LEFT, padx=5)
        self.to_currency = ttk.Combobox(
            to_frame,
            values=list(self.currencies.keys()),
            state='readonly',
            width=12,
            font=('Microsoft YaHei', 10)
        )
        self.to_currency.set('CNY')
        self.to_currency.pack(side=tk.LEFT, padx=5)
        
        self.to_name_label = ttk.Label(
            to_frame, 
            text=self.currencies['CNY'],
            width=8,
            font=('Microsoft YaHei', 10)
        )
        self.to_name_label.pack(side=tk.LEFT, padx=5)
        
        # 转换按钮
        button_frame = ttk.Frame(main_frame)
        button_frame.pack(pady=15)
        
        convert_btn = ttk.Button(
            button_frame,
            text="立即转换",
            command=self.convert_currency,
            width=12
        )
        convert_btn.pack(side=tk.LEFT, padx=5)
        
        clear_btn = ttk.Button(
            button_frame,
            text="清空",
            command=self.clear_all,
            width=8
        )
        clear_btn.pack(side=tk.LEFT, padx=5)
        
        # 结果显示区域
        result_frame = ttk.LabelFrame(main_frame, text="转换结果", padding=15)
        result_frame.pack(fill=tk.BOTH, expand=True, pady=5)
        
        self.result_var = tk.StringVar(value="输入金额并选择货币进行转换")
        self.result_label = ttk.Label(
            result_frame,
            textvariable=self.result_var,
            font=('Microsoft YaHei', 11),
            foreground='#2c3e50',
            anchor=tk.CENTER,
            wraplength=350
        )
        self.result_label.pack(fill=tk.BOTH, expand=True)
        
        # 汇率信息
        self.rate_var = tk.StringVar()
        rate_label = ttk.Label(
            result_frame,
            textvariable=self.rate_var,
            font=('Microsoft YaHei', 9),
            foreground='#7f8c8d',
            anchor=tk.CENTER
        )
        rate_label.pack()
        
        # 状态栏
        status_frame = ttk.Frame(self.root)
        status_frame.pack(side=tk.BOTTOM, fill=tk.X, padx=10, pady=5)
        
        self.status_var = tk.StringVar(value=f"离线模式 | 汇率数据: {self.last_update}")
        status_label = ttk.Label(
            status_frame,
            textvariable=self.status_var,
            font=('Microsoft YaHei', 8),
            foreground='#95a5a6'
        )
        status_label.pack(side=tk.LEFT)
        
        # 更新汇率按钮
        update_btn = ttk.Button(
            status_frame,
            text="手动更新汇率",
            command=self.manual_update_rate,
            width=12
        )
        update_btn.pack(side=tk.RIGHT)
    
    def setup_bindings(self):
        """绑定事件"""
        self.from_currency.bind('<<ComboboxSelected>>', self.update_currency_names)
        self.to_currency.bind('<<ComboboxSelected>>', self.update_currency_names)
        self.amount_entry.bind('<KeyRelease>', lambda e: self.convert_currency())
        
        # 初始更新货币名称
        self.update_currency_names()
    
    def update_currency_names(self, event=None):
        """更新货币名称显示"""
        from_code = self.from_currency.get()
        to_code = self.to_currency.get()
        
        self.from_name_label.config(text=self.currencies.get(from_code, ''))
        self.to_name_label.config(text=self.currencies.get(to_code, ''))
    
    def convert_currency(self):
        """执行货币转换"""
        try:
            # 获取输入
            amount_str = self.amount_var.get().strip()
            if not amount_str:
                self.result_var.set("请输入要转换的金额")
                self.rate_var.set("")
                return
                
            amount = float(amount_str)
            from_curr = self.from_currency.get()
            to_curr = self.to_currency.get()
            
            if not from_curr or not to_curr:
                messagebox.showwarning("选择错误", "请选择要转换的货币")
                return
            
            if from_curr == to_curr:
                result = amount
                rate = 1.0
            else:
                # 计算转换
                if from_curr in self.base_rates and to_curr in self.base_rates:
                    # 通过美元作为中间货币进行转换
                    rate = self.base_rates[to_curr] / self.base_rates[from_curr]
                    result = amount * rate
                else:
                    messagebox.showerror("错误", f"不支持 {from_curr} 或 {to_curr} 货币")
                    return
            
            # 显示结果
            result_formatted = f"{amount:,.2f} {from_curr} = {result:,.4f} {to_curr}"
            rate_formatted = f"汇率: 1 {from_curr} = {rate:.6f} {to_curr}"
            reverse_rate = f"1 {to_curr} = {1/rate:.6f} {from_curr}" if rate != 0 else ""
            
            self.result_var.set(result_formatted)
            self.rate_var.set(f"{rate_formatted}  |  {reverse_rate}")
            
        except ValueError:
            self.result_var.set("错误: 请输入有效的数字")
            self.rate_var.set("")
        except ZeroDivisionError:
            self.result_var.set("错误: 汇率计算错误")
            self.rate_var.set("")
        except Exception as e:
            self.result_var.set(f"转换错误: {str(e)}")
            self.rate_var.set("")
    
    def swap_currencies(self):
        """交换货币选择"""
        from_curr = self.from_currency.get()
        to_curr = self.to_currency.get()
        
        self.from_currency.set(to_curr)
        self.to_currency.set(from_curr)
        self.update_currency_names()
        
        # 自动重新转换
        if self.amount_var.get():
            self.convert_currency()
    
    def clear_all(self):
        """清空所有输入"""
        self.amount_var.set("")
        self.result_var.set("输入金额并选择货币进行转换")
        self.rate_var.set("")
        self.amount_entry.focus()
    
    def manual_update_rate(self):
        """手动更新汇率对话框"""
        dialog = tk.Toplevel(self.root)
        dialog.title("手动更新汇率")
        dialog.geometry("400x300")
        dialog.transient(self.root)
        dialog.grab_set()
        
        # 居中显示
        dialog.update_idletasks()
        x = self.root.winfo_x() + (self.root.winfo_width() - dialog.winfo_width()) // 2
        y = self.root.winfo_y() + (self.root.winfo_height() - dialog.winfo_height()) // 2
        dialog.geometry(f"+{x}+{y}")
        
        ttk.Label(dialog, text="手动更新汇率（相对于USD）", 
                 font=('Microsoft YaHei', 11, 'bold')).pack(pady=10)
        
        # 创建滚动区域
        canvas = tk.Canvas(dialog)
        scrollbar = ttk.Scrollbar(dialog, orient="vertical", command=canvas.yview)
        scrollable_frame = ttk.Frame(canvas)
        
        scrollable_frame.bind(
            "<Configure>",
            lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
        )
        
        canvas.create_window((0, 0), window=scrollable_frame, anchor="nw")
        canvas.configure(yscrollcommand=scrollbar.set)
        
        # 为每种货币创建输入框
        entries = {}
        for i, (code, name) in enumerate(self.currencies.items()):
            if code in self.base_rates:
                frame = ttk.Frame(scrollable_frame)
                frame.pack(fill=tk.X, padx=20, pady=2)
                
                ttk.Label(frame, text=f"{code} ({name}):", width=15, anchor="w").pack(side=tk.LEFT)
                var = tk.StringVar(value=str(self.base_rates[code]))
                entry = ttk.Entry(frame, textvariable=var, width=10)
                entry.pack(side=tk.LEFT, padx=5)
                entries[code] = var
        
        def save_rates():
            try:
                for code, var in entries.items():
                    self.base_rates[code] = float(var.get())
                
                self.last_update = datetime.now().strftime("%Y-%m-%d %H:%M:%S (手动更新)")
                self.status_var.set(f"离线模式 | 汇率数据: {self.last_update}")
                dialog.destroy()
                messagebox.showinfo("成功", "汇率已更新！")
                self.convert_currency()  # 使用新汇率重新计算
            except ValueError:
                messagebox.showerror("错误", "请输入有效的数字")
        
        ttk.Button(dialog, text="保存", command=save_rates).pack(pady=10)
        
        canvas.pack(side="left", fill="both", expand=True)
        scrollbar.pack(side="right", fill="y")

def main():
    root = tk.Tk()
    
    # 设置窗口居中
    window_width = 500
    window_height = 450
    screen_width = root.winfo_screenwidth()
    screen_height = root.winfo_screenheight()
    center_x = int(screen_width/2 - window_width/2)
    center_y = int(screen_height/2 - window_height/2)
    root.geometry(f'{window_width}x{window_height}+{center_x}+{center_y}')
    
    # 创建应用
    app = OfflineCurrencyConverter(root)
    
    # 运行主循环
    root.mainloop()

if __name__ == "__main__":
    main()