# 安装依赖
pip install qrcode[pil]

# 运行程序
python password_generator_pro.py

# 转换为Windows可执行文件
pip install pyinstaller
pyinstaller --onefile --name="密码生成器Pro" password_generator_pro.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
高度随机密码生成器 Pro
支持多种复杂度模式、彩色终端输出、二维码生成与导出
"""

import secrets
import string
import os
import sys
from datetime import datetime
import re

try:
    import qrcode
    QRCODE_AVAILABLE = True
except ImportError:
    QRCODE_AVAILABLE = False

# ANSI颜色代码
class Colors:
    """终端颜色控制"""
    RESET = '\033[0m'
    BOLD = '\033[1m'
    
    # 前景色
    RED = '\033[91m'
    GREEN = '\033[92m'
    YELLOW = '\033[93m'
    BLUE = '\033[94m'
    MAGENTA = '\033[95m'
    CYAN = '\033[96m'
    WHITE = '\033[97m'
    
    # 背景色
    BG_BLACK = '\033[40m'
    BG_BLUE = '\033[44m'
    
    @staticmethod
    def disable():
        """禁用颜色（兼容不支持ANSI的终端）"""
        Colors.RESET = ''
        Colors.BOLD = ''
        Colors.RED = ''
        Colors.GREEN = ''
        Colors.YELLOW = ''
        Colors.BLUE = ''
        Colors.MAGENTA = ''
        Colors.CYAN = ''
        Colors.WHITE = ''
        Colors.BG_BLACK = ''
        Colors.BG_BLUE = ''

# 检测终端是否支持颜色
if not sys.stdout.isatty() or os.name == 'nt' and not os.environ.get('ANSICON'):
    # Windows默认不支持ANSI，除非使用Windows Terminal或启用了ANSICON
    try:
        # 尝试启用Windows 10+的ANSI支持
        import ctypes
        kernel32 = ctypes.windll.kernel32
        kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
    except:
        Colors.disable()


# 密码模式配置
PASSWORD_MODES = {
    1: {
        'name': '完整字符集',
        'description': '大小写字母 + 数字 + 特殊符号（最安全）',
        'charset': {
            'lowercase': string.ascii_lowercase,
            'uppercase': string.ascii_uppercase,
            'digits': string.digits,
            'special': "!@#$%^&*()-_=+[]{}|;:,.<>?/~`"
        },
        'min_length': 8
    },
    2: {
        'name': '基础字符集',
        'description': '大小写字母 + 数字 + 基础符号（兼容性好）',
        'charset': {
            'lowercase': string.ascii_lowercase,
            'uppercase': string.ascii_uppercase,
            'digits': string.digits,
            'special': "!@#$%^&*-_=+"
        },
        'min_length': 10
    },
    3: {
        'name': '字母数字混合',
        'description': '大小写字母 + 数字（适合老系统）',
        'charset': {
            'lowercase': string.ascii_lowercase,
            'uppercase': string.ascii_uppercase,
            'digits': string.digits,
            'special': ''
        },
        'min_length': 12
    },
    4: {
        'name': '纯字母型',
        'description': '仅大小写字母（特殊限制场景）',
        'charset': {
            'lowercase': string.ascii_lowercase,
            'uppercase': string.ascii_uppercase,
            'digits': '',
            'special': ''
        },
        'min_length': 15
    }
}


def print_header(text, color=Colors.CYAN):
    """打印彩色标题"""
    print(f"\n{color}{Colors.BOLD}{'=' * 60}")
    print(f"  {text}")
    print(f"{'=' * 60}{Colors.RESET}")


def print_separator(color=Colors.BLUE):
    """打印分隔线"""
    print(f"{color}{'-' * 60}{Colors.RESET}")


def print_success(text):
    """打印成功信息"""
    print(f"{Colors.GREEN}✓ {text}{Colors.RESET}")


def print_error(text):
    """打印错误信息"""
    print(f"{Colors.RED}✗ {text}{Colors.RESET}")


def print_warning(text):
    """打印警告信息"""
    print(f"{Colors.YELLOW}⚠ {text}{Colors.RESET}")


def print_info(text):
    """打印提示信息"""
    print(f"{Colors.CYAN}ℹ {text}{Colors.RESET}")


def generate_secure_password(length=15, mode=1):
    """
    生成高度随机的复杂密码
    
    Args:
        length: 密码长度
        mode: 密码模式 (1-4)
    
    Returns:
        str: 生成的密码
    """
    config = PASSWORD_MODES[mode]
    charset = config['charset']
    
    # 收集所有可用字符
    all_chars = ''
    required_chars = []
    
    # 构建字符集并确保每种类型至少有一个
    if charset['lowercase']:
        all_chars += charset['lowercase']
        required_chars.append(secrets.choice(charset['lowercase']))
    
    if charset['uppercase']:
        all_chars += charset['uppercase']
        required_chars.append(secrets.choice(charset['uppercase']))
    
    if charset['digits']:
        all_chars += charset['digits']
        required_chars.append(secrets.choice(charset['digits']))
    
    if charset['special']:
        all_chars += charset['special']
        required_chars.append(secrets.choice(charset['special']))
    
    # 填充剩余长度
    remaining_length = length - len(required_chars)
    password = required_chars + [secrets.choice(all_chars) for _ in range(remaining_length)]
    
    # 使用 Fisher-Yates 算法打乱顺序（密码学安全）
    for i in range(len(password) - 1, 0, -1):
        j = secrets.randbelow(i + 1)
        password[i], password[j] = password[j], password[i]
    
    return ''.join(password)


def display_qrcode_terminal(data, label=""):
    """在终端显示二维码"""
    if not QRCODE_AVAILABLE:
        print_warning("二维码显示不可用: qrcode库未安装")
        return
    
    try:
        qr = qrcode.QRCode(
            version=1,
            error_correction=qrcode.constants.ERROR_CORRECT_H,
            box_size=1,
            border=1,
        )
        qr.add_data(data)
        qr.make(fit=True)
        
        print(f"\n{Colors.YELLOW}{label}{Colors.RESET}")
        qr.print_ascii(invert=True)
    except Exception as e:
        print_error(f"终端二维码显示失败: {e}")


def save_qrcode_image(data, filename):
    """保存二维码为PNG图片"""
    if not QRCODE_AVAILABLE:
        return False
    
    try:
        qr = qrcode.QRCode(
            version=1,
            error_correction=qrcode.constants.ERROR_CORRECT_H,
            box_size=20,
            border=2,
        )
        qr.add_data(data)
        qr.make(fit=True)
        
        img = qr.make_image(fill_color="black", back_color="white")
        img.save(filename)
        return True
    except Exception as e:
        print_error(f"保存二维码 {filename} 失败: {e}")
        return False


def get_user_choice(prompt, default='N', valid_choices=None):
    """
    获取用户选择
    
    Args:
        prompt: 提示信息
        default: 默认值
        valid_choices: 有效选择列表，None表示不限制
    
    Returns:
        str: 用户选择（大写）
    """
    while True:
        choice = input(f"{Colors.CYAN}{prompt}{Colors.RESET}").strip().upper()
        
        if not choice:
            return default.upper()
        
        if valid_choices is None or choice in valid_choices:
            return choice
        
        print_error(f"无效的选择，请输入: {', '.join(valid_choices)}")


def parse_parameters(input_str):
    """解析用户输入的数量和长度参数"""
    # 分隔符：空格、逗号、顿号等
    parts = re.split(r'[,，、\s]+', input_str.strip())
    parts = [p for p in parts if p]
    
    if len(parts) != 2:
        print_error("请输入两个数字（个数和长度）")
        return None, None
    
    try:
        count = int(parts[0])
        length = int(parts[1])
        
        # 验证范围
        if not (1 <= count <= 50):
            print_error("个数必须在 1-50 之间")
            return None, None
        if not (6 <= length <= 50):
            print_error("长度必须在 6-50 之间")
            return None, None
        
        return count, length
    except ValueError:
        print_error("请输入有效的整数")
        return None, None


def display_mode_menu():
    """显示密码模式菜单"""
    print(f"\n{Colors.CYAN}{Colors.BOLD}请选择密码复杂度模式:{Colors.RESET}")
    for mode_id, config in PASSWORD_MODES.items():
        mode_color = Colors.GREEN if mode_id == 1 else Colors.WHITE
        print(f"{mode_color}  [{mode_id}] {config['name']}: {config['description']}")
        print(f"      推荐最小长度: {config['min_length']} 位{Colors.RESET}")


def display_password_list(passwords, mode):
    """以双色交替显示密码列表"""
    colors = [Colors.CYAN, Colors.MAGENTA]  # 交替使用青色和品红色
    
    print_header("生成的密码", Colors.GREEN)
    
    mode_info = PASSWORD_MODES[mode]
    print(f"{Colors.YELLOW}模式: {mode_info['name']} | 数量: {len(passwords)} | 长度: {len(passwords[0])}{Colors.RESET}\n")
    
    for i, pwd in enumerate(passwords, 1):
        color = colors[i % 2]
        print(f"{color}密码 {i:2d}: {Colors.BOLD}{pwd}{Colors.RESET}")


def save_password_list(passwords, timestamp, mode):
    """保存密码清单到文件"""
    filename = f"passwords_{timestamp}.txt"
    
    try:
        mode_info = PASSWORD_MODES[mode]
        with open(filename, 'w', encoding='utf-8') as f:
            f.write(f"密码生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
            f.write(f"密码模式: {mode_info['name']}\n")
            f.write(f"生成数量: {len(passwords)}\n")
            f.write(f"密码长度: {len(passwords[0])}\n")
            f.write("=" * 60 + "\n\n")
            for i, pwd in enumerate(passwords, 1):
                f.write(f"密码 {i}: {pwd}\n")
        
        print_success(f"密码清单已导出: {filename}")
        return True
    except Exception as e:
        print_error(f"导出失败: {e}")
        return False


def save_individual_passwords(passwords, timestamp):
    """单独保存每个密码"""
    success_count = 0
    
    for i, pwd in enumerate(passwords, 1):
        filename = f"{i}_{timestamp}.txt"
        try:
            with open(filename, 'w', encoding='utf-8') as f:
                f.write(pwd)
            success_count += 1
        except Exception as e:
            print_error(f"导出密码 {i} 失败: {e}")
    
    if success_count > 0:
        print_success(f"成功导出 {success_count}/{len(passwords)} 个密码文件")
    
    return success_count


def save_qrcode_images(passwords, timestamp):
    """保存所有二维码图片"""
    if not QRCODE_AVAILABLE:
        print_warning("qrcode库未安装，无法导出二维码图片")
        return 0
    
    success_count = 0
    
    for i, pwd in enumerate(passwords, 1):
        filename = f"{i}_{timestamp}.png"
        if save_qrcode_image(pwd, filename):
            success_count += 1
    
    if success_count > 0:
        print_success(f"成功导出 {success_count}/{len(passwords)} 个二维码图片")
    
    return success_count


def main():
    """主程序"""
    print_header("高度随机密码生成器 Pro", Colors.MAGENTA)
    
    if not QRCODE_AVAILABLE:
        print_warning("qrcode库未安装，二维码功能将不可用")
        print_info("安装命令: pip install qrcode[pil]\n")
    
    while True:
        # 步骤1: 选择密码模式
        display_mode_menu()
        
        mode_choice = get_user_choice(
            "\n选择模式 (1/2/3/4，默认1，回车=1): ",
            default='1',
            valid_choices=['1', '2', '3', '4']
        )
        mode = int(mode_choice)
        
        mode_info = PASSWORD_MODES[mode]
        print_info(f"已选择: {mode_info['name']}")
        
        # 长度建议
        if mode >= 3:
            print_warning(f"建议密码长度至少 {mode_info['min_length']} 位以保证安全性")
        
        # 步骤2: 询问参数
        print(f"\n{Colors.CYAN}默认将生成 1 个长度 15 的高度随机复杂密码{Colors.RESET}")
        choice = get_user_choice("是否要调整数量或长度？(N/Y，默认N): ", 'N', ['N', 'Y'])
        
        count = 1
        length = 15
        
        if choice == 'Y':
            while True:
                user_input = input(f"{Colors.CYAN}请输入个数和长度（用空格或逗号分隔，如: 3 20）: {Colors.RESET}").strip()
                count, length = parse_parameters(user_input)
                if count and length:
                    # 检查长度建议
                    if length < mode_info['min_length']:
                        print_warning(f"建议长度至少 {mode_info['min_length']} 位")
                        confirm = get_user_choice("是否继续使用当前长度？(Y/N): ", 'N', ['Y', 'N'])
                        if confirm == 'N':
                            continue
                    break
        
        print(f"\n{Colors.GREEN}正在生成 {count} 个长度为 {length} 的密码...{Colors.RESET}")
        
        # 生成密码
        passwords = [generate_secure_password(length, mode) for _ in range(count)]
        
        # 生成时间戳（14位）
        timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
        
        # 显示密码列表（双色）
        display_password_list(passwords, mode)
        
        # 步骤3: 显示二维码
        if QRCODE_AVAILABLE:
            print_header("密码二维码（终端显示）", Colors.BLUE)
            for i, pwd in enumerate(passwords, 1):
                display_qrcode_terminal(pwd, f"密码 {i}: {pwd}")
        
        # 步骤4: 导出所有密码到一个txt
        print_separator()
        choice = get_user_choice("是否导出密码清单到一个txt文件？(N/Y，默认N): ", 'N', ['N', 'Y'])
        
        if choice == 'Y':
            save_password_list(passwords, timestamp, mode)
        
        # 步骤5: 单独导出每个密码
        print_separator()
        choice = get_user_choice("是否把每个密码单独导出成txt文件？(N/Y，默认N): ", 'N', ['N', 'Y'])
        
        if choice == 'Y':
            save_individual_passwords(passwords, timestamp)
        
        # 步骤6: 导出二维码图片
        if QRCODE_AVAILABLE:
            print_separator()
            choice = get_user_choice("是否导出各密码的二维码图片？(N/Y，默认N): ", 'N', ['N', 'Y'])
            
            if choice == 'Y':
                save_qrcode_images(passwords, timestamp)
        
        # 步骤7: 询问是否继续
        print_header("操作完成！", Colors.GREEN)
        choice = get_user_choice("是否还要生成？(N/Y，默认N): ", 'N', ['N', 'Y'])
        
        if choice != 'Y':
            print(f"\n{Colors.MAGENTA}{Colors.BOLD}感谢使用！祝您密码安全！{Colors.RESET}\n")
            break
        
        print_header("开始新一轮生成...", Colors.CYAN)


if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print(f"\n\n{Colors.YELLOW}程序已被用户中断{Colors.RESET}")
    except Exception as e:
        print_error(f"发生错误: {e}")
        import traceback
        traceback.print_exc()