"""
开发者模式 - r321f-CRonly 功能
"""

import os
import sys
import json
import getpass
import tkinter as tk
from tkinter import simpledialog, messagebox
from typing import List, Dict, Optional
from datetime import datetime


class DeveloperMode:
    """开发者模式管理器"""

    # 开发者密码
    DEVELOPER_PASSWORDS = [
        "r321f_is_forver",
        "r321f"
    ]

    def __init__(self, config_dir=None):
        """
        初始化开发者模式

        Args:
            config_dir: 配置目录
        """
        if config_dir is None:
            home_dir = os.path.expanduser('~')
            self.config_dir = os.path.join(home_dir, '.r321f')
        else:
            self.config_dir = config_dir

        self.developer_files_path = os.path.join(self.config_dir, 'developer_files.json')
        self.authenticated = False

    def authenticate(self) -> bool:
        """
        认证开发者身份

        Returns:
            是否认证成功
        """
        print("=" * 60)
        print("开发者模式认证")
        print("=" * 60)
        print()

        # 尝试使用 Tkinter 输入密码
        password = self._get_password_via_tkinter()

        # 如果 Tkinter 失败，使用终端输入
        if not password:
            print("Tkinter 窗口已关闭，请在终端输入密码：")
            password = getpass.getpass("请输入开发者密码: ")

        # 验证密码
        if password in self.DEVELOPER_PASSWORDS:
            self.authenticated = True
            print()
            print("✓ 认证成功！")
            print()
            return True
        else:
            print()
            print("✗ 认证失败：密码错误")
            print()
            return False

    def _get_password_via_tkinter(self) -> Optional[str]:
        """
        使用 Tkinter 获取密码

        Returns:
            密码或 None
        """
        try:
            # 创建 Tkinter 根窗口
            root = tk.Tk()
            root.title("r321f 开发者认证")
            root.geometry("400x200")

            # 居中显示
            root.eval('tk::PlaceWindow . center')

            # 密码输入对话框
            password = simpledialog.askstring(
                "开发者认证",
                "请输入开发者密码：",
                show='*',
                parent=root
            )

            # 销毁窗口
            root.destroy()

            return password

        except Exception as e:
            print(f"Tkinter 错误: {e}")
            return None

    def list_developer_files(self, page: int = 0, per_page: int = 5) -> List[Dict]:
        """
        列出开发者文件

        Args:
            page: 页码（从0开始）
            per_page: 每页显示数量

        Returns:
            文件列表
        """
        if not self.authenticated:
            raise PermissionError("未认证，请先使用开发者密码登录")

        # 加载开发者文件
        files = self._load_developer_files()

        # 分页
        start = page * per_page
        end = start + per_page
        return files[start:end]

    def add_developer_file(self, name: str, content: str, description: str = ""):
        """
        添加开发者文件

        Args:
            name: 文件名
            content: 文件内容
            description: 描述
        """
        if not self.authenticated:
            raise PermissionError("未认证，请先使用开发者密码登录")

        # 加载现有文件
        files = self._load_developer_files()

        # 添加新文件
        files.append({
            'id': len(files) + 1,
            'name': name,
            'content': content,
            'description': description,
            'created_at': datetime.now().isoformat(),
            'author': 'developer'
        })

        # 保存文件
        self._save_developer_files(files)

        print(f"✓ 开发者文件 '{name}' 已添加")

    def get_developer_file(self, file_id: int) -> Optional[Dict]:
        """
        获取开发者文件

        Args:
            file_id: 文件ID

        Returns:
            文件内容或 None
        """
        if not self.authenticated:
            raise PermissionError("未认证，请先使用开发者密码登录")

        files = self._load_developer_files()

        for file in files:
            if file['id'] == file_id:
                return file

        return None

    def delete_developer_file(self, file_id: int):
        """
        删除开发者文件

        Args:
            file_id: 文件ID
        """
        if not self.authenticated:
            raise PermissionError("未认证，请先使用开发者密码登录")

        files = self._load_developer_files()

        # 删除文件
        files = [f for f in files if f['id'] != file_id]

        # 保存文件
        self._save_developer_files(files)

        print(f"✓ 文件 ID {file_id} 已删除")

    def _load_developer_files(self) -> List[Dict]:
        """加载开发者文件"""
        if not os.path.exists(self.developer_files_path):
            # 创建默认开发者文件（加密后的内容）
            from cryptography.fernet import Fernet
            import base64

            # 生成一个密钥用于加密开发者文件
            key = Fernet.generate_key()
            fernet = Fernet(key)

            # 加密示例内容
            files_data = [
                {
                    'id': 1,
                    'name': 'test_encryption.txt',
                    'content': '这是一个测试加密文件内容。',
                    'description': '用于测试加密功能的示例文件'
                },
                {
                    'id': 2,
                    'name': 'example_config.json',
                    'content': '{"encryption_level": "P3", "auto_backup": true}',
                    'description': '示例配置文件'
                },
                {
                    'id': 3,
                    'name': 'secret_message.txt',
                    'content': '这是一条只有开发者才能看到的秘密消息。',
                    'description': '开发者专用秘密消息'
                },
                {
                    'id': 4,
                    'name': 'api_keys.json',
                    'content': '{"api_key": "sk_test_xxx", "secret": "xxx"}',
                    'description': 'API密钥示例（请勿在生产环境使用）'
                },
                {
                    'id': 5,
                    'name': 'debug_log.txt',
                    'content': '[DEBUG] System initialized\n[INFO] All services running',
                    'description': '调试日志示例'
                }
            ]

            # 加密每个文件的内容
            default_files = []
            for file_data in files_data:
                encrypted_content = fernet.encrypt(file_data['content'].encode('utf-8'))
                default_files.append({
                    'id': file_data['id'],
                    'name': file_data['name'],
                    'content': base64.b64encode(encrypted_content).decode('utf-8'),
                    'description': file_data['description'],
                    'created_at': datetime.now().isoformat(),
                    'author': 'system'
                })

            self._save_developer_files(default_files)
            return default_files

        with open(self.developer_files_path, 'r', encoding='utf-8') as f:
            return json.load(f)

    def _save_developer_files(self, files: List[Dict]):
        """保存开发者文件"""
        with open(self.developer_files_path, 'w', encoding='utf-8') as f:
            json.dump(files, f, indent=2, ensure_ascii=False)

    def run_interactive_mode(self):
        """运行交互式开发者模式"""
        if not self.authenticate():
            return

        print("=" * 60)
        print("开发者模式 - 内置加密文件")
        print("=" * 60)
        print()
        print("操作说明：")
        print("  输入数字选择文件并解密保存")
        print("  输入 'a' 或 'd' 切换上一页")
        print("  输入 'w' 或 's' 切换下一页")
        print("  输入 'q' 退出")
        print()

        current_page = 0
        per_page = 5

        while True:
            # 显示当前页文件
            files = self.list_developer_files(current_page, per_page)

            print(f"【第 {current_page + 1} 页】")
            print("-" * 60)

            if not files:
                print("没有文件")
            else:
                for file in files:
                    print(f"  [{file['id']}] {file['name']}")
                    print(f"      {file['description']}")
                    print(f"      创建时间: {file['created_at'][:10]}")
                    print()

            print("-" * 60)
            print("操作: ", end='', flush=True)

            # 获取用户输入
            try:
                choice = input().strip().lower()

                if choice == 'q':
                    print("退出开发者模式")
                    break
                elif choice in ['a', 'd']:
                    # 上一页
                    if current_page > 0:
                        current_page -= 1
                    else:
                        print("已经是第一页了")
                elif choice in ['w', 's']:
                    # 下一页
                    total_files = len(self._load_developer_files())
                    if (current_page + 1) * per_page < total_files:
                        current_page += 1
                    else:
                        print("已经是最后一页了")
                elif choice.isdigit():
                    # 解密并保存文件
                    file_id = int(choice)
                    file = self.get_developer_file(file_id)
                    if file:
                        print()
                        print("=" * 60)
                        print(f"正在解密文件: {file['name']}")
                        print("-" * 60)

                        try:
                            # 解密内容
                            import base64
                            from cryptography.fernet import Fernet

                            # 使用开发者密码作为密钥
                            key = Fernet.generate_key()
                            fernet = Fernet(key)

                            # 解密
                            encrypted_content = base64.b64decode(file['content'].encode('utf-8'))
                            decrypted_content = fernet.decrypt(encrypted_content).decode('utf-8')

                            # 保存到当前目录
                            output_path = os.path.join(os.getcwd(), file['name'])
                            with open(output_path, 'w', encoding='utf-8') as f:
                                f.write(decrypted_content)

                            print(f"✓ 文件已解密并保存到: {output_path}")
                            print()
                            print("文件内容预览:")
                            print("-" * 60)
                            print(decrypted_content[:200] + "..." if len(decrypted_content) > 200 else decrypted_content)
                            print("-" * 60)

                        except Exception as e:
                            print(f"✗ 解密失败: {e}")

                        print()
                        input("按 Enter 继续...")
                    else:
                        print(f"文件 ID {file_id} 不存在")
                else:
                    print("无效输入")

            except KeyboardInterrupt:
                print("\n退出开发者模式")
                break
            except Exception as e:
                print(f"错误: {e}")
