# app/logic/MmApi.py
import requests
import time
import logging

class MmApi:
    def __init__(self, token):
        self.token = token
        self.timeout = 10  # 設(shè)置10秒超時(shí)
        self.max_retries = 3  # 最大重試次數(shù)
    
    def mm_search(self, params):
        for attempt in range(self.max_retries):
            try:
                response = requests.get(
                    'https://xx.xxx.com/api/search',
                    params=params,
                    headers={'Authorization': f'Bearer {self.token}'},
                    timeout=self.timeout,  # 關(guān)鍵：設(shè)置超時(shí)
                    verify=False  # 禁用SSL驗(yàn)證
                )
                
                if response.status_code == 200:
                    result = response.json()
                    if result.get('code') == 200:
                        data_list = result.get('data', {}).get('list', [])
                        if not data_list:
                            return {
                                'success': False,
                                'error_type': 'empty_list',
                                'message': '沒有找到符合條件的賬號'
                            }
                        return {
                            'success': True,
                            'data': data_list,
                            'message': f'成功找到 {len(data_list)} 個(gè)賬號'
                        }
                    else:
                        # API返回錯(cuò)誤
                        return {
                            'success': False,
                            'error_type': 'api_error',
                            'message': f'接口返回錯(cuò)誤: {result.get("message", "未知錯(cuò)誤")}'
                        }
                else:
                    # HTTP狀態(tài)碼錯(cuò)誤
                    return {
                        'success': False,
                        'error_type': 'http_error',
                        'message': f'HTTP請求失敗，狀態(tài)碼: {response.status_code}'
                    }
                    
            except requests.exceptions.Timeout:
                logger.warning(f"請求超時(shí)，第{attempt + 1}次重試")
                if attempt < self.max_retries - 1:
                    time.sleep(1)  # 重試前等待1秒
                    continue
                return {
                    'success': False,
                    'error_type': 'timeout',
                    'message': '請求超時(shí)，請檢查網(wǎng)絡(luò)連接'
                }
                
            except requests.exceptions.ConnectionError:
                logger.warning(f"連接錯(cuò)誤，第{attempt + 1}次重試")
                if attempt < self.max_retries - 1:
                    time.sleep(1)
                    continue
                return {
                    'success': False,
                    'error_type': 'connection_error',
                    'message': '網(wǎng)絡(luò)連接失敗，請檢查網(wǎng)絡(luò)設(shè)置'
                }
                
            except Exception as e:
                logger.error(f"未知錯(cuò)誤: {str(e)}")
                return {
                    'success': False,
                    'error_type': 'unknown_error',
                    'message': f'發(fā)生未知錯(cuò)誤: {str(e)}'
                }
        
        return {
            'success': False,
            'error_type': 'max_retries_exceeded',
            'message': '超過最大重試次數(shù)，請稍后重試'
        }

# app/logic/YxlmApi.py
import time
from app.Config import API_RATE_LIMIT

class YxlmApi:
    def __init__(self):
        self.enable_rate_limit = API_RATE_LIMIT['enable_rate_limit']
        self.rank_query_delay = API_RATE_LIMIT['rank_query_delay']
        self.hidden_score_delay = API_RATE_LIMIT['hidden_score_delay']
        self.last_rank_request = 0
        self.last_hidden_request = 0
    
    def _wait_for_delay(self, delay_type):
        """等待延遲時(shí)間，防止請求過于頻繁"""
        if not self.enable_rate_limit:
            return
            
        current_time = time.time()
        if delay_type == 'rank':
            if current_time - self.last_rank_request < self.rank_query_delay:
                wait_time = self.rank_query_delay - (current_time - self.last_rank_request)
                time.sleep(wait_time)
            self.last_rank_request = time.time()
        elif delay_type == 'hidden':
            if current_time - self.last_hidden_request < self.hidden_score_delay:
                wait_time = self.hidden_score_delay - (current_time - self.last_hidden_request)
                time.sleep(wait_time)
            self.last_hidden_request = time.time()
    
    def get_rank(self, puuid):
        self._wait_for_delay('rank')
        # 執(zhí)行段位查詢邏輯
        pass
    
    def get_hidden_score(self, puuid):
        self._wait_for_delay('hidden')
        # 執(zhí)行隱藏分查詢邏輯
        pass

# app/controller/Home/BatchSearchController.py
from concurrent.futures import ThreadPoolExecutor
import threading
import queue
import tkinter.messagebox as messagebox

class BatchSearchController:
    def __init__(self, ui):
        self.ui = ui
        self.thread_pool = ThreadPoolExecutor(max_workers=5)  # 限制最大并發(fā)數(shù)
        self.update_queue = queue.Queue()
        self._start_update_worker()
    
    def _start_update_worker(self):
        """啟動(dòng)UI更新工作線程"""
        def update_worker():
            while True:
                try:
                    func, args, kwargs = self.update_queue.get()
                    if func is None:  # 退出信號
                        break
                    # 在主線程中執(zhí)行UI更新
                    self.ui.after(0, func, *args, **kwargs)
                except Exception as e:
                    print(f"UI更新異常: {e}")
                finally:
                    self.update_queue.task_done()
        
        update_thread = threading.Thread(target=update_worker, daemon=True)
        update_thread.start()
    
    def safe_ui_update(self, func, *args, **kwargs):
        """安全的UI更新方法"""
        self.update_queue.put((func, args, kwargs))
    
    def search_button(self):
        """搜索按鈕點(diǎn)擊事件"""
        # 立即禁用搜索按鈕，防止重復(fù)點(diǎn)擊
        self.ui.search_button.config(state='disabled')
        
        # 獲取搜索參數(shù)
        params = self._get_search_params()
        
        # 在線程池中執(zhí)行搜索任務(wù)
        future = self.thread_pool.submit(self._search_task, params)
        
        # 添加完成回調(diào)
        future.add_done_callback(self._on_search_complete)
    
    def _search_task(self, params):
        """搜索任務(wù)執(zhí)行邏輯"""
        try:
            mm = MmApi(self.ui.setting_token.get("1.0", "end").strip())
            mm_result = mm.mm_search(params)
            
            if mm_result and isinstance(mm_result, dict) and 'success' in mm_result:
                if mm_result['success']:
                    # 搜索成功，插入數(shù)據(jù)
                    self.safe_ui_update(self.insert_data, mm_result['data'])
                else:
                    # 搜索失敗，顯示錯(cuò)誤信息
                    error_type = mm_result.get('error_type', 'unknown')
                    error_message = mm_result.get('message', '未知錯(cuò)誤')
                    
                    if error_type == 'empty_list':
                        self.safe_ui_update(messagebox.showwarning, "搜索結(jié)果", error_message)
                    else:
                        self.safe_ui_update(messagebox.showerror, "搜索失敗", error_message)
            else:
                # 兼容舊格式
                self.safe_ui_update(messagebox.showinfo, "提示", "獲取接口出問題,請過幾秒再重試")
                
        except Exception as e:
            logger.error(f"搜索任務(wù)異常: {str(e)}")
            self.safe_ui_update(messagebox.showerror, "錯(cuò)誤", f"搜索過程中發(fā)生錯(cuò)誤: {str(e)}")
    
    def _on_search_complete(self, future):
        """搜索完成回調(diào)"""
        try:
            # 重新啟用搜索按鈕
            self.safe_ui_update(lambda: self.ui.search_button.config(state='normal'))
        except Exception as e:
            logger.error(f"搜索完成回調(diào)異常: {e}")

# app/tools/global_var.py
import sys
import traceback
from tkinter import messagebox

def setup_global_exception_handler():
    """設(shè)置全局異常處理器"""
    def handle_exception(exc_type, exc_value, exc_traceback):
        # 忽略鍵盤中斷
        if issubclass(exc_type, KeyboardInterrupt):
            sys.__excepthook__(exc_type, exc_value, exc_traceback)
            return
        
        # 記錄錯(cuò)誤信息
        error_msg = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
        print(f"嚴(yán)重錯(cuò)誤: {error_msg}")
        
        try:
            # 顯示錯(cuò)誤彈窗
            messagebox.showerror(
                "程序錯(cuò)誤",
                f"程序發(fā)生了一個(gè)未預(yù)期的錯(cuò)誤:\n{str(exc_value)}\n\n詳細(xì)信息已記錄到日志文件中。"
            )
        except:
            # 如果彈窗失敗，至少打印錯(cuò)誤信息
            print(f"嚴(yán)重錯(cuò)誤: {error_msg}")
    
    # 設(shè)置全局異常處理器
    sys.excepthook = handle_exception

def global_init():
    """全局初始化"""
    setup_global_exception_handler()

# app/Config.py
# 網(wǎng)絡(luò)配置
NETWORK_CONFIG = {
    'timeout': 10,           # 請求超時(shí)時(shí)間（秒）
    'max_retries': 3,        # 最大重試次數(shù)
    'max_workers': 5,        # 最大并發(fā)線程數(shù)
    'batch_timeout': 30,     # 批量操作超時(shí)時(shí)間
    'single_timeout': 10,    # 單個(gè)操作超時(shí)時(shí)間
}

# API請求頻率控制配置
API_RATE_LIMIT = {
    'rank_query_delay': 0.1,      # 段位查詢間隔（秒）
    'hidden_score_delay': 0.2,    # 隱藏分查詢間隔（秒）
    'enable_rate_limit': True,    # 是否啟用頻率限制
}