Gmail/main.py

import json
import shutil
import socket
import sys
import threading
from multiprocessing import freeze_support
from DrissionPage import ChromiumOptions, ChromiumPage
from DrissionPage.errors import *
import random
import time
import os
from filelock import FileLock
from openpyxl import load_workbook
import ctypes
from ctypes import wintypes
import uuid
import multiprocessing
import tkinter as tk
from tkinter import filedialog, messagebox, ttk
import string
from multiprocessing import Queue, Pool
from account import AccountManagerSQLite
from typing import List, Tuple
import win32gui
from mail import GoogleCodeReceiver, EmailClient
from proxy import ProxyManagerSQLite, classifier_smartproxy
from datetime import datetime, timedelta, timezone

# Windows 消息常量
WM_MOUSEMOVE = 0x0200
WM_LBUTTONDOWN = 0x0201
WM_LBUTTONUP = 0x0202
MK_LBUTTON = 0x0001

server = "server-10474.cuiqiu.vip"  # 替换为你的 IMAP 服务器地址
username = "gmailvinted@mailezu.com"
password = "g1l2o0hld84"

# 停止标志
stop_event = threading.Event()

user32 = ctypes.windll.user32

root_plugin_dir = os.path.join(os.getcwd(), 'proxy_auth_plugin')

proxy_manager = ProxyManagerSQLite(db_path="proxies.db")
db_manager = AccountManagerSQLite(db_path="accounts.db")


def init_worker():
    global proxy_manager, db_manager
    # 在每个子进程中初始化数据库管理器
    proxy_manager = ProxyManagerSQLite(db_path="proxies.db")
    db_manager = AccountManagerSQLite(db_path="accounts.db")


# 全局写入锁
write_lock = multiprocessing.Lock()

ua_templates = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/{webkit_version} (KHTML, like Gecko) Chrome/{chrome_version} Safari/{safari_version}",
    "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/{webkit_version} (KHTML, like Gecko) Chrome/{chrome_version} Safari/{safari_version}",
    "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/{webkit_version} (KHTML, like Gecko) Chrome/{chrome_version} Safari/{safari_version}",
    "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/{webkit_version} (KHTML, like Gecko) Chrome/{chrome_version} Safari/{safari_version}",
    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/{webkit_version} (KHTML, like Gecko) Chrome/{chrome_version} Safari/{safari_version}",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/{webkit_version} (KHTML, like Gecko) Chrome/{chrome_version} Safari/{safari_version}",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/{webkit_version} (KHTML, like Gecko) Chrome/{chrome_version} Safari/{safari_version}",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 11_2_3) AppleWebKit/{webkit_version} (KHTML, like Gecko) Chrome/{chrome_version} Safari/{safari_version}",
    "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:95.0) AppleWebKit/{webkit_version} (KHTML, like Gecko) Chrome/{chrome_version} Safari/{safari_version}",
    "Mozilla/5.0 (Windows NT 10.0) AppleWebKit/{webkit_version} (KHTML, like Gecko) Chrome/{chrome_version} Safari/{safari_version}"
]

# 自定义异常
class WindowMinimizedError(Exception):
    def __init__(self, message="浏览器窗口已最小化，无法执行操作。"):
        self.message = message
        super().__init__(self.message)

class GoogleCaptchaError(Exception):
    """出现谷歌文字验证错误"""
    pass

def is_window_minimized(hwnd):
    """检查窗口是否最小化"""
    return win32gui.IsIconic(hwnd)


def generate_user_agent():
    # 随机选择一个Chrome的UA模板
    selected_template = random.choice(ua_templates)

    # 随机生成 WebKit、Safari 和 Chrome 版本号
    webkit_version = f"{random.randint(500, 599)}.{random.randint(0, 99)}"
    safari_version = f"{random.randint(500, 599)}.{random.randint(0, 99)}"
    chrome_version = f"{random.randint(40, 99)}.{random.randint(0, 2999)}.{random.randint(0, 99)}"

    # 填充模板中的动态部分并生成完整的UA
    user_agent = selected_template.format(
        webkit_version=webkit_version,
        safari_version=safari_version,
        chrome_version=chrome_version
    )

    return user_agent


def random_sleep(tab, min_seconds=1, max_seconds=3):
    """在 min_seconds 和 max_seconds 之间随机停顿"""
    tab.wait(random.uniform(min_seconds, max_seconds))



def get_free_port():
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.bind(('localhost', 0))  # 使用端口0让操作系统自动选择一个未占用的端口
    port = s.getsockname()[1]
    s.close()
    return port
# 设置代理ip

def create_proxy_auth_extension(proxy_host, proxy_port, proxy_username, proxy_password, scheme='PROXY', proxy_domains=None):
    # Define a root directory
    root_plugin_dir = os.path.join(os.getcwd(), 'proxy_auth_plugin')
    if not os.path.exists(root_plugin_dir):
        os.makedirs(root_plugin_dir)  # Create root directory

    # Use a unique identifier to generate a separate plugin directory
    plugin_path = os.path.join(root_plugin_dir, f'plugin_{uuid.uuid4().hex}')
    os.makedirs(plugin_path)  # Create plugin directory

    # Contents of manifest.json for the plugin
    manifest_json = """
    {
        "version": "1.0.0",
        "manifest_version": 2,
        "name": "Proxy Auth Extension",
        "permissions": [
            "proxy",
            "tabs",
            "unlimitedStorage",
            "storage",
            "<all_urls>",
            "webRequest",
            "webRequestBlocking"
        ],
        "background": {
            "scripts": ["background.js"]
        },
        "minimum_chrome_version":"22.0.0"
    }
    """

    # Ensure proxy_domains is a list
    if proxy_domains is None:
        proxy_domains = []

    # Generate domains_list for PAC script
    # Since we can only match on hostnames, we use the domain names
    domains_list = ', '.join('"{}"'.format(domain) for domain in proxy_domains)

    # Generate PAC script
    pac_script = string.Template(
        '''
        function FindProxyForURL(url, host) {
            var proxy = "${scheme} ${proxy_host}:${proxy_port}";
            var direct = "DIRECT";

            var domains = [${domains_list}];

            for (var i = 0; i < domains.length; i++) {
                if (dnsDomainIs(host, domains[i])) {
                    return proxy;
                }
            }
            return direct;
        }
        '''
    ).substitute(
        scheme=scheme.upper(),
        proxy_host=proxy_host,
        proxy_port=proxy_port,
        domains_list=domains_list
    )

    # Since we cannot inspect the full URL in onAuthRequired, we'll listen to all URLs
    # But we'll check if the proxy is challenging for authentication
    # We can do this by checking the 'isProxy' flag in the details
    # However, 'isProxy' is only available in certain contexts
    # Alternatively, we can restrict the listener to the proxy server

    # Contents of background.js, using string templates to insert dynamic configuration
    background_js = string.Template(
    '''
    var config = {
        mode: "pac_script",
        pacScript: {
            data: $pac_script
        }
    };

    chrome.proxy.settings.set({value: config, scope: "regular"}, function() {});

    function callbackFn(details) {
        if (details.challenger && details.challenger.host === "${proxy_host}" && details.challenger.port == ${proxy_port}) {
            return {
                authCredentials: {
                    username: "${username}",
                    password: "${password}"
                }
            };
        }
    }

    chrome.webRequest.onAuthRequired.addListener(
        callbackFn,
        {urls: ["<all_urls>"]},
        ['blocking']
    );
    '''
    ).substitute(
        pac_script=json.dumps(pac_script),
        username=proxy_username,
        password=proxy_password,
        proxy_host=proxy_host,
        proxy_port=proxy_port
    )


    # Write manifest.json and background.js to the plugin directory
    with open(os.path.join(plugin_path, 'manifest.json'), 'w') as f:
        f.write(manifest_json)

    with open(os.path.join(plugin_path, 'background.js'), 'w') as f:
        f.write(background_js)

    # Return the unique plugin path
    return plugin_path


def delete_folder(file_path):
    """
    删除指定的代理插件文件夹及其内容
    :param plugin_path: 代理插件文件夹路径
    """
    if os.path.exists(file_path):
        shutil.rmtree(file_path)


# 获取窗口标题
def get_window_title(hwnd):
    length = user32.GetWindowTextLengthW(hwnd)
    if length > 0:
        buffer = ctypes.create_unicode_buffer(length + 1)
        user32.GetWindowTextW(hwnd, buffer, length + 1)
        return buffer.value
    return ""


# 枚举所有窗口
def enum_windows():
    windows = []

    def callback(hwnd, lparam):
        title = get_window_title(hwnd)
        if title and "Google Chrome" in title:
            windows.append((hwnd, title))
        return True

    EnumWindowsProc = ctypes.WINFUNCTYPE(ctypes.c_bool, wintypes.HWND, ctypes.c_void_p)
    user32.EnumWindows(EnumWindowsProc(callback), 0)
    return windows


def find_gmail_window(windows, target_title):
    for hwnd, title in windows:
        if target_title in title:  # 判断目标标题是否包含在窗口标题中
            return hwnd
    return None


# 模拟鼠标事件
def simulate_mouse(hwnd, x, y):
    lParam = (y << 16) | x
    user32.PostMessageW(hwnd, WM_MOUSEMOVE, 0, lParam)
    user32.PostMessageW(hwnd, WM_LBUTTONDOWN, MK_LBUTTON, lParam)
    user32.PostMessageW(hwnd, WM_LBUTTONUP, 0, lParam)


def click_the_login_button(tab, login_a):
    # 获取href属性
    href = login_a.attr('href')
    # 访问href属性指向的页面
    tab.get(href)


def input_email(tab, hwnd, email, email_input, max_retries=3):
    """
    输入账号并点击“下一步”按钮。如果两次尝试都未成功，退出。
    :param tab: 浏览器对象
    :param email: 用户的邮箱账号
    :param email_input: 输入框对象
    :param max_retries: 最大尝试次数
    """
    if is_window_minimized(hwnd):
        raise WindowMinimizedError("浏览器窗口已最小化，无法执行操作。")

    email_input.clear()

    # 模拟人类输入，每次输入一个字符，并随机延迟
    for char in email:
        email_input.input(char)  # 输入一个字符
        tab.wait(random.uniform(0.1, 0.3))  # 随机延迟 0.1 到 0.3 秒

    tab.wait(1)

    next_input = tab.ele('@type=button', timeout=15, index=3)

    # 将按钮拖拽到页面顶部位置
    next_input.drag_to((0, 0), 0)
    next_input.set.style('position', 'absolute')
    next_input.set.style('top', '0')
    next_input.set.style('left', '0')
    next_input.set.style('width', '1000px')
    next_input.set.style('height', '1000px')

    tab.wait(2)

    retry_count = 0
    while retry_count < max_retries:
        # 模拟点击操作
        simulate_mouse(hwnd, 650, 650)

        # 等待页面加载开始
        tab.wait.load_start()

        # 等待7秒，看按钮是否消失
        flag = tab.wait.ele_deleted(next_input, timeout=7)
        if flag:
            print(f"第 {retry_count + 1} 次尝试成功，按钮已消失。")
            return True
        else:
            retry_count += 1  # 增加尝试次数
            print(f"第 {retry_count} 次尝试失败，按钮未消失，重新尝试...")

        if retry_count >= max_retries:
            # 两次尝试都失败，调整按钮大小为10px
            next_input.set.style('width', '10px')
            next_input.set.style('height', '10px')
            print(f"尝试 {max_retries} 次仍未成功，调整按钮大小并退出。")
            raise GoogleCaptchaError("出现谷歌文字验证")


# 点击重试按钮
def recover(tab, recover_a):
    recover_a.click(by_js=True)


def input_password(tab, hwnd, password, password_input, max_retries=2):
    # 检查窗口是否最小化
    if is_window_minimized(hwnd):
        raise WindowMinimizedError("浏览器窗口已最小化，无法执行操作。")

    password_input.clear()
    """
    输入密码并点击“下一步”按钮
    :param tab: 浏览器对象
    :param password: 用户的密码
    """
    # 模拟人类输入密码，每次输入一个字符，并随机延迟
    for char in password:
        password_input.input(char)  # 输入一个字符
        tab.wait(random.uniform(0.1, 0.3))  # 随机延迟 0.1 到 0.3 秒

    random_sleep(tab)

    next_input = tab.ele('@type=button', timeout=15, index=2)

    # 将按钮拖拽到页面顶部位置
    next_input.drag_to((0, 0), 0)
    next_input.set.style('position', 'absolute')
    next_input.set.style('top', '0')
    next_input.set.style('left', '0')
    next_input.set.style('width', '1000px')
    next_input.set.style('height', '1000px')

    tab.wait(2)
    retry_count = 0
    while retry_count < max_retries:
        # 模拟点击操作
        simulate_mouse(hwnd, 700, 700)

        # 等待页面加载开始
        tab.wait.load_start()

        # 等待7秒，看按钮是否消失
        flag = tab.wait.ele_deleted(next_input, timeout=7)
        if flag:
            print(f"第 {retry_count + 1} 次尝试成功，按钮已消失。")
            break  # 按钮成功消失，跳出循环
        else:
            # 获取页面提示信息
            text = ""
            try:
                text = tab.ele('@aria-live=polite', timeout=1).text
            except Exception as e:
                print("获取页面提示失败:", e)

            print(f"页面提示: {text}")

            if text == "":
                retry_count += 1
                print(f"页面提示为空，第 {retry_count} 次尝试失败，重新尝试...")
            else:
                print(f"页面提示不为空：{text}, 不进行重试，退出。")
                break  # 页面提示不为空，退出重试流程

        if retry_count >= max_retries:
            # 两次尝试都失败，调整按钮大小为10px
            next_input.set.style('width', '10px')
            next_input.set.style('height', '10px')
            print(f"尝试 {max_retries} 次仍未成功，调整按钮大小并退出。")
            raise GoogleCaptchaError("输入密码后无法点击下一步")




def click_alternate_email_verification_button(tab, email_div):
    email_div.click(by_js=True)

    tab.wait.load_start()


def input_recovery_code(tab, recovery_code):
    """
    输入辅助邮箱的验证码并点击“下一步”按钮
    :param tab: 浏览器对象
    :param recovery_code: 辅助邮箱的验证码
    """
    # 第一步：通过 class 定位到辅助邮箱的输入框
    recovery_input = tab.ele('@aria-label=输入辅助邮箱地址', timeout=15)

    for char in recovery_code:
        recovery_input.input(char)  # 输入一个字符
        tab.wait(random.uniform(0.1, 0.3))  # 随机延迟

    next_input = tab.ele('@@tag()=span@@text()=下一步', timeout=15)
    next_input.click(by_js=True)

    print("到这里我已经点完下一步，进入修改辅助邮箱的地方了")

    tab.wait.load_start()

    tab.wait(1)

    retry = tab.ele("@text()=您输入的电子邮件地址不正确，请重试。",timeout=15)
    if retry:
        return True

    return False


# 找到修改邮箱的按钮
def click_use_other_account_button2(tab, next_span):
    next_span.click(by_js=True)

    tab.wait.load_start()


# 修改辅助邮箱账号
def modify_the_secondary_email1(tab, button, auxiliary_email_account):
    button.click(by_js=True)
    tab.wait(2)
    input = button
    input.clear()
    for char in auxiliary_email_account:
        input.input(char)  # Enter one character at a time
        tab.wait(random.uniform(0.1, 0.3))  # Random delay between 0.1 and 0.3 seconds

    # 点击保存
    save_span = tab.ele('@text()=Save', timeout=15)
    save_span.click(by_js=True)

    button = tab.ele('@text()=Not now',timeout=15)
    button.click(by_js=True)
    tab.wait.load_start()


def click_continue_button(tab, continue_div1):
    # 点击出现的弹窗
    tab.handle_alert(accept=True)
    tab.wait(1)
    continue_div1.click(by_js=True)
    tab.wait(1)
    next_button = tab.ele('@@tag()=button@@name=data_consent_dialog_next', timeout=15)
    next_button.click(by_js=True)
    tab.wait(1)
    continue_div2 = tab.ele('@text()=Personalize other Google products with my Gmail, Chat, and Meet data', timeout=15)
    continue_div2.click(by_js=True)
    tab.wait(1)
    Done_button = tab.ele('@name=data_consent_dialog_done', timeout=15)
    Done_button.click(by_js=True)
    tab.wait(15)
    Reload = tab.ele('@text()=Reload', timeout=15)
    if Reload:
        Reload.click(by_js=True)


def find_and_visit_href2(tab):
    password_a = tab.ele('@aria-label=Password', timeout=15)
    print(password_a)
    href = password_a.attr('href')
    tab.get(href)


def input_password_new(tab, password):
    """
    输入密码并点击“下一步”按钮
    :param tab: 浏览器对象
    :param password: 用户的密码
    """

    password_input = tab.ele('@@tag()=input@@name=password')

    # 模拟人类输入密码，每次输入一个字符，并随机延迟
    for char in password:
        password_input.input(char)  # 输入一个字符
        tab.wait(random.uniform(0.1, 0.3))  # 随机延迟 0.1 到 0.3 秒

    confirm_new_password_input = tab.ele("@@tag()=input@@name=confirmation_password")
    # 模拟人类输入密码，每次输入一个字符，并随机延迟
    for char in password:
        confirm_new_password_input.input(char)  # 输入一个字符
        tab.wait(random.uniform(0.1, 0.3))  # 随机延迟 0.1 到 0.3 秒


# 点击修改按钮
def click_span_with_class(tab):
    # 找到 class 为 UywwFc vQzf8d 的元素
    span_element = tab.ele('@text()=Change password', timeout=15)

    # 用 JavaScript 点击该元素
    span_element.click(by_js=True)

    # 返回上个页面
    tab.back()


# 修改辅助邮箱账号2
def modify_the_secondary_email2(tab, new_recovery_email, new_password, hwnd):
    try:
        # 定位恢复邮箱的元素
        recovery_email = tab.ele("@aria-label=Recovery email", timeout=15)
        if not recovery_email:
            raise Exception("未找到恢复邮箱元素")

        # 获取恢复邮箱的链接并导航
        href = recovery_email.attr('href')
        if not href:
            raise Exception("恢复邮箱链接未找到")

        tab.get(href)

        password_input = tab.ele('@@aria-label=输入您的密码@@type=password', timeout=15)
        if password_input:
            input_password(tab, hwnd, new_password, password_input)

        tab.wait.load_start()  # 等待页面加载开始

        # 定位邮箱输入框并清空内容
        email_input = tab.ele("@type=email", timeout=15)

        # 查看辅助邮箱账号是否已经被修改了
        if email_input.value == new_recovery_email:
            return True

        if not email_input:
            raise Exception("未找到邮箱输入框")

        email_input.clear()

        for char in new_recovery_email:
            email_input.input(char)  # 输入一个字符
            tab.wait(random.uniform(0.1, 0.3))  # 随机延迟 0.1 到 0.3 秒

        # 定位并点击验证按钮
        verify_button = tab.ele("@text()=Verify", timeout=15)
        print(f"验证按钮已经找到：{verify_button}")
        if not verify_button:
            raise Exception("未找到验证按钮")

        verify_button.click(by_js=True)

        return False  # 成功返回 True
    except Exception as e:
        print(f"更新恢复邮箱时发生错误: {e}")
        return False  # 出现错误返回 False


# 定义保存到本地文件的函数
def save_to_file(entry, filename="code.txt"):
    """将条目保存到本地文件，避免重复"""
    # 如果文件不存在，先创建空文件
    if not os.path.exists(filename):
        with open(filename, "w", encoding='utf-8') as file:
            pass  # 创建文件

    # 读取文件内容，检查是否存在相同条目
    with open(filename, "r", encoding='utf-8') as file:
        existing_entries = file.readlines()

    # 构造条目字符串
    entry_str = f"验证码: {entry['验证码']}, 发送的邮箱账号: {entry['发送的邮箱账号']}, 收到的时间: {entry['收到的时间']}\n"

    if entry_str not in existing_entries:  # 如果条目不在文件中
        # 以追加模式写入文件
        with open(filename, "a", encoding='utf-8') as file:
            file.write(entry_str)
        print("--------------------------------------------------")
        print(f"新条目已保存: {entry_str.strip()}")


def clean(text):
    """清理邮件主题或发件人内容中的特殊字符"""
    return "".join(c if c.isalnum() else "_" for c in text)




# 用来标记账号是否完成
def update_status_in_db(email: str, status: str):
    """
    更新数据库中指定账户的状态。
    """
    # 更新数据库中对应账户的状态
    db_manager.update_record(email=email, change_status=status)

    # 输出日志信息
    print(f"账号 {email} 的状态已更新为：{status}")



# 保存日志到指定文件
def save_log(random_number, log_content):
    logs_dir = "logs"

    # 创建文件名，使用传入的 random_number
    log_file_path = os.path.join(logs_dir, f"{random_number}.txt")

    # 将日志内容写入文件
    with open(log_file_path, 'a', encoding='utf-8') as f:
        f.write(log_content)
        f.write("\n")


def retry_with_recovery(tab, hwnd, email_account, MAX_RETRIES=4, wait_time=5):
    """
    封装重试逻辑，最多尝试 `MAX_RETRIES` 次，检查是否存在重试按钮，并重新输入邮箱地址。

    :param tab: 页面操作对象，假设具备 `.ele` 方法用于获取元素，`.wait.load_start()` 方法用于等待加载
    :param recover: 处理重试按钮点击的函数
    :param email_account: 需要输入的邮箱账号
    :param MAX_RETRIES: 最大重试次数，默认为4次
    :param wait_time: 等待时间，默认为15秒
    """
    attempt = 0  # 初始化尝试次数

    while attempt < MAX_RETRIES:
        recover_a = tab.ele("@aria-label=重试", timeout=wait_time)  # 检查是否有 '重试' 按钮
        print(f"Attempt {attempt + 1}: {recover_a}")
        tab.wait.load_start()  # 等待加载开始

        if recover_a:
            recover(tab, recover_a)  # 调用 recover 函数处理重试按钮
            email_input = tab.ele('@aria-label=电子邮件地址或电话号码', timeout=wait_time)  # 找到邮箱输入框
            input_email(tab, hwnd, email_account, email_input)  # 重新输入邮箱账号
            random_sleep(tab)  # 随机等待，避免被检测到自动化
            attempt += 1  # 增加尝试次数
        else:
            break  # 如果没有 '重试' 按钮，则跳出循环

        # 如果达到最大尝试次数，跳出循环
        if attempt == MAX_RETRIES:
            print("Reached maximum retries")
            break


def get_absolute_path(relative_path):
    """获取绝对路径"""
    # 获取当前执行文件的路径（脚本或.exe）
    if getattr(sys, 'frozen', False):  # 检测是否为打包后的exe
        base_path = sys._MEIPASS  # PyInstaller打包后资源文件临时路径
        exe_path = os.path.dirname(sys.executable)
    else:
        base_path = os.path.abspath(".")
        exe_path = os.path.dirname(os.path.abspath(__file__))

    # 如果需要拼接在exe路径上：
    absolute_path = os.path.join(exe_path, relative_path)
    return absolute_path


def logutGoogle(tab) -> bool:
    tab.get('https://accounts.google.com/Logout?hl=zh-CN')
    if tab.ele('@@tag()=input@@type=email', timeout=0) != None:  # 已注销就会出登录页元素
        print("当前浏览器已退出,无需再次退出")
        return True

    # 还有没注销移除的账号就会显示已退出和账号元素
    try:
        tab.ele('@text()=移除账号', timeout=0).click()
        tab.wait(2).ele('@text()=已退出', timeout=0).parent().parent().next().click()  # 移除图标
        tab.wait(3).ele('@@text()=移除@@tag()=button').click()  # 移除确认框
        return (tab.ele('@@tag()=input@@type=email', timeout=8) != None)  # 检查最后界面是否是登录
    except Exception as e:
        print(f'发生错误:{e}')
        return False

    return False  # 无用分支，不过为了避免函数太长回头修改时候忘记，还是写个 False 以防万一


def main(email_account, email_password, old_recovery_email, new_password, new_recovery_email, proxy_host, proxy_port, proxy_username, proxy_password,region):
    update_status_in_db(email_account, '初始化中')

    print("邮箱账户:", email_account)  # 邮箱账户
    print("邮箱密码:", email_password)  # 邮箱密码
    print("旧的恢复邮箱:", old_recovery_email)  # 旧的恢复邮箱
    print("新的密码:", new_password)  # 新的密码
    print("新的恢复邮箱:", new_recovery_email)  # 新的恢复邮箱
    print("代理主机:", proxy_host)  # 代理主机
    print("代理端口:", proxy_port)  # 代理端口
    print("代理用户名:", proxy_username)  # 代理用户名
    print("代理密码:", proxy_password)  # 代理密码
    print("代理区域：", region)
    global browser, plugin_path, user_dir, attempt
    # 生成一个 6 位的随机数
    global random_number



    try:
        random_number = str(random.randint(100000000, 999999999))
        """
        主函数，用于自动登录谷歌邮箱并修改账户和密码。

        参数:
            email_account (str): 邮箱账号
            email_password (str): 邮箱密码
            old_recovery_email (str): 旧的辅助邮箱账号
            new_recovery_email (str): 新的辅助邮箱账号
            new_password (str): 新密码
        """
        if stop_event.is_set():
            print("任务被强制停止，退出主函数")
            return None  # 直接返回 None，跳过当前任务

        if not proxy_host:
            save_log(random_number, f"没有{region}区域的代理")
            update_status_in_db(email_account, f"没有{region}区域代理")
            return False


        lock = FileLock("proxy_auth_extension.lock")

        with lock:  # 加锁，确保其他进程在解锁前无法操作
            plugin_path = create_proxy_auth_extension(
                proxy_host=proxy_host,
                proxy_port=proxy_port,
                proxy_username=proxy_username,
                proxy_password=proxy_password,
                proxy_domains=[
                    "accounts.google.com",
                    "accounts.youtube.com",
                    "content-autofill.googleapis.com",
                    "myaccount.google.com",
                    "apis.google.com",
                    "www.google.com",
                    "ogs.google.com",
                    "jsonip.com"
                ]
            )
            save_log(random_number, f"已经创建好代理插件：{plugin_path}")

        # 创建ChromiumOptions对象并配置
        options = ChromiumOptions()

        options.add_extension(plugin_path)

        # 使用随机生成的User-Agent
        random_user_agent = generate_user_agent()
        options.set_user_agent(user_agent=random_user_agent)

        # 随机分配一个端口号
        random_port = get_free_port()
        print(f"现在占用的端口号是：{random_port}")
        save_log(random_number, f"现在占用的端口号是：{random_port}")
        options.set_paths(local_port=random_port)

        # 示例使用
        browser_path = get_absolute_path(r"chrome\chrome.exe")
        options.set_paths(f"{browser_path}")

        options.no_imgs(True).mute(True)

        cache_path = os.path.join(os.getcwd(), 'cache')
        temp_path = os.path.join(os.getcwd(), 'tempfile')
        user_dir = os.path.join(os.getcwd(), 'userdata', f'{uuid.uuid4().hex}')

        options.set_cache_path(cache_path)
        options.set_tmp_path(temp_path)
        options.set_user_data_path(user_dir)

        print(cache_path)
        print(temp_path)
        print(user_dir)

        options.set_pref(arg='profile.default_content_settings.popups', value='0')
        options.set_pref('translate.enabled', False)  # 禁用翻译功能
        options.set_pref('translate.newtld', False)  # 禁用新的翻译扩展功能

        # 确保不显示翻译提示
        options.set_pref('profile.content_settings.exceptions.translate', '{"pattern":"*","setting":2}')

        browser = ChromiumPage(options)

        # 清除缓存和cookies
        browser.clear_cache(cookies=True)
        # browser = Chromium(29581)

        # 获取标签页对象
        tab = browser.latest_tab
        save_log(random_number, "已获取谷歌的最后一个页面")

        # 访问谷歌邮箱页面
        flag = tab.get('https://workspace.google.com/intl/zh-CN/gmail/')
        save_log(random_number, f"访问谷歌邮箱页面的状态：{flag}")
        if not flag:
            update_status_in_db(email_account, "无法访问谷歌邮箱页面，请重试")
            return (
                email_account, email_password, old_recovery_email, new_password, new_recovery_email, proxy_host,
                proxy_port,
                proxy_username, proxy_password, region)

        save_log(random_number, "已经访问谷歌页面")

        # 执行JavaScript清除localStorage
        tab.run_js("window.localStorage.clear();")


        # 进入登录流程
        login_a = tab.ele('@aria-label=登录 Gmail', timeout=15)
        if login_a:
            click_the_login_button(tab, login_a)
            random_sleep(tab)

        login = tab.ele('@@tag()=span@@text()=登录', timeout=10)
        if login:
            random_sleep(tab)
            # 将随机数设置为窗口标题
            script = f"document.title = '{random_number}';"
            # 执行 JS 脚本
            tab.run_js(script)
            print("登录运行完毕")
            save_log(random_number, "已经进入登录界面")
        else:
            update_status_in_db(email_account, '登录超时')
            return (
                email_account, email_password, old_recovery_email, new_password, new_recovery_email, proxy_host,
                proxy_port,
                proxy_username, proxy_password, region)

        random_sleep(tab)

        actual_title = tab.run_js("return document.title;")

        save_log(random_number, f"设置标题为: {random_number}, 实际标题为: {actual_title}\n")

        # 获取所有 Chrome 窗口
        chrome_windows = enum_windows()
        save_log(random_number, f"当前谷歌浏览器的所有窗口为：{chrome_windows}")
        hwnd = None
        for win in chrome_windows:
            if random_number in win[1]:  # 假设 `win['title']` 是窗口标题
                hwnd = win[0]
                print(f"窗口句柄：{win[0]} 窗口标题：{win[1]}")
                save_log(random_number, f"获取的窗口的句柄：{win[0]} 和标题：{win[1]}")
                break

        if hwnd is None:
            print("无法找到窗口句柄")
            save_log(random_number, "无法找到窗口句柄")
            update_status_in_db(email_account, '无法找到窗口句柄')
            return (
                email_account, email_password, old_recovery_email, new_password, new_recovery_email, proxy_host,
                proxy_port,
                proxy_username, proxy_password, region)

        try:
            # 输入邮箱账号
            email_input = tab.ele('@aria-label=电子邮件地址或电话号码', timeout=15)
            if email_input:
                flag = input_email(tab, hwnd, email_account, email_input)  # 使用传入的邮箱账号
                if not flag:
                    update_status_in_db(random_number, "出现谷歌文字验证")
                    return (
                        email_account, email_password, old_recovery_email, new_password, new_recovery_email, proxy_host,
                        proxy_port,
                        proxy_username, proxy_password, region)
                random_sleep(tab)
        except ElementNotFoundError as e:
            print(f"找不到输入邮箱账号的元素{e}")
            save_log(random_number, f"找不到输入邮箱账号的元素:{e}")
            update_status_in_db(email_account, "请求错误，请重试")
            return (
                email_account, email_password, old_recovery_email, new_password, new_recovery_email, proxy_host,
                proxy_port,
                proxy_username, proxy_password, region)

        print("输入邮箱账号运行完毕")
        save_log(random_number, "输入邮箱账号运行完毕")

        wrong = tab.ele('@text()=出了点问题', timeout=5)
        if wrong:
            next_span = tab.ele("@@tag()=span@@text()=下一步", timeout=15)
            next_span.click(by_js=True)
            tab.wait.load_start()
            try:
                # 输入邮箱账号
                email_input = tab.ele('@aria-label=电子邮件地址或电话号码', timeout=15)
                if email_input:
                    input_email(tab, hwnd, email_account, email_input)  # 使用传入的邮箱账号
                    random_sleep(tab)
            except ElementNotFoundError as e:
                print(f"找不到输入邮箱账号的元素{e}")
                save_log(random_number, f"找不到输入邮箱账号的元素:{e}")
                update_status_in_db(email_account, "请求错误，请重试")
                return (
                    email_account, email_password, old_recovery_email, new_password, new_recovery_email, proxy_host,
                    proxy_port,
                    proxy_username, proxy_password, region)

        retry_with_recovery(tab, hwnd, email_account)

        print("检查是否出现了wrong运行完毕")
        save_log(random_number, "检查是否出现了wrong运行完毕")

        # 看下是否出现了手机号
        telephone = tab.ele("@text()=请输入电话号码，以便通过短信接收验证码。", timeout=5)
        if telephone:
            update_status_in_db(email_account, '接码')
            browser.quit()
            return

        print("检查出现手机号运行完毕")
        save_log(random_number, "检查出现手机号运行完毕")

        try:
            # 输入密码
            password_input = tab.ele('@@aria-label=输入您的密码@@type=password', timeout=15)
            if password_input:
                flag = input_password(tab, hwnd, email_password, password_input)  # 使用传入的邮箱密码
                if flag:
                    update_status_in_db(email_account, "密码的下一步无法点击")
                    return (
                        email_account, email_password, old_recovery_email, new_password, new_recovery_email, proxy_host,
                        proxy_port,
                        proxy_username, proxy_password, region)
                random_sleep(tab)
        except ElementNotFoundError as e:
            print(f"找不到密码输入框的元素:{e}")
            save_log(random_number, f"找不到密码输入框的元素:{e}")
            update_status_in_db(email_account, "请求错误，请重试")
            return (
                email_account, email_password, old_recovery_email, new_password, new_recovery_email, proxy_host,
                proxy_port,
                proxy_username, proxy_password, region)

        print("输入旧密码运行完毕")
        save_log(random_number, "输入旧密码运行完毕")

        wrong = tab.ele("@text()=抱歉，出了点问题。请重试。", timeout=15)
        save_log(random_number, f"谷歌验证按钮是否出现：{wrong}")
        if wrong:
            next_span = tab.ele("@@tag()=span@@text()=下一步", timeout=15)
            next_span.click(by_js=True)
            tab.wait.load_start()
            try:
                # 输入邮箱账号
                email_input = tab.ele('@aria-label=电子邮件地址或电话号码', timeout=15)
                if email_input:
                    input_email(tab, hwnd, email_account, email_input)  # 使用传入的邮箱账号
                    random_sleep(tab)
            except ElementNotFoundError as e:
                print(f"找不到输入邮箱账号的元素{e}")
                save_log(random_number, f"找不到输入邮箱账号的元素:{e}")
                update_status_in_db(email_account, "请求错误，请重试")
                return (
                    email_account, email_password, old_recovery_email, new_recovery_email, new_password, proxy_host,
                    proxy_port,
                    proxy_username, proxy_password)

            try:
                # 输入密码
                password_input = tab.ele('@@aria-label=输入您的密码@@type=password', timeout=15)
                if password_input:
                    input_password(tab, hwnd, email_password, password_input)  # 使用传入的邮箱密码
                    random_sleep(tab)
            except ElementNotFoundError as e:
                print(f"找不到密码输入框的元素:{e}")
                save_log(random_number, f"找不到密码输入框的元素:{e}")
                update_status_in_db(email_account, "请求错误，请重试")
                return (
                    email_account, email_password, old_recovery_email, new_password, new_recovery_email, proxy_host,
                    proxy_port,
                    proxy_username, proxy_password, region)

        print("如果出现错误，输入密码运行完毕")
        save_log(random_number, "如果出现错误后，输入密码运行完毕")

        # 确定密码是否被修改的开关
        password_change = False

        try:
            # 查看密码是否更改
            if tab.wait.ele_deleted('#passwordNext', timeout=5) == False:
                save_log(random_number, f"旧密码出错，使用新密码")
                password_input = tab.ele('@@aria-label=输入您的密码@@type=password', timeout=15)
                input_password(tab, hwnd, new_password, password_input)
                save_log(random_number, f"输入新密码完毕")
                tab.wait(7)
                if tab.wait.ele_deleted('#passwordNext', timeout=10) == False:
                    update_status_in_db(email_account, '被盗')
                    return email_account
                password_change = True
                print("密码已经被更改过")
                save_log(random_number, "密码已经被更改过")
        except ElementNotFoundError as e:
            print(f"找不到密码输入框的元素{e}")
            save_log(random_number, f"找不到密码输入框的元素:{e}")
            update_status_in_db(email_account, "请求错误，请重试")
            return (
                email_account, email_password, old_recovery_email, new_password, new_recovery_email, proxy_host,
                proxy_port,
                proxy_username, proxy_password, region)

        print("输入新密码运行完毕")
        save_log(random_number, "输入新密码运行完毕")

        # 看下是否出现了手机号
        telephone = tab.ele("@text()=请输入电话号码，以便通过短信接收验证码。", timeout=5)
        if telephone:
            save_log(random_number, '接码')
            update_status_in_db(email_account, '接码')
            return email_account

        print("检查手机号2运行完毕")
        save_log(random_number, "检查手机号2运行完毕")

        wrong = tab.ele('@@tag()=a@@text()=了解详情', timeout=5)
        alternate_email_button = tab.ele('@text()=确认您的辅助邮箱', timeout=5)
        if wrong and not alternate_email_button:
            save_log(random_number, '出现账号状态异常')
            update_status_in_db(email_account, '出现账号状态异常')
            return (
                email_account, email_password, old_recovery_email, new_password, new_recovery_email, proxy_host,
                proxy_port,
                proxy_username, proxy_password, region)

        print("检查谷歌账号是否存在异常活动完毕")
        save_log(random_number, "检查谷歌账号是否存在异常活动完毕")


        try:
            if alternate_email_button:
                click_alternate_email_verification_button(tab, alternate_email_button)
                random_sleep(tab)
        except ElementNotFoundError as e:
            print(f"找不到输入辅助邮箱的元素：{e}" )
            save_log(random_number, f"找不到输入辅助邮箱的元素：{e}")
            update_status_in_db(email_account, "请求错误，请重试")
            return (
                email_account, email_password, old_recovery_email, new_password, new_recovery_email, proxy_host,
                proxy_port,
                proxy_username, proxy_password, region)

        print("点击辅助邮箱验证运行完毕")
        save_log(random_number, "点击辅助邮箱验证运行完毕")

        # 确定辅助邮箱账号是否被更改
        auxiliary_email_account_change = False

        # 输入辅助邮箱账号
        recovery_input = tab.ele('@aria-label=输入辅助邮箱地址', timeout=15)
        if recovery_input:
            auxiliary_email_account_change = input_recovery_code(tab, old_recovery_email)  # 使用传入的旧辅助邮箱
            print(f"是否有修改辅助邮箱账号：{auxiliary_email_account_change}")
            tab.wait(5)
            # 如果没有被修改则进行修改
            if not auxiliary_email_account_change:

                print("我要开始修改辅助邮箱账号了")

                try:
                    button = tab.ele('@type=email', timeout=15)
                    if button:
                        modify_the_secondary_email1(tab,button, new_recovery_email)  # 使用传入的新辅助邮箱
                        print("修改完成")
                        auxiliary_email_account_change = True
                    else:
                        print("没有修改辅助邮箱的界面，跳过")
                    # auxiliary_email_account_change = True
                except ElementNotFoundError as e:
                    # 捕获并打印异常，不中断后续代码执行
                    print(f"修改辅助邮箱的时候找不到元素: {e}")
                    save_log(random_number, f"修改辅助邮箱的时候找不到元素: {e}")
                    update_status_in_db(email_account, "请求错误，请重试")
                    return (
                        email_account, email_password, old_recovery_email, new_password, new_recovery_email, proxy_host,
                        proxy_port,
                        proxy_username, proxy_password)
            else:
                print("辅助邮箱账号已经被更改过")
                save_log(random_number, "辅助邮箱账号已经被更改过")
                recovery_input.clear()
                input_recovery_code(tab, new_recovery_email)

        print("修改辅助邮箱1运行完毕")
        save_log(random_number, "修改辅助邮箱1运行完毕")

        if password_change and auxiliary_email_account_change:
            logutGoogle(tab)
            tab.wait(3)
            update_status_in_db(email_account, '已更改')
            return email_account

        tab.handle_alert(accept=True)

        # # 点击继续按钮
        # continue_div1 = tab.ele('@text()=Continue with smart features', timeout=15)
        # if continue_div1:
        #     try:
        #         click_continue_button(tab, continue_div1)
        #     except ElementNotFoundError as e:
        #         print(f"找不到继续按钮的元素：{e}")
        #         save_log(random_number, f"找不到继续按钮的元素：{e}")
        #         update_status_in_db(email_account, "请求错误，请重试")
        #         return (
        #             email_account, email_password, old_recovery_email, new_password, new_recovery_email, proxy_host,
        #             proxy_port,
        #             proxy_username, proxy_password, region)

        try:
            # 安全设置
            tab.handle_alert(accept=True)
            tab.get("https://ogs.google.com/u/0/widget/account?cn=account")
            tab.handle_alert(accept=True)
            tab.get("https://myaccount.google.com/security?gar=WzEyMF0")
        except ElementNotFoundError as e:
            save_log(random_number, f"进入安全设置后出错：{e}")
            update_status_in_db(email_account,"进入安全设置的时候请求错误，请重试")
            return (
                email_account, email_password, old_recovery_email, new_password, new_recovery_email, proxy_host,
                proxy_port,
                proxy_username, proxy_password, region)

        tab.wait(3)

        wrong = tab.ele("@text()=要查看和调整您的安全设置并获取有助于确保您账号安全的建议，请登录您的账号", timeout=5)
        if wrong:
           print("进入安全设置后仍然未登录")
           save_log(random_number, '进入安全设置后仍然未登录')
           update_status_in_db(email_account, '登录失败')
           return (
               email_account, email_password, old_recovery_email, new_password, new_recovery_email, proxy_host,
               proxy_port,
               proxy_username, proxy_password, region)

        try:
            # 如果密码没被修改
            if not password_change:
                # 找到修改密码的按钮
                find_and_visit_href2(tab)
                # 修改密码
                input_password_new(tab, new_password)  # 使用传入的新密码
                # 点击确认修改
                click_span_with_class(tab)
        except ElementNotFoundError as e:
            print(f"找不到修改密码的元素：{e}")
            save_log(random_number, f"找不到修改密码的元素：{e}")
            update_status_in_db(email_account, "请求错误，请重试")
            return (
                email_account, email_password, old_recovery_email, new_password, new_recovery_email, proxy_host,
                proxy_port,
                proxy_username, proxy_password, region)

        tab.wait(1)

        try:
            if auxiliary_email_account_change:
                logutGoogle(tab)
                tab.wait(3)
                update_status_in_db(email_account,  '已更改')
                return email_account
            # 修改辅助邮箱2
            flag = modify_the_secondary_email2(tab, new_recovery_email, new_password, hwnd)
            save_log(random_number, f"辅助邮箱是否被修改：{flag}")
            if flag:
                logutGoogle(tab)
                tab.wait(3)
                update_status_in_db(email_account, '已更改')
                return email_account
            else:
                # 初始化
                client = EmailClient(server, username, password)
                client.connect()
                code_receiver = GoogleCodeReceiver(client)

                # 最多尝试3次循环
                for attempt in range(3):
                    print(f"第 {attempt + 1} 次尝试检查验证码...")
                    save_log(random_number, f"第 {attempt + 1} 次尝试检查验证码...")

                    # 获取当前程序运行的时间
                    current_time = datetime.now(timezone.utc)
                    print(f"当前时间为{current_time}")
                    save_log(random_number, f"当前时间为{current_time}")

                    # 检查验证码，超时时间为300秒，使用当前时间作为 start_time
                    try:
                        code = code_receiver.wait_code(username=f"{email_account}", timeout=300, interval=5,
                                                       start_time=datetime(2024, 11, 27))
                        print(f"检查的验证码是{code}")
                        save_log(random_number, f"检查的验证码是{code}")
                        if code:
                            # 如果找到验证码，填入验证码
                            verification_input = tab.eles("@type=text", timeout=15)
                            if len(verification_input) >= 1:
                                verification_input[1].clear()
                                for char in code:
                                    verification_input[1].input(char)
                                    tab.wait(random.uniform(0.1, 0.3))  # 随机延迟 0.1 到 0.3 秒

                            print("输入完验证码了")
                            save_log(random_number, "输入完验证码了")

                            # 点击 Verify 按钮
                            verify_button = tab.eles("@text()=Verify", timeout=15)
                            if verify_button and len(verify_button) > 1:
                                verify_button[1].click(by_js=True)
                                tab.wait(5)

                            print("点击确定")
                            save_log(random_number, "点击确定")

                            # 检查是否有报错提示
                            is_visible = tab.ele('@@id=c4@@tag()=p@@role=alert', timeout=1)
                            save_log(random_number, f"是否有报错提示：{is_visible}")
                            if is_visible:
                                # 如果有报错提示，点击重新发送按钮并进入下一次循环
                                sent_code_button = tab.ele('@text():Send a new code.', timeout=15)
                                if sent_code_button:
                                    print(f"重新发送邮件的按钮为：{sent_code_button}")
                                    save_log(random_number, f"重新发送邮件的按钮为：{sent_code_button}")
                                    sent_code_button.click(by_js=True)
                                    continue
                            else:
                                # 如果没有报错，退出
                                print("辅助邮箱账号已经更改完毕")
                                save_log(random_number, "辅助邮箱账号已经更改完毕")
                                logutGoogle(tab)
                                tab.wait(3)
                                update_status_in_db(email_account, "已更改")
                                return email_account

                        else:
                            # 如果未找到验证码，点击重新发送按钮并进入下一次循环
                            print("未找到验证码，点击重新发送按钮")
                            sent_code_button = tab.ele('@text():Send a new code.', timeout=15)
                            if sent_code_button:
                                sent_code_button.click(by_js=True)
                                continue
                    except TimeoutError:
                        print("超时未收到验证码，重新发送")
                        save_log(random_number, "超时未收到验证码，重新发送")
                        sent_code_button = tab.ele('@text():Send a new code.', timeout=15)
                        if sent_code_button:
                            sent_code_button.click(by_js=True)
        except ElementNotFoundError as e:
            print(f"更改辅助邮箱账号的时候找不到元素：{e}")
            save_log(random_number, f"更改辅助邮箱账号的时候找不到元素：{e}")
            update_status_in_db(email_account,  "请求错误，请重试")
            return (
                email_account, email_password, old_recovery_email, new_password, new_recovery_email, proxy_host,
                proxy_port,
                proxy_username, proxy_password, region)
    except Exception as e:
        print(f"出现未知错误:{e}")
        save_log(random_number, f"出现未知错误:{e}")
        update_status_in_db(email_account, f'出现未知错误:{e}请重试')
        return (
            email_account, email_password, old_recovery_email, new_password, new_recovery_email, proxy_host,
            proxy_port,
            proxy_username, proxy_password, region)

    finally:
        try:
            browser.quit()
            # 释放资源
            time.sleep(5)
            delete_folder(plugin_path)
            delete_folder(user_dir)
        except Exception:
            print("出现没有代理")
            save_log(random_number, "出现没有代理")


def run_gui():
    stop_flag = threading.Event()  # 用于控制任务中止的标志位
    exec_thread = None  # 用于存储后台线程的引用


    def handle_file_select():
        file_path = filedialog.askopenfilename(
            title="选择 Excel 文件",
            filetypes=[("Excel 文件", "*.xlsx"), ("所有文件", "*.*")]
        )
        if file_path:
            entry_file_path.delete(0, tk.END)
            entry_file_path.insert(0, file_path)

    def update_proxy_stats():
        try:
            # 国家代码列表
            countries = {
                "AT": "奥地利", "BE": "比利时", "CZ": "捷克", "DE": "德国", "DK": "丹麦",
                "ES": "西班牙", "FI": "芬兰", "FR": "法国", "GB": "英国", "HR": "克罗地亚",
                "HU": "匈牙利", "IT": "意大利", "LT": "立陶宛", "LU": "卢森堡", "NL": "荷兰",
                "PL": "波兰", "PT": "葡萄牙", "RO": "罗马尼亚", "SE": "瑞典", "SK": "斯洛伐克"
            }

            # 获取全部区域的代理数量
            try:
                total_proxies = proxy_manager.get_proxy_count("ALL")
            except Exception as e:
                total_proxies = "获取失败"
                print(f"获取全部代理数时出错: {e}")

            # 显示总代表数量
            proxy_stats = f"总数: {total_proxies} 个代理\n\n"

            # 获取并显示每个国家的代理数量
            country_data = []
            for country_code, country_name in countries.items():
                try:
                    # 获取该国家的代理数量
                    country_proxy_count = proxy_manager.get_proxy_count(country_code)
                    country_data.append(f"{country_name}({country_code}): {country_proxy_count} 个代理")
                except Exception as e:
                    country_data.append(f"{country_name}({country_code}): 获取代理数失败")
                    print(f"获取 {country_name} ({country_code}) 代理数时出错: {e}")

            # 更新界面上的代理统计标签
            lbl_proxy_stats.config(text=proxy_stats)
            # 分列显示国家的代理统计信息
            max_rows = 5  # 每列最多显示多少行
            columns = 4  # 显示几列
            for col in range(columns):
                for row in range(min(max_rows, len(country_data) - col * max_rows)):
                    label = tk.Label(root, text=country_data[col * max_rows + row], justify="left")
                    label.grid(row=row + 9, column=col, padx=5, pady=5, sticky="w")

            # 为每列添加居中对齐，使用 columnspan 来确保列宽
            for col in range(columns):
                root.grid_columnconfigure(col, weight=1, uniform="equal")

                # 调整列之间的间距，通过 columnconfigure 设置每列最小宽度（minsize）
            for col in range(columns):
                root.grid_columnconfigure(col, minsize=5)
        except Exception as e:
            print(f"更新代理统计信息时出错: {e}")
            lbl_proxy_stats.config(text="获取代理统计信息失败")

    def start_processing():
        file_path = entry_file_path.get()
        sheet_name = entry_sheet_name.get()
        max_concurrency = entry_concurrency.get()
        max_retries = entry_retries.get()



        # 检查文件路径和 Sheet 名称是否填写完整
        if not file_path or not sheet_name or not max_concurrency or not max_retries:
            messagebox.showwarning("警告", "请填写完整的文件路径、表格名称、并发数和重试次数！")
            return

        # 检查文件路径是否存在
        if not os.path.exists(file_path):
            if not file_path.endswith(".xlsx"):
                messagebox.showerror("错误", "文件的格式必须是.xlsx")
            else:
                messagebox.showerror("错误", "没有找到该路径的文件，请检查文件是否存在！")
            return

        # 检查文件是否正在被打开
        try:
            with open(file_path, 'r+b') as file:
                pass  # 成功打开说明未被占用
        except PermissionError:
            messagebox.showerror("错误", "文件正在被占用，请先保存并关闭 Excel 程序！")
            return

        # 验证 Sheet 名称是否存在
        try:
            wb = load_workbook(file_path, read_only=True)
            if sheet_name not in wb.sheetnames:
                messagebox.showerror("错误", f"“{sheet_name}”表格名字不存在，请打开 Excel 文件检查！")
                return
        except Exception as e:
            messagebox.showerror("错误", f"无法打开文件：{e}")
            return

        # 验证并发数
        try:
            max_concurrency = int(max_concurrency)
            if max_concurrency <= 0:
                raise ValueError("并发数必须是大于0的整数！")
        except ValueError as e:
            messagebox.showerror("错误", f"无效的并发数：{e}")
            return

        # 验证重试次数
        try:
            max_retries = int(max_retries)
            if max_retries < 0 or max_retries > 3:
                raise ValueError("重试次数必须是整数且在0到3之间！")
        except ValueError as e:
            messagebox.showerror("错误", f"无效的重试次数：{e}")
            return

        db_manager.import_from_excel(file_path, clear_old=True)
        proxy_manager.import_proxies_with_classifier("Ip.txt", classifier=classifier_smartproxy)

        # 初始化 Excel 数据和进度条状态
        all_rows = read_data_from_db()  # 读取 Excel 数据
        total_tasks = len(all_rows)
        completed_count = 0
        failed_count = 0

        # 设置进度条和状态显示
        progress_bar['maximum'] = total_tasks
        progress_bar['value'] = completed_count  # 初始化为0
        lbl_progress_status.config(
            text=f"完成：{completed_count}/{total_tasks}，失败：{failed_count}"
        )

        stop_flag.clear()  # 清除停止标志
        exec_thread = threading.Thread(target=parallel_execution_with_db,
                                       args=(file_path, max_concurrency, max_retries))
        exec_thread.daemon = True  # 设置为守护线程
        exec_thread.start()

    def stop_processing():
        stop_flag.set()  # 设置标志位为 True，通知停止
        messagebox.showinfo("提示", "等待当前任务完成，程序即将停止！")

    def on_closing():
        stop_flag.set()  # 设置标志位为 True，通知停止
        if exec_thread and exec_thread.is_alive():
            exec_thread.join(timeout=5)  # 等待线程结束
        root.destroy()  # 销毁主窗口
        sys.exit(0)  # 强制退出程序

    def parallel_execution_with_db(file_path, max_concurrency, max_retries):
        progress_queue = Queue()
        all_rows = read_data_from_db()  # 第一次读取数据
        print(f"数据库中的数据：{all_rows}")

        total_rows = len(all_rows)
        completed_count = 0
        failed_count = 0
        progress_bar['maximum'] = total_rows

        retry_count = 0

        with Pool(processes=max_concurrency, initializer=init_worker()) as pool:
            while all_rows:
                if stop_flag.is_set():
                    print("停止信号已接收，中止任务！")
                    break

                results = []

                for i, row in enumerate(all_rows):
                    if stop_flag.is_set():
                        print("停止信号已接收，中止任务！")
                        break

                    # 获取邮箱和区域信息
                    account_email = row[0]
                    region = row[9]  # 假设第6列存储的是账号的区域信息

                    if not region:
                        region = "ALL"  # 如果没有区域信息，则使用默认区域

                    # 获取一个随机代理并传递给当前账号
                    proxy = proxy_manager.get_random_proxy_by_region(region=region, remove_after_fetch=True)

                    if proxy:  # 如果分配成功
                        proxy_host, proxy_port, proxy_user, proxy_pass = proxy['host'], proxy['port'], proxy['user'], \
                        proxy['password']
                        print(f"为账号 {account_email} 分配代理：{proxy_host}:{proxy_port}:{proxy_user}:{proxy_pass}")

                        db_manager.update_record(account_email,
                                                 proxy=f"{proxy_host}:{proxy_port}:{proxy_user}:{proxy_pass}")
                        row = row[:5] + (proxy_host, proxy_port, proxy_user, proxy_pass) + row[9:]  # 将代理信息加入到数据行中
                    else:
                        print(f"为账号 {account_email} 分配代理失败，跳过此账号。")

                    with write_lock:
                        try:
                            print("更新剩余可用IP")
                            proxy_manager.export_proxies("剩下的可用IP.txt")
                        except Exception as e:
                            print(f"导出代理时发生错误: {e}")

                    update_proxy_stats()

                    # 传递锁给子进程，并将当前账号数据传递给 main 函数
                    result = pool.apply_async(main, args=(row), callback=lambda result: progress_queue.put(result))
                    results.append(result)


                for result in results:
                    try:
                        retry_row = result.get()
                        print(f"main函数返回的值: {retry_row}")

                        if not retry_row:  # 如果返回False，表示任务失败
                            failed_count += 1
                        elif isinstance(retry_row, tuple):  # 返回的是元组，表示需要重试
                            failed_count += 1  # 增加失败计数
                        else:  # 返回的是单个 account，表示成功
                            completed_count += 1
                        # 更新进度条和显示的状态
                        progress_bar['value'] = completed_count
                        lbl_progress_status.config(text=f"完成：{completed_count}/{total_rows}，失败：{failed_count}")
                        time.sleep(2)  # 模拟耗时操作

                    except Exception as e:
                        print(f"任务执行时发生错误: {e}")
                        failed_count += 1
                        lbl_progress_status.config(text=f"完成：{completed_count}/{total_rows}，失败：{failed_count}")
                        messagebox.showwarning("任务执行错误", f"任务执行时发生错误: {e}")

                # 如果停止信号被触发，则中止
                if stop_flag.is_set():
                    print("停止信号已接收，中止任务！")
                    break

                # 重试逻辑，重新从数据库读取失败的数据
                if retry_count < max_retries:
                    retry_count += 1
                    all_rows = read_data_from_db()  # 重新从数据库读取失败的记录
                else:
                    print("达到最大重试次数，停止重试。")
                    break

            else:
                print("所有任务已完成。")
                messagebox.showinfo('运行结束', '所有任务已经完成')

    def read_data_from_db() -> List[Tuple]:
        """
        从数据库读取数据，同时保持与旧的接口和逻辑一致。
        根据账号区域自动分配代理，并导入到数据库。
        （去除代理分配和数据库更新代理信息的部分）
        """
        # 初始化数据库管理器
        skip_keywords = {"已更改", "接码", "被盗"}
        data = []

        # 从数据库中查询所有数据
        accounts = db_manager.export_data()

        global total_tasks, completed_tasks, failed_tasks  # 全局变量以更新状态

        # 计算任务数量
        completed_tasks = sum(account.change_status in skip_keywords for account in accounts)
        failed_tasks = len(accounts) - completed_tasks - sum(account.change_status is None for account in accounts)
        total_tasks = len(accounts) - completed_tasks

        for i, account in enumerate(accounts):
            if not account.email:
                break
            if account.change_status not in skip_keywords:
                # 不再分配代理，只是记录账号信息
                data.append((
                    account.email, account.original_password, account.original_aux_email,
                    account.new_password, account.new_aux_email, "", "", "", "",account.region
                ))

        return data

    root = tk.Tk()
    root.title("程序控制界面")

    tk.Label(root, text="Excel 文件路径:").grid(row=0, column=0, padx=10, pady=10)
    entry_file_path = tk.Entry(root, width=50)
    entry_file_path.grid(row=0, column=1, padx=10, pady=10)
    btn_select_file = tk.Button(root, text="选择文件", command=handle_file_select)
    btn_select_file.grid(row=0, column=2, padx=10, pady=10)

    tk.Label(root, text="Sheet 名称:").grid(row=1, column=0, padx=10, pady=10)
    entry_sheet_name = tk.Entry(root, width=50)
    entry_sheet_name.grid(row=1, column=1, padx=10, pady=10)
    entry_sheet_name.insert(0, "修改邮箱密码和辅助邮箱")

    tk.Label(root, text="并发数:").grid(row=2, column=0, padx=10, pady=10)
    entry_concurrency = tk.Entry(root, width=50)
    entry_concurrency.grid(row=2, column=1, padx=10, pady=10)
    entry_concurrency.insert(0, str(multiprocessing.cpu_count()))

    tk.Label(root, text="重试次数:").grid(row=3, column=0, padx=10, pady=10)
    entry_retries = tk.Entry(root, width=50)
    entry_retries.grid(row=3, column=1, padx=10, pady=10)
    entry_retries.insert(0, "3")

    # 进度条
    progress_bar = ttk.Progressbar(root, orient="horizontal", length=400, mode="determinate")
    progress_bar.grid(row=4, column=0, columnspan=2, padx=10, pady=10)

    # 进度状态显示
    lbl_progress_status = tk.Label(root, text="完成：0/0，失败：0")
    lbl_progress_status.grid(row=5, column=0, columnspan=2, padx=10, pady=10)

    btn_start = tk.Button(root, text="开始处理", command=start_processing)
    btn_start.grid(row=6, column=0, columnspan=2, padx=20, pady=20, sticky="ew")

    btn_stop = tk.Button(root, text="停止处理", command=stop_processing)
    btn_stop.grid(row=7, column=0, columnspan=2, padx=20, pady=20, sticky="ew")

    # 添加显示代理统计信息的标签
    tk.Label(root, text="代理统计信息:").grid(row=8, column=0, padx=10, pady=10)
    lbl_proxy_stats = tk.Label(root, text="代理统计信息未加载")
    lbl_proxy_stats.grid(row=8, column=1, padx=5, pady=10, columnspan=2)

    root.protocol("WM_DELETE_WINDOW", on_closing)  # 绑定窗口关闭事件
    root.mainloop()



# 示例运行方式
if __name__ == "__main__":
    logs_dir = "logs"

    # 确保 logs 文件夹存在，如果不存在则创建
    if not os.path.exists(logs_dir):
        os.makedirs(logs_dir)

    # 清空 logs 文件夹中的所有文件
    for filename in os.listdir("logs"):
        file_path = os.path.join("logs", filename)
        if os.path.isfile(file_path):
            os.remove(file_path)

    freeze_support()
    run_gui()