main.py

"""网易云音乐API服务主程序

提供网易云音乐相关API服务，包括：
- 歌曲信息获取
- 音乐搜索
- 歌单和专辑详情
- 音乐下载
- 健康检查
- API可用性监控
"""

import logging
import sys
import time
import traceback
import threading
import smtplib
import requests
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from datetime import date, datetime
from dataclasses import dataclass
from pathlib import Path
from typing import Dict, Any, Optional, Tuple, List
from urllib.parse import quote
from flask import Flask, request, send_file, render_template, Response, session, redirect, url_for, jsonify
import functools

import db_helper
import requests as sync_requests

from config import config as app_config


# ===== 代理池配置 =====
PROXY_API_URL = 'https://proxy.scdn.io/api/get_proxy.php'
PROXY_CACHE_FILE = 'proxy_cache.json'


class ProxyPool:
    """代理池管理类"""

    def __init__(self):
        self._lock = threading.Lock()
        self._cache = []
        self._last_fetch = 0
        self._fetch_interval = 300  # 5分钟刷新一次

    def _fetch_from_api(self, protocol: str = 'all', count: int = 10) -> List[str]:
        """从API获取代理"""
        try:
            params = {'protocol': protocol, 'count': count}
            response = sync_requests.get(PROXY_API_URL, params=params, timeout=15)
            data = response.json()
            if data.get('code') == 200 and data.get('data', {}).get('proxies'):
                return data['data']['proxies']
        except Exception as e:
            print(f"获取代理失败: {e}")
        return []

    def get_proxies(self, protocol: str = 'all', count: int = 5, force_refresh: bool = False) -> List[Dict[str, Any]]:
        """获取代理列表"""
        with self._lock:
            now = time.time()
            if force_refresh or now - self._last_fetch > self._fetch_interval or not self._cache:
                self._cache = self._fetch_from_api(protocol, 20)
                self._last_fetch = now

            result = []
            for proxy in self._cache[:count]:
                if ':' in proxy:
                    ip, port = proxy.rsplit(':', 1)
                    result.append({
                        'proxy': proxy,
                        'ip': ip,
                        'port': int(port),
                        'protocol': protocol if protocol != 'all' else 'http'
                    })
            return result

    def refresh(self, protocol: str = 'all') -> int:
        """手动刷新代理池"""
        with self._lock:
            self._cache = self._fetch_from_api(protocol, 20)
            self._last_fetch = time.time()
            return len(self._cache)


# 全局代理池实例
proxy_pool = ProxyPool()

try:
    from music_api import (
        NeteaseAPI, APIException, QualityLevel,
        url_v1, name_v1, lyric_v1, search_music, 
        playlist_detail, album_detail
    )
    from cookie_manager import CookieManager, CookieException
    from music_downloader import MusicDownloader, DownloadException, AudioFormat
except ImportError as e:
    print(f"导入模块失败: {e}")
    print("请确保所有依赖模块存在且可用")
    sys.exit(1)


@dataclass
class APIConfig:
    """API配置类"""
    host: str = '0.0.0.0'
    port: int = 5000
    debug: bool = False
    downloads_dir: str = 'downloads'
    max_file_size: int = 500 * 1024 * 1024  # 500MB
    request_timeout: int = 30
    log_level: str = 'INFO'
    cors_origins: str = '*'
    system_public_key: str = ''


class APIResponse:
    """API响应工具类"""
    
    @staticmethod
    def success(data: Any = None, message: str = 'success', status_code: int = 200) -> Tuple[Dict[str, Any], int]:
        """成功响应"""
        response = {
            'status': status_code,
            'success': True,
            'message': message
        }
        if data is not None:
            response['data'] = data
        return response, status_code
    
    @staticmethod
    def error(message: str, status_code: int = 400, error_code: str = None) -> Tuple[Dict[str, Any], int]:
        """错误响应"""
        response = {
            'status': status_code,
            'success': False,
            'message': message
        }
        if error_code:
            response['error_code'] = error_code
        return response, status_code


class MusicAPIService:
    """音乐API服务类"""
    
    def __init__(self, config: APIConfig):
        self.config = config
        self.logger = self._setup_logger()
        self.cookie_manager = CookieManager()
        self.netease_api = NeteaseAPI()
        self.downloader = MusicDownloader()
        
        # 创建下载目录
        self.downloads_path = Path(config.downloads_dir)
        self.downloads_path.mkdir(exist_ok=True)
        
        self.logger.info(f"音乐API服务初始化完成，下载目录: {self.downloads_path.absolute()}")
    
    def _setup_logger(self) -> logging.Logger:
        """设置日志记录器"""
        logger = logging.getLogger('music_api')
        logger.setLevel(getattr(logging, self.config.log_level.upper()))
        
        if not logger.handlers:
            # 控制台处理器
            console_handler = logging.StreamHandler()
            console_formatter = logging.Formatter(
                '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
            )
            console_handler.setFormatter(console_formatter)
            logger.addHandler(console_handler)
            
            # 文件处理器
            try:
                file_handler = logging.FileHandler('music_api.log', encoding='utf-8')
                file_formatter = logging.Formatter(
                    '%(asctime)s - %(name)s - %(levelname)s - %(funcName)s:%(lineno)d - %(message)s'
                )
                file_handler.setFormatter(file_formatter)
                logger.addHandler(file_handler)
            except Exception as e:
                logger.warning(f"无法创建日志文件: {e}")
        
        return logger
    
    def _get_cookies(self) -> Dict[str, str]:
        """获取Cookie"""
        try:
            cookie_str = self.cookie_manager.read_cookie()
            return self.cookie_manager.parse_cookie_string(cookie_str)
        except CookieException as e:
            self.logger.warning(f"获取Cookie失败: {e}")
            return {}
        except Exception as e:
            self.logger.error(f"Cookie处理异常: {e}")
            return {}
    
    def _extract_music_id(self, id_or_url: str) -> str:
        """提取音乐ID"""
        try:
            # 处理短链接
            if '163cn.tv' in id_or_url:
                import requests
                response = requests.get(id_or_url, allow_redirects=False, timeout=10)
                id_or_url = response.headers.get('Location', id_or_url)
            
            # 处理网易云链接
            if 'music.163.com' in id_or_url:
                index = id_or_url.find('id=') + 3
                if index > 2:
                    return id_or_url[index:].split('&')[0]
            
            # 直接返回ID
            return str(id_or_url).strip()
            
        except Exception as e:
            self.logger.error(f"提取音乐ID失败: {e}")
            return str(id_or_url).strip()
    
    def _format_file_size(self, size_bytes: int) -> str:
        """格式化文件大小"""
        if size_bytes == 0:
            return "0B"
        
        units = ["B", "KB", "MB", "GB", "TB"]
        size = float(size_bytes)
        unit_index = 0
        
        while size >= 1024.0 and unit_index < len(units) - 1:
            size /= 1024.0
            unit_index += 1
        
        return f"{size:.2f}{units[unit_index]}"
    
    def _get_quality_display_name(self, quality: str) -> str:
        """获取音质显示名称"""
        quality_names = {
            'standard': "标准音质",
            'exhigh': "极高音质", 
            'lossless': "无损音质",
            'hires': "Hi-Res音质",
            'sky': "沉浸环绕声",
            'jyeffect': "高清环绕声",
            'jymaster': "超清母带",
            'dolby': "杜比全景声"
        }
        return quality_names.get(quality, f"未知音质({quality})")
    
    def _validate_request_params(self, required_params: Dict[str, Any]) -> Optional[Tuple[Dict[str, Any], int]]:
        """验证请求参数"""
        for param_name, param_value in required_params.items():
            if not param_value:
                return APIResponse.error(f"参数 '{param_name}' 不能为空", 400)
        return None
    
    def _safe_get_request_data(self) -> Dict[str, Any]:
        """安全获取请求数据"""
        try:
            if request.method == 'GET':
                return dict(request.args)
            else:
                # 优先使用JSON数据，然后是表单数据
                json_data = request.get_json(silent=True) or {}
                form_data = dict(request.form)
                # 合并数据，JSON优先
                return {**form_data, **json_data}
        except Exception as e:
            self.logger.error(f"获取请求数据失败: {e}")
            return {}


# 创建Flask应用和服务实例
config = APIConfig()
config.host = app_config.HOST
config.port = app_config.PORT
config.debug = app_config.DEBUG
config.downloads_dir = app_config.DOWNLOADS_DIR
config.cors_origins = app_config.CORS_ORIGINS

# 加载系统公用密钥
try:
    conn = db_helper.get_conn()
    with conn.cursor() as cur:
        cur.execute("SELECT api_key FROM api_keys WHERE key_name = '系统公用密钥' AND status = 1 LIMIT 1")
        row = cur.fetchone()
        if row:
            config.system_public_key = row['api_key']
            print(f"✅ 系统公用密钥已加载")
        else:
            print("️ 未找到系统公用密钥，主页API调用可能失败")
    conn.close()
except Exception as e:
    print(f"⚠️ 加载系统公用密钥失败: {e}")

app = Flask(__name__)
app.secret_key = app_config.SECRET_KEY
app.jinja_env.auto_reload = True
app.config['TEMPLATES_AUTO_RELOAD'] = True

# Session配置
from flask import session
app.config['SESSION_COOKIE_SAMESITE'] = 'Lax'
app.config['SESSION_COOKIE_SECURE'] = False

api_service = MusicAPIService(config)


def send_health_email(to_emails: list, subject: str, body: str):
    """发送健康通知邮件"""
    smtp = {
        "host": app_config.SMTP_HOST,
        "port": app_config.SMTP_PORT,
        "user": app_config.SMTP_USER,
        "password": app_config.SMTP_PASSWORD,
        "from_name": app_config.SMTP_FROM_NAME,
    }
    if not smtp.get("user") or not smtp.get("password"):
        return
    try:
        msg = MIMEMultipart()
        msg["From"] = f"{smtp['from_name']} <{smtp['user']}>"
        msg["Subject"] = subject
        msg.attach(MIMEText(body, "html", "utf-8"))

        server = smtplib.SMTP(smtp["host"], smtp["port"], timeout=15)
        server.starttls()
        server.login(smtp["user"], smtp["password"])
        for email in to_emails:
            msg["To"] = email
            server.sendmail(smtp["user"], email, msg.as_string())
        server.quit()
    except Exception as e:
        pass


def check_api_health():
    """检测API健康状态并存入数据库，状态变化时发送邮件通知"""
    try:
        start = time.time()
        response = sync_requests.get('http://localhost:5000/health', timeout=30)
        latency = int((time.time() - start) * 1000)

        if response.status_code == 200:
            status = 'up'
        elif latency > 5000:
            status = 'warning'
        else:
            status = 'down'

        prev = db_helper.get_health_previous_status()
        db_helper.save_health_check(status, latency)

        if prev != 'unknown' and prev != status:
            subscribers = db_helper.get_active_subscribers()
            if subscribers:
                now_str = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
                if status == 'up' and prev in ('down', 'warning'):
                    send_health_email(subscribers,
                        '✅ MusicAPI 服务已恢复',
                        f'<h3>服务已恢复正常</h3>'
                        f'<p>恢复时间：{now_str}</p><p>响应延迟：{latency}ms</p>'
                        f'<p><a href="https://music.rrvenn.cn/health/monitor">查看监控面板</a></p>')
                elif status == 'down' and prev in ('up', 'warning'):
                    send_health_email(subscribers,
                        '🔴 MusicAPI 服务异常',
                        f'<h3>服务检测失败</h3>'
                        f'<p>异常时间：{now_str}</p><p>请及时排查。</p>'
                        f'<p><a href="https://music.rrvenn.cn/health/monitor">查看监控面板</a></p>')

    except Exception as e:
        prev = db_helper.get_health_previous_status()
        db_helper.save_health_check('down', -1)

        if prev != 'unknown' and prev != 'down':
            subscribers = db_helper.get_active_subscribers()
            if subscribers:
                now_str = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
                send_health_email(subscribers,
                    '🔴 MusicAPI 服务异常',
                    f'<h3>服务检测失败（连接超时）</h3>'
                    f'<p>异常时间：{now_str}</p><p>请及时排查。</p>'
                    f'<p><a href="https://music.rrvenn.cn/health/monitor">查看监控面板</a></p>')


def health_monitor_loop():
    """健康监控定时任务循环"""
    while True:
        check_api_health()
        time.sleep(900)


# 启动健康监控线程（延迟5秒启动，等待Flask服务就绪）
def start_monitor_with_delay():
    time.sleep(5)
    check_api_health()
    monitor_thread = threading.Thread(target=health_monitor_loop, daemon=True)
    monitor_thread.start()


monitor_init_thread = threading.Thread(target=start_monitor_with_delay, daemon=True)
monitor_init_thread.start()


# 存储当前请求的 API Key 信息
g_api_key_info = None


def get_api_key_from_request():
    """从请求中获取 API Key"""
    # 从 Header 获取
    auth_header = request.headers.get('Authorization', '')
    if auth_header.startswith('Bearer '):
        return auth_header[7:]
    # 从 Query 参数获取
    return request.args.get('api_key', '')


@app.before_request
def before_request():
    """请求前处理 - 强制API Key认证"""
    global g_api_key_info
    g_api_key_info = None
    
    # 记录请求信息
    api_service.logger.info(
        f"{request.method} {request.path} - IP: {request.remote_addr} - "
        f"User-Agent: {request.headers.get('User-Agent', 'Unknown')}"
    )
    
    # 公开路径（不需要API Key）
    public_paths = ['/user', '/admin', '/docs', '/health', '/static', '/favicon.ico', '/api/stats']
    
    # 检查是否是公开路径（管理后台和用户平台有自己的session认证）
    is_public = False
    
    # 精确匹配根路径
    if request.path == '/':
        is_public = True
    else:
        for p in public_paths:
            if request.path == p or request.path.startswith(p + '/'):
                is_public = True
                break
    
    if is_public:
        return
    
    # 获取API Key
    api_key = get_api_key_from_request()
    
    # 如果没有提供API Key，使用系统公用密钥
    if not api_key:
        api_key = config.system_public_key
    
    # 验证 API Key
    if not db_helper.validate_api_key(api_key):
        api_service.logger.warning(f"API Key验证失败: {api_key[:10]}...")
        resp = jsonify({"status": 401, "success": False, "message": "无效的API Key"})
        resp.status_code = 401
        return resp
    
    g_api_key_info = db_helper.get_api_key_info(api_key)
    api_service.logger.info(f"API Key认证成功: key_id={g_api_key_info['id']}, name={g_api_key_info['key_name']}")


@app.after_request
def after_request(response: Response) -> Response:
    """请求后处理 - 设置CORS头、禁用缓存并记录统计"""
    # 获取请求的Origin头
    origin = request.headers.get('Origin', '')
    
    # 如果有Origin头，设置CORS（支持credentials）
    if origin:
        if config.cors_origins == '*' or origin in config.cors_origins.split(','):
            response.headers.add('Access-Control-Allow-Origin', origin)
            response.headers.add('Access-Control-Allow-Credentials', 'true')
    else:
        response.headers.add('Access-Control-Allow-Origin', config.cors_origins)
    
    response.headers.add('Access-Control-Allow-Headers', 'Content-Type,Authorization,X-API-Key')
    response.headers.add('Access-Control-Allow-Methods', 'GET,POST,OPTIONS')
    response.headers.add('Access-Control-Max-Age', '3600')
    
    # 完全禁用缓存 - 通用 + CDN 专用头
    response.headers['Cache-Control'] = 'no-store, no-cache, must-revalidate, max-age=0, s-maxage=0, proxy-revalidate, private'
    response.headers['Pragma'] = 'no-cache'
    response.headers['Expires'] = 'Thu, 01 Jan 1970 00:00:00 GMT'
    response.headers['CDN-Cache-Control'] = 'no-store, max-age=0'
    response.headers['Surrogate-Control'] = 'no-store, max-age=0'
    response.headers['Edge-Control'] = 'no-store, max-age=0'
    response.headers['x-cache-ttl'] = '0'

    api_service.logger.info(f"响应状态: {response.status_code}")

    skip_paths = ('/admin', '/static', '/favicon.ico', '/@', '/__')
    if not request.path.startswith(skip_paths):
        try:
            user_id = None
            api_key_id = None
            if g_api_key_info:
                api_key_id = g_api_key_info['id']
                # 获取 Key 所属用户
                keys = db_helper.list_api_keys()
                for key in keys:
                    if key['id'] == api_key_id:
                        user_id = key['user_id']
                        break
            
            db_helper.log_api_call(
                endpoint=request.path,
                method=request.method,
                ip_address=request.headers.get('X-Forwarded-For', '').split(',')[0].strip() or request.headers.get('X-Real-IP', '') or request.remote_addr or '127.0.0.1',
                user_agent=request.headers.get('User-Agent', '')[:500],
                status_code=response.status_code,
                user_id=user_id,
                api_key_id=api_key_id
            )
        except Exception:
            pass

    return response


@app.errorhandler(400)
def handle_bad_request(e):
    """处理400错误"""
    return APIResponse.error("请求参数错误", 400)


@app.errorhandler(404)
def handle_not_found(e):
    """处理404错误"""
    return APIResponse.error("请求的资源不存在", 404)


@app.errorhandler(500)
def handle_internal_error(e):
    """处理500错误"""
    api_service.logger.error(f"服务器内部错误: {e}")
    return APIResponse.error("服务器内部错误", 500)


def login_required(f):
    """登录检查装饰器 - 支持管理员session或API Key认证"""
    @functools.wraps(f)
    def decorated_function(*args, **kwargs):
        if not session.get('user_id') and not g_api_key_info:
            return APIResponse.error("请先登录或提供有效的API Key", 401)
        return f(*args, **kwargs)
    return decorated_function


@app.route('/')
def index() -> str:
    """首页路由"""
    return render_template('index.html')


@app.route('/docs')
def api_docs():
    """API文档页面"""
    return render_template('docs.html')


@app.route('/user')
def user_home():
    """用户平台首页"""
    return render_template('user_home.html')


@app.route('/user/dashboard')
def user_dashboard():
    """用户控制面板"""
    return render_template('user_dashboard.html')


@app.route('/api/api.php', methods=['GET', 'POST'])
@login_required
def api_php_compat():
    """兼容旧版API格式（Scratch扩展使用）"""
    try:
        data = api_service._safe_get_request_data()
        action = data.get('action', '').lower()
        
        if action == 'search':
            keyword = data.get('name', '')
            limit = int(data.get('limit', 10))
            search_type = int(data.get('type', 1))
            
            import flask
            original_args = flask.request.args.to_dict()
            original_form = flask.request.form.to_dict()
            
            flask.request.args = flask.MultiDict({'keyword': keyword, 'limit': limit})
            flask.request.form = flask.MultiDict({'keyword': keyword, 'limit': limit})
            
            try:
                resp = search_music_api()
                result = []
                for item in resp[0].get('data', []):
                    result.append({
                        'id': item.get('id'),
                        'name': item.get('name'),
                        'artist': item.get('artists', item.get('artist_string', '')),
                        'album': item.get('album', ''),
                        'picUrl': item.get('picUrl', '')
                    })
                return jsonify({'code': 200, 'data': result[:limit], 'msg': 'success'})
            finally:
                flask.request.args = flask.MultiDict(original_args)
                flask.request.form = flask.MultiDict(original_form)
        
        elif action == 'music':
            url = data.get('url', '')
            level = data.get('level', 'standard')
            yrc = data.get('yrc', 0)
            
            if not url:
                return jsonify({'code': 400, 'error': '缺少url参数'})
            
            song_id = api_service._extract_music_id(url)
            cookies = api_service._get_cookies()
            
            valid_levels = ['standard', 'exhigh', 'lossless', 'hires', 'sky', 'jyeffect', 'jymaster']
            if level not in valid_levels:
                level = 'standard'
            
            result = url_v1(song_id, level, cookies)
            if result and result.get('data') and len(result['data']) > 0:
                song_data = result['data'][0]
                response = {
                    'code': 200,
                    'data': {
                        'id': song_data.get('id'),
                        'name': song_data.get('name', ''),
                        'artist': song_data.get('ar', song_data.get('ar_name', '')),
                        'album': song_data.get('al', song_data.get('al_name', '')),
                        'url': song_data.get('url', ''),
                        'size': song_data.get('size', 0),
                        'level': song_data.get('level', level),
                        'pic': song_data.get('pic', ''),
                        'lyric': song_data.get('lyric', ''),
                        'tlyric': song_data.get('tlyric', '')
                    },
                    'msg': 'success'
                }
                
                if isinstance(response['data']['artist'], dict):
                    response['data']['artist'] = response['data']['artist'].get('name', '')
                if isinstance(response['data']['album'], dict):
                    response['data']['album'] = response['data']['album'].get('name', '')
                
                return jsonify(response)
            else:
                return jsonify({'code': 500, 'error': '获取歌曲信息失败'})
        
        elif action == 'artist':
            artist_id = data.get('id', '')
            limit = int(data.get('limit', 10))
            
            if not artist_id:
                return jsonify({'code': 400, 'error': '缺少id参数'})
            
            return jsonify({'code': 200, 'data': [], 'msg': 'success'})
        
        else:
            return jsonify({'code': 400, 'error': f'未知action: {action}'})
    
    except Exception as e:
        api_service.logger.error(f"兼容API错误: {e}")
        return jsonify({'code': 500, 'error': str(e)})


@app.route('/health', methods=['GET'])
def health_check():
    """健康检查API"""
    try:
        # 检查Cookie状态
        cookie_status = api_service.cookie_manager.is_cookie_valid()
        
        health_info = {
            'service': 'running',
            'timestamp': int(time.time()) if 'time' in sys.modules else None,
            'cookie_status': 'valid' if cookie_status else 'invalid',
            'downloads_dir': str(api_service.downloads_path.absolute()),
            'version': '2.0.0'
        }
        
        return APIResponse.success(health_info, "API服务运行正常")
        
    except Exception as e:
        api_service.logger.error(f"健康检查失败: {e}")
        return APIResponse.error(f"健康检查失败: {str(e)}", 500)


@app.route('/song', methods=['GET', 'POST'])
@app.route('/Song_V1', methods=['GET', 'POST'])  # 向后兼容
@login_required
def get_song_info():
    """获取歌曲信息API"""
    try:
        # 获取请求参数
        data = api_service._safe_get_request_data()
        song_ids = data.get('ids') or data.get('id')
        url = data.get('url')
        level = data.get('level', 'lossless')
        info_type = data.get('type', 'url')
        
        # 参数验证
        if not song_ids and not url:
            return APIResponse.error("必须提供 'ids'、'id' 或 'url' 参数")
        
        # 提取音乐ID
        music_id = api_service._extract_music_id(song_ids or url)
        
        # 验证音质参数
        valid_levels = ['standard', 'exhigh', 'lossless', 'hires', 'sky', 'jyeffect', 'jymaster']
        if level not in valid_levels:
            return APIResponse.error(f"无效的音质参数，支持: {', '.join(valid_levels)}")
        
        # 验证类型参数
        valid_types = ['url', 'name', 'lyric', 'json']
        if info_type not in valid_types:
            return APIResponse.error(f"无效的类型参数，支持: {', '.join(valid_types)}")
        
        cookies = api_service._get_cookies()
        
        # 根据类型获取不同信息
        if info_type == 'url':
            result = url_v1(music_id, level, cookies)
            if result and result.get('data') and len(result['data']) > 0:
                song_data = result['data'][0]
                response_data = {
                    'id': song_data.get('id'),
                    'url': song_data.get('url'),
                    'level': song_data.get('level'),
                    'quality_name': api_service._get_quality_display_name(song_data.get('level', level)),
                    'size': song_data.get('size'),
                    'size_formatted': api_service._format_file_size(song_data.get('size', 0)),
                    'type': song_data.get('type'),
                    'bitrate': song_data.get('br')
                }
                return APIResponse.success(response_data, "获取歌曲URL成功")
            else:
                return APIResponse.error("获取音乐URL失败，可能是版权限制或音质不支持", 404)
        
        elif info_type == 'name':
            result = name_v1(music_id)
            return APIResponse.success(result, "获取歌曲信息成功")
        
        elif info_type == 'lyric':
            result = lyric_v1(music_id, cookies)
            return APIResponse.success(result, "获取歌词成功")
        
        elif info_type == 'json':
            # 获取完整的歌曲信息（用于前端解析）
            song_info = name_v1(music_id)
            url_info = url_v1(music_id, level, cookies)
            lyric_info = lyric_v1(music_id, cookies)
            
            if not song_info or 'songs' not in song_info or not song_info['songs']:
                return APIResponse.error("未找到歌曲信息", 404)
            
            song_data = song_info['songs'][0]
            
            # 构建前端期望的响应格式
            response_data = {
                'id': music_id,
                'name': song_data.get('name', ''),
                'ar_name': ', '.join(artist['name'] for artist in song_data.get('ar', [])),
                'al_name': song_data.get('al', {}).get('name', ''),
                'pic': song_data.get('al', {}).get('picUrl', ''),
                'level': level,
                'lyric': lyric_info.get('lrc', {}).get('lyric', '') if lyric_info else '',
                'tlyric': lyric_info.get('tlyric', {}).get('lyric', '') if lyric_info else ''
            }
            
            # 添加URL和大小信息
            if url_info and url_info.get('data') and len(url_info['data']) > 0:
                url_data = url_info['data'][0]
                response_data.update({
                    'url': url_data.get('url', ''),
                    'size': api_service._format_file_size(url_data.get('size', 0)),
                    'level': url_data.get('level', level)
                })
            else:
                response_data.update({
                    'url': '',
                    'size': '获取失败'
                })
            
            return APIResponse.success(response_data, "获取歌曲信息成功")
            
    except APIException as e:
        api_service.logger.error(f"API调用失败: {e}")
        return APIResponse.error(f"API调用失败: {str(e)}", 500)
    except Exception as e:
        api_service.logger.error(f"获取歌曲信息异常: {e}\n{traceback.format_exc()}")
        return APIResponse.error(f"服务器错误: {str(e)}", 500)


@app.route('/search', methods=['GET', 'POST'])
@app.route('/Search', methods=['GET', 'POST'])  # 向后兼容
@login_required
def search_music_api():
    """搜索音乐API"""
    try:
        # 获取请求参数
        data = api_service._safe_get_request_data()
        keyword = data.get('keyword') or data.get('keywords') or data.get('q')
        limit = int(data.get('limit', 30))
        offset = int(data.get('offset', 0))
        search_type = data.get('type', '1')  # 1-歌曲, 10-专辑, 100-歌手, 1000-歌单
        
        # 参数验证
        validation_error = api_service._validate_request_params({'keyword': keyword})
        if validation_error:
            return validation_error
        
        # 限制搜索数量
        if limit > 100:
            limit = 100
        
        cookies = api_service._get_cookies()
        result = search_music(keyword, cookies, limit)
        
        # search_music返回的是歌曲列表，需要包装成前端期望的格式
        if result:
            for song in result:
                # 添加艺术家字符串（如果需要）
                if 'artists' in song:
                    song['artist_string'] = song['artists']
        
        return APIResponse.success(result, "搜索完成")
        
    except ValueError as e:
        return APIResponse.error(f"参数格式错误: {str(e)}")
    except Exception as e:
        api_service.logger.error(f"搜索音乐异常: {e}\n{traceback.format_exc()}")
        return APIResponse.error(f"搜索失败: {str(e)}", 500)


@app.route('/playlist', methods=['GET', 'POST'])
@app.route('/Playlist', methods=['GET', 'POST'])  # 向后兼容
@login_required
def get_playlist():
    """获取歌单详情API"""
    try:
        # 获取请求参数
        data = api_service._safe_get_request_data()
        playlist_id = data.get('id')
        
        # 参数验证
        validation_error = api_service._validate_request_params({'playlist_id': playlist_id})
        if validation_error:
            return validation_error
        
        cookies = api_service._get_cookies()
        result = playlist_detail(playlist_id, cookies)
        
        # 适配前端期望的响应格式
        response_data = {
            'status': 'success',
            'playlist': result
        }
        
        return APIResponse.success(response_data, "获取歌单详情成功")
        
    except Exception as e:
        api_service.logger.error(f"获取歌单异常: {e}\n{traceback.format_exc()}")
        return APIResponse.error(f"获取歌单失败: {str(e)}", 500)


@app.route('/album', methods=['GET', 'POST'])
@app.route('/Album', methods=['GET', 'POST'])  # 向后兼容
@login_required
def get_album():
    """获取专辑详情API"""
    try:
        # 获取请求参数
        data = api_service._safe_get_request_data()
        album_id = data.get('id')
        
        # 参数验证
        validation_error = api_service._validate_request_params({'album_id': album_id})
        if validation_error:
            return validation_error
        
        cookies = api_service._get_cookies()
        result = album_detail(album_id, cookies)
        
        # 适配前端期望的响应格式
        response_data = {
            'status': 200,
            'album': result
        }
        
        return APIResponse.success(response_data, "获取专辑详情成功")
        
    except Exception as e:
        api_service.logger.error(f"获取专辑异常: {e}\n{traceback.format_exc()}")
        return APIResponse.error(f"获取专辑失败: {str(e)}", 500)


@app.route('/download', methods=['GET', 'POST'])
@app.route('/Download', methods=['GET', 'POST'])  # 向后兼容
@login_required
def download_music_api():
    """下载音乐API"""
    try:
        # 获取请求参数
        data = api_service._safe_get_request_data()
        music_id = data.get('id')
        quality = data.get('quality', 'lossless')
        return_format = data.get('format', 'file')  # file 或 json
        
        # 参数验证
        validation_error = api_service._validate_request_params({'music_id': music_id})
        if validation_error:
            return validation_error
        
        # 验证音质参数
        valid_qualities = ['standard', 'exhigh', 'lossless', 'hires', 'sky', 'jyeffect', 'jymaster']
        if quality not in valid_qualities:
            return APIResponse.error(f"无效的音质参数，支持: {', '.join(valid_qualities)}")
        
        # 验证返回格式
        if return_format not in ['file', 'json']:
            return APIResponse.error("返回格式只支持 'file' 或 'json'")
        
        music_id = api_service._extract_music_id(music_id)
        cookies = api_service._get_cookies()
        
        # 获取音乐基本信息
        song_info = name_v1(music_id)
        if not song_info or 'songs' not in song_info or not song_info['songs']:
            return APIResponse.error("未找到音乐信息", 404)
        
        # 获取音乐下载链接
        url_info = url_v1(music_id, quality, cookies)
        if not url_info or 'data' not in url_info or not url_info['data'] or not url_info['data'][0].get('url'):
            return APIResponse.error("无法获取音乐下载链接，可能是版权限制或音质不支持", 404)
        
        # 构建音乐信息
        song_data = song_info['songs'][0]
        url_data = url_info['data'][0]
        
        music_info = {
            'id': music_id,
            'name': song_data['name'],
            'artist_string': ', '.join(artist['name'] for artist in song_data['ar']),
            'album': song_data['al']['name'],
            'pic_url': song_data['al']['picUrl'],
            'file_type': url_data['type'],
            'file_size': url_data['size'],
            'duration': song_data.get('dt', 0),
            'download_url': url_data['url']
        }
        
        # 生成安全文件名
        safe_name = f"{music_info['name']} [{quality}]"
        safe_name = ''.join(c for c in safe_name if c not in r'<>:"/\|?*')
        filename = f"{safe_name}.{music_info['file_type']}"
        
        file_path = api_service.downloads_path / filename
        
        # 检查文件是否已存在
        if file_path.exists():
            api_service.logger.info(f"文件已存在: {filename}")
        else:
            # 使用优化后的下载器下载
            try:
                download_result = api_service.downloader.download_music_file(
                    music_id, quality
                )
                
                if not download_result.success:
                    return APIResponse.error(f"下载失败: {download_result.error_message}", 500)
                
                file_path = Path(download_result.file_path)
                api_service.logger.info(f"下载完成: {filename}")
                
            except DownloadException as e:
                api_service.logger.error(f"下载异常: {e}")
                return APIResponse.error(f"下载失败: {str(e)}", 500)
        
        # 根据返回格式返回结果
        if return_format == 'json':
            response_data = {
                'music_id': music_id,
                'name': music_info['name'],
                'artist': music_info['artist_string'],
                'album': music_info['album'],
                'quality': quality,
                'quality_name': api_service._get_quality_display_name(quality),
                'file_type': music_info['file_type'],
                'file_size': music_info['file_size'],
                'file_size_formatted': api_service._format_file_size(music_info['file_size']),
                'file_path': str(file_path.absolute()),
                'filename': filename,
                'duration': music_info['duration']
            }
            return APIResponse.success(response_data, "下载完成")
        else:
            # 返回文件下载
            if not file_path.exists():
                return APIResponse.error("文件不存在", 404)
            
            try:
                response = send_file(
                    str(file_path),
                    as_attachment=True,
                    download_name=filename,
                    mimetype=f"audio/{music_info['file_type']}"
                )
                response.headers['X-Download-Message'] = 'Download completed successfully'
                response.headers['X-Download-Filename'] = quote(filename, safe='')
                return response
            except Exception as e:
                api_service.logger.error(f"发送文件失败: {e}")
                return APIResponse.error(f"文件发送失败: {str(e)}", 500)
            
    except Exception as e:
        api_service.logger.error(f"下载音乐异常: {e}\n{traceback.format_exc()}")
        return APIResponse.error(f"下载异常: {str(e)}", 500)


@app.route('/stream', methods=['GET', 'POST'])
@login_required
def stream_music():
    """代理音频流，解决跨域问题"""
    data = api_service._safe_get_request_data()
    music_id = data.get('id', '')
    quality = data.get('level', 'lossless')

    try:
        music_id = api_service._extract_music_id(music_id)
        cookies = api_service._get_cookies()
        info = url_v1(music_id, quality, cookies)
        if not info or 'data' not in info or not info['data']:
            return APIResponse.error('无法获取音频链接', 404)
        url = info['data'][0].get('url', '')
        if not url:
            return APIResponse.error('该音质不可用', 404)

        resp = sync_requests.get(url, stream=True, timeout=30,
                                 headers={'User-Agent': 'Mozilla/5.0'})
        if resp.status_code != 200:
            return APIResponse.error('音频源请求失败', 502)

        def generate():
            for chunk in resp.iter_content(chunk_size=65536):
                yield chunk
            resp.close()

        return Response(
            generate(),
            status=200,
            content_type=resp.headers.get('Content-Type', 'audio/mpeg'),
            headers={
                'Accept-Ranges': 'bytes',
                'Cache-Control': 'public, max-age=3600',
                'Access-Control-Allow-Origin': '*'
            }
        )
    except Exception as e:
        return APIResponse.error(f'流代理失败: {str(e)}', 500)


@app.route('/api/info', methods=['GET'])
@login_required
def api_info():
    """API信息接口"""
    try:
        info = {
            'name': '网易云音乐API服务',
            'version': '2.0.0',
            'description': '提供网易云音乐相关API服务',
            'endpoints': {
                '/health': 'GET - 健康检查',
                '/song': 'GET/POST - 获取歌曲信息',
                '/search': 'GET/POST - 搜索音乐',
                '/playlist': 'GET/POST - 获取歌单详情',
                '/album': 'GET/POST - 获取专辑详情',
                '/download': 'GET/POST - 下载音乐',
                '/api/info': 'GET - API信息',
                '/api/proxy': 'GET - 获取代理IP',
                '/api/proxy/refresh': 'POST - 刷新代理池',
                '/api/proxy/protocols': 'GET - 支持的代理协议'
            },
            'supported_qualities': [
                'standard', 'exhigh', 'lossless', 
                'hires', 'sky', 'jyeffect', 'jymaster'
            ],
            'config': {
                'downloads_dir': str(api_service.downloads_path.absolute()),
                'max_file_size': f"{config.max_file_size // (1024*1024)}MB",
                'request_timeout': f"{config.request_timeout}s"
            }
        }
        
        return APIResponse.success(info, "API信息获取成功")
        
    except Exception as e:
        api_service.logger.error(f"获取API信息异常: {e}")
        return APIResponse.error(f"获取API信息失败: {str(e)}", 500)


@app.route('/api/stats', methods=['GET'])
@login_required
def public_stats():
    """公开统计接口"""
    try:
        stats = db_helper.get_total_stats()
        return {'status': 200, 'data': {
            'total_calls': stats['total_calls'],
            'total_visitors': stats['total_unique_visitors'],
            'today_calls': stats['today_calls'],
            'today_visitors': stats['today_unique_visitors'],
            'total_users': stats.get('total_users', 0)
        }}
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


ADMIN_PASSWORD = app_config.ADMIN_PASSWORD


@app.route('/admin', methods=['GET'])
def admin_login_page():
    """后台登录页"""
    return render_template('admin_login.html')


@app.route('/admin/login', methods=['POST'])
def admin_login():
    """后台登录处理"""
    password = (request.form.get('password') or '').strip()
    if password == ADMIN_PASSWORD:
        session['admin_authed'] = True
        return redirect(url_for('admin_dashboard'))
    return render_template('admin_login.html', error='密码错误')


@app.route('/admin/dashboard')
def admin_dashboard():
    """后台仪表盘"""
    if not session.get('admin_authed'):
        return redirect(url_for('admin_login_page'))
    return render_template('admin_dashboard.html')


@app.route('/admin/logout')
def admin_logout():
    """退出登录"""
    session.pop('admin_authed', None)
    return redirect(url_for('admin_login_page'))


@app.route('/admin/api/stats')
def admin_api_stats():
    """仪表盘统计数据API"""
    if not session.get('admin_authed'):
        return {'error': 'unauthorized'}, 403
    try:
        stats = db_helper.get_total_stats()
        return {'status': 200, 'data': stats}
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/admin/api/daily')
def admin_api_daily():
    """每日统计API"""
    if not session.get('admin_authed'):
        return {'error': 'unauthorized'}, 403
    try:
        days = int(request.args.get('days', 30))
        data = db_helper.get_daily_stats(days)
        return {'status': 200, 'data': data}
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/admin/api/hourly')
def admin_api_hourly():
    """今日每小时统计API"""
    if not session.get('admin_authed'):
        return {'error': 'unauthorized'}, 403
    try:
        data = db_helper.get_hourly_today()
        return {'status': 200, 'data': data}
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/admin/api/endpoints')
def admin_api_endpoints():
    """端点统计API"""
    if not session.get('admin_authed'):
        return {'error': 'unauthorized'}, 403
    try:
        data = db_helper.get_top_endpoints()
        return {'status': 200, 'data': data}
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/admin/api/ips')
def admin_api_ips():
    """Top IP统计"""
    if not session.get('admin_authed'):
        return {'error': 'unauthorized'}, 403
    try:
        data = db_helper.get_top_ips()
        return {'status': 200, 'data': data}
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/admin/api/weekly')
def admin_api_weekly():
    """近7天汇总"""
    if not session.get('admin_authed'):
        return {'error': 'unauthorized'}, 403
    try:
        data = db_helper.get_weekly_summary()
        return {'status': 200, 'data': data}
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/admin/api/breakdown')
def admin_api_breakdown():
    """接口分布饼图"""
    if not session.get('admin_authed'):
        return {'error': 'unauthorized'}, 403
    try:
        data = db_helper.get_endpoint_breakdown()
        return {'status': 200, 'data': data}
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/admin/api/logs')
def admin_api_logs():
    """最近调用日志"""
    if not session.get('admin_authed'):
        return {'error': 'unauthorized'}, 403
    try:
        limit = int(request.args.get('limit', 50))
        data = db_helper.get_recent_logs(limit)
        return {'status': 200, 'data': data}
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/admin/api/methods')
def admin_api_methods():
    """请求方法分布"""
    if not session.get('admin_authed'):
        return {'error': 'unauthorized'}, 403
    try:
        data = db_helper.get_method_distribution()
        return {'status': 200, 'data': data}
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


# ===== 公告管理API =====
@app.route('/admin/api/announcements', methods=['GET'])
def admin_api_announcements():
    """获取公告列表"""
    if not session.get('admin_authed'):
        return {'error': 'unauthorized'}, 403
    try:
        data = db_helper.get_announcements()
        return {'status': 200, 'data': data}
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/admin/api/announcement/<int:announcement_id>', methods=['GET'])
def admin_api_get_announcement(announcement_id):
    """获取单个公告"""
    if not session.get('admin_authed'):
        return {'error': 'unauthorized'}, 403
    try:
        data = db_helper.get_announcement(announcement_id)
        if data:
            return {'status': 200, 'data': data}
        else:
            return {'status': 404, 'message': '公告不存在'}, 404
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/admin/api/announcement', methods=['POST'])
def admin_api_create_announcement():
    """创建公告"""
    if not session.get('admin_authed'):
        return {'error': 'unauthorized'}, 403
    try:
        data = request.get_json()
        title = data.get('title', '').strip()
        content = data.get('content', '').strip()
        status = data.get('status', 1)
        
        if not title or not content:
            return {'status': 400, 'message': '标题和内容不能为空'}, 400
        
        result = db_helper.create_announcement(title, content, status)
        if result:
            return {'status': 200, 'data': result, 'message': '创建成功'}
        else:
            return {'status': 500, 'message': '创建失败'}, 500
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/admin/api/announcement/<int:announcement_id>', methods=['PUT'])
def admin_api_update_announcement(announcement_id):
    """更新公告"""
    if not session.get('admin_authed'):
        return {'error': 'unauthorized'}, 403
    try:
        data = request.get_json()
        title = data.get('title', '').strip()
        content = data.get('content', '').strip()
        status = data.get('status', 1)
        
        if not title or not content:
            return {'status': 400, 'message': '标题和内容不能为空'}, 400
        
        result = db_helper.update_announcement(announcement_id, title, content, status)
        if result:
            return {'status': 200, 'data': result, 'message': '更新成功'}
        else:
            return {'status': 404, 'message': '公告不存在'}, 404
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/admin/api/announcement/<int:announcement_id>', methods=['DELETE'])
def admin_api_delete_announcement(announcement_id):
    """删除公告"""
    if not session.get('admin_authed'):
        return {'error': 'unauthorized'}, 403
    try:
        result = db_helper.delete_announcement(announcement_id)
        if result:
            return {'status': 200, 'message': '删除成功'}
        else:
            return {'status': 404, 'message': '公告不存在'}, 404
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


# ===== 前端公告接口 =====
@app.route('/api/announcement', methods=['GET'])
def public_announcement():
    """获取启用的公告（前端展示）"""
    try:
        data = db_helper.get_active_announcement()
        return {'status': 200, 'data': data}
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


# ===== 健康监控API =====
@app.route('/api/health/monitor', methods=['GET'])
def health_monitor_api():
    """获取健康监控数据（从数据库）"""
    stats = db_helper.get_health_check_stats()
    history = db_helper.get_health_check_history(100)
    hourly = db_helper.get_health_hourly_stats()
    daily = db_helper.get_health_daily_trend(7)
    latency_dist = db_helper.get_health_latency_distribution()
    
    availability = 0
    if stats['today_checks'] > 0:
        availability = round((stats['today_success'] / stats['today_checks']) * 100, 1)
    
    return {
        'status': 200,
        'data': {
            'current_status': stats['current_status'],
            'today_availability': availability,
            'avg_latency': stats['avg_latency'],
            'today_checks': stats['today_checks'],
            'last_check': stats['last_check'],
            'history': history,
            'hourly': hourly,
            'daily': daily,
            'latency_distribution': latency_dist
        }
    }


@app.route('/api/health/subscribe', methods=['POST'])
def health_subscribe():
    """订阅健康通知"""
    data = request.get_json(silent=True) or {}
    email = (data.get('email') or '').strip()
    if not email or '@' not in email:
        return {'status': 400, 'success': False, 'message': '请输入有效的邮箱地址'}
    ok = db_helper.subscribe_health_notify(email)
    return {'status': 200 if ok else 500, 'success': ok, 'message': '订阅成功' if ok else '订阅失败'}


@app.route('/api/health/unsubscribe', methods=['POST'])
def health_unsubscribe():
    """取消订阅"""
    data = request.get_json(silent=True) or {}
    email = (data.get('email') or '').strip()
    if not email:
        return {'status': 400, 'success': False, 'message': '请输入邮箱地址'}
    ok = db_helper.unsubscribe_health_notify(email)
    return {'status': 200 if ok else 404, 'success': ok, 'message': '已取消订阅' if ok else '未找到该订阅'}


@app.route('/health/monitor')
def health_monitor_page():
    """健康监控页面"""
    return render_template('health_monitor.html')


# ===== API Key 持久化接口 =====
@app.route('/api/stats/persistent', methods=['GET'])
def persistent_stats():
    """使用 API Key 获取统计数据（持久化方式，无需登录）"""
    api_key = request.headers.get('X-API-Key') or request.args.get('api_key')
    
    if not api_key:
        return {'status': 401, 'message': '缺少 API Key，请在请求头或参数中提供'}, 401
    
    if not db_helper.validate_api_key(api_key, 'stats'):
        return {'status': 403, 'message': '无效或无权限的 API Key'}, 403
    
    try:
        stats = db_helper.get_total_stats()
        return {'status': 200, 'data': {
            'total_calls': stats['total_calls'],
            'total_visitors': stats['total_unique_visitors'],
            'today_calls': stats['today_calls'],
            'today_visitors': stats['today_unique_visitors']
        }}
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/admin/api/keys', methods=['GET'])
def admin_api_list_keys():
    """列出所有 API Keys"""
    if not session.get('admin_authed'):
        return {'error': 'unauthorized'}, 403
    try:
        search = request.args.get('search', '')
        keys = db_helper.get_all_api_keys(search)
        return {'status': 200, 'data': keys}
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/admin/api/key/create', methods=['POST'])
def admin_api_create_key():
    """创建新的 API Key"""
    if not session.get('admin_authed'):
        return {'error': 'unauthorized'}, 403
    try:
        data = request.get_json() or {}
        key_name = data.get('name', '') or 'API Key'
        permissions = data.get('permissions', ['stats'])
        
        api_key = db_helper.create_api_key(key_name, permissions)
        return {'status': 200, 'data': {'api_key': api_key, 'name': key_name}, 'message': '创建成功'}
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/admin/api/key/<int:key_id>', methods=['PUT'])
def admin_api_update_key(key_id):
    """更新 API Key"""
    if not session.get('admin_authed'):
        return {'error': 'unauthorized'}, 403
    try:
        data = request.get_json() or {}
        key_name = data.get('name')
        permissions = data.get('permissions')
        status = data.get('status')
        
        ok = db_helper.update_api_key(key_id, key_name, permissions, status)
        if ok:
            return {'status': 200, 'message': '更新成功'}
        else:
            return {'status': 404, 'message': '未找到或无更新内容'}, 404
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/admin/api/key/<int:key_id>', methods=['DELETE'])
def admin_api_delete_key(key_id):
    """删除 API Key"""
    if not session.get('admin_authed'):
        return {'error': 'unauthorized'}, 403
    try:
        ok = db_helper.delete_api_key(key_id)
        if ok:
            return {'status': 200, 'message': '删除成功'}
        else:
            return {'status': 404, 'message': '未找到'}, 404
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


# ===== 管理后台用户管理 API =====
@app.route('/admin/api/users', methods=['GET'])
def admin_api_users():
    """获取用户列表"""
    if not session.get('admin_authed'):
        return {'error': 'unauthorized'}, 403
    try:
        search = request.args.get('search', '')
        users = db_helper.get_all_users(search)
        return {'status': 200, 'data': users}
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/admin/api/users/<int:user_id>', methods=['GET'])
def admin_api_get_user(user_id):
    """获取单个用户详情"""
    if not session.get('admin_authed'):
        return {'error': 'unauthorized'}, 403
    try:
        user = db_helper.get_user_by_id(user_id)
        if user:
            return {'status': 200, 'data': user}
        else:
            return {'status': 404, 'message': '用户不存在'}, 404
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/admin/api/users/<int:user_id>', methods=['DELETE'])
def admin_api_delete_user(user_id):
    """删除用户"""
    if not session.get('admin_authed'):
        return {'error': 'unauthorized'}, 403
    try:
        ok = db_helper.delete_user(user_id)
        if ok:
            return {'status': 200, 'message': '删除成功'}
        else:
            return {'status': 404, 'message': '用户不存在'}, 404
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/admin/api/keys', methods=['GET'])
def admin_api_list_keys_with_users():
    """获取所有 API Keys（带用户信息）"""
    if not session.get('admin_authed'):
        return {'error': 'unauthorized'}, 403
    try:
        search = request.args.get('search', '')
        keys = db_helper.get_all_api_keys(search)
        return {'status': 200, 'data': keys}
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


# ===== 健康监控API =====
@app.route('/health/stats', methods=['GET'])
def health_stats():
    """健康检查统计"""
    try:
        stats = db_helper.get_health_check_stats()
        return {'status': 200, 'data': stats}
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/health/history', methods=['GET'])
def health_history():
    """健康检查每日趋势"""
    try:
        days = int(request.args.get('days', 7))
        history = db_helper.get_health_daily_trend(days)
        return {'status': 200, 'data': history}
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/health/logs', methods=['GET'])
def health_logs():
    """健康检查日志"""
    try:
        limit = int(request.args.get('limit', 20))
        logs = db_helper.get_health_check_history(limit)
        return {'status': 200, 'data': logs}
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/health/check', methods=['POST'])
def health_check_manual():
    """手动执行健康检查"""
    import time
    start_time = time.time()
    try:
        response = requests.get('http://127.0.0.1:5000/health', timeout=5)
        response_time_ms = int((time.time() - start_time) * 1000)
        success = response.status_code == 200
        message = f'Status: {response.status_code}'
        db_helper.log_health_check(success, response_time_ms, message)
        return {'status': 200, 'data': {'success': success, 'response_time_ms': response_time_ms}}
    except Exception as e:
        response_time_ms = int((time.time() - start_time) * 1000)
        db_helper.log_health_check(False, response_time_ms, str(e))
        return {'status': 500, 'message': str(e)}, 500


# ===== 用户系统 =====
@app.route('/user/register', methods=['POST'])
def user_register():
    """用户注册"""
    try:
        data = request.get_json() or {}
        username = (data.get('username') or '').strip()
        email = (data.get('email') or '').strip()
        password = data.get('password') or ''
        
        if not username or not email or not password:
            return {'status': 400, 'message': '用户名、邮箱和密码不能为空'}, 400
        
        if len(password) < 6:
            return {'status': 400, 'message': '密码长度至少为6位'}, 400
        
        user = db_helper.create_user(username, email, password)
        if user:
            return {'status': 200, 'message': '注册成功', 'data': user}
        else:
            return {'status': 400, 'message': '用户名或邮箱已存在'}, 400
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/user/login', methods=['POST'])
def user_login():
    """用户登录"""
    try:
        data = request.get_json() or {}
        username = (data.get('username') or '').strip()
        password = data.get('password') or ''
        
        if not username or not password:
            return {'status': 400, 'message': '用户名和密码不能为空'}, 400
        
        user = db_helper.get_user_by_username(username)
        if not user:
            return {'status': 401, 'message': '用户名或密码错误'}, 401
        
        if user['password_hash'] != db_helper.hash_password(password):
            return {'status': 401, 'message': '用户名或密码错误'}, 401
        
        if user['status'] != 1:
            return {'status': 403, 'message': '账号已被禁用'}, 403
        
        db_helper.update_user_last_login(user['id'])
        session['user_id'] = user['id']
        session['username'] = user['username']
        
        user_info = db_helper.get_user_by_id(user['id'])
        return {'status': 200, 'message': '登录成功', 'data': user_info}
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/user/logout', methods=['POST'])
def user_logout():
    """用户登出"""
    session.pop('user_id', None)
    session.pop('username', None)
    return {'status': 200, 'message': '登出成功'}


@app.route('/user/me', methods=['GET'])
def user_profile():
    """获取当前用户信息"""
    if 'user_id' not in session:
        return {'status': 401, 'message': '请先登录'}, 401
    
    user = db_helper.get_user_by_id(session['user_id'])
    if user:
        return {'status': 200, 'data': user}
    return {'status': 404, 'message': '用户不存在'}, 404


@app.route('/api/user/status', methods=['GET'])
def api_user_status():
    """检查用户登录状态"""
    if 'user_id' in session:
        user = db_helper.get_user_by_id(session['user_id'])
        if user:
            return {'status': 200, 'data': {
                'logged_in': True,
                'user_id': user['id'],
                'username': user['username'],
                'email': user['email']
            }}
    return {'status': 200, 'data': {'logged_in': False}}


# ===== 用户端 API Key 管理 =====
@app.route('/user/keys', methods=['GET'])
def user_list_keys():
    """获取用户的 API Keys"""
    if 'user_id' not in session:
        return {'status': 401, 'message': '请先登录'}, 401
    
    keys = db_helper.list_api_keys(session['user_id'])
    return {'status': 200, 'data': keys}


@app.route('/user/keys/create', methods=['POST'])
def user_create_key():
    """用户创建 API Key"""
    if 'user_id' not in session:
        return {'status': 401, 'message': '请先登录'}, 401
    
    try:
        data = request.get_json() or {}
        key_name = (data.get('name') or '').strip() or '我的密钥'
        permissions = data.get('permissions', ['stats'])
        
        api_key = db_helper.create_api_key(session['user_id'], key_name, permissions)
        return {'status': 200, 'message': '创建成功', 'data': {'api_key': api_key, 'name': key_name}}
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/user/keys/<int:key_id>/reset', methods=['POST'])
def user_reset_key(key_id):
    """用户重置 API Key"""
    if 'user_id' not in session:
        return {'status': 401, 'message': '请先登录'}, 401
    
    new_key = db_helper.reset_api_key(key_id, session['user_id'])
    if new_key:
        return {'status': 200, 'message': '重置成功', 'data': {'api_key': new_key}}
    else:
        return {'status': 404, 'message': 'Key 不存在或无权限'}, 404


@app.route('/user/keys/<int:key_id>/toggle', methods=['POST'])
def user_toggle_key(key_id):
    """用户启用/禁用 API Key"""
    if 'user_id' not in session:
        return {'status': 401, 'message': '请先登录'}, 401
    
    if not db_helper.check_key_owner(key_id, session['user_id']):
        return {'status': 403, 'message': '无权限操作该 Key'}, 403
    
    try:
        data = request.get_json() or {}
        status = int(data.get('status', 1))
        db_helper.update_api_key(key_id, status=status)
        return {'status': 200, 'message': '更新成功'}
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/user/keys/<int:key_id>/delete', methods=['POST'])
def user_delete_key(key_id):
    """用户删除 API Key"""
    if 'user_id' not in session:
        return {'status': 401, 'message': '请先登录'}, 401
    
    result = db_helper.delete_api_key(key_id, session['user_id'])
    if result:
        return {'status': 200, 'message': '删除成功'}
    else:
        return {'status': 404, 'message': 'Key 不存在或无权限'}, 404


@app.route('/user/stats', methods=['GET'])
def user_stats():
    """获取用户统计数据"""
    if 'user_id' not in session:
        return {'status': 401, 'message': '请先登录'}, 401
    
    try:
        stats = db_helper.get_user_stats(session['user_id'])
        daily_stats = db_helper.get_user_daily_stats(session['user_id'])
        return {'status': 200, 'data': {'stats': stats, 'daily': daily_stats}}
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


@app.route('/user/keys/<int:key_id>/stats', methods=['GET'])
def user_key_stats(key_id):
    """获取某个 Key 的统计数据"""
    if 'user_id' not in session:
        return {'status': 401, 'message': '请先登录'}, 401
    
    if not db_helper.check_key_owner(key_id, session['user_id']):
        return {'status': 403, 'message': '无权限查看该 Key'}, 403
    
    try:
        stats = db_helper.get_user_key_stats(key_id)
        return {'status': 200, 'data': stats}
    except Exception as e:
        return {'status': 500, 'message': str(e)}, 500


# ===== 管理后台 API =====
@app.route('/admin/users', methods=['GET'])
def admin_list_users():
    """管理员获取所有用户"""
    if not session.get('admin_authed'):
        return {'error': 'unauthorized'}, 403
    
    users = db_helper.list_all_users()
    return {'status': 200, 'data': users}


@app.route('/admin/users/<int:user_id>/keys', methods=['GET'])
def admin_get_user_keys(user_id):
    """管理员获取某用户的 Keys"""
    if not session.get('admin_authed'):
        return {'error': 'unauthorized'}, 403
    
    keys = db_helper.list_api_keys(user_id)
    return {'status': 200, 'data': keys}


# ===== 代理池 API =====
@app.route('/api/proxy', methods=['GET'])
def get_proxy():
    """获取代理IP列表

    参数:
        protocol: 代理协议 (http, https, socks4, socks5, all)
        count: 获取数量 (1-20, 默认5)
        refresh: 是否强制刷新 (1=是, 0=否)
    """
    try:
        data = api_service._safe_get_request_data()
        protocol = data.get('protocol', 'all')
        count = min(int(data.get('count', 5)), 20)
        refresh = data.get('refresh', '0') == '1'

        valid_protocols = ['http', 'https', 'socks4', 'socks5', 'all']
        if protocol not in valid_protocols:
            protocol = 'all'

        proxies = proxy_pool.get_proxies(protocol, count, refresh)
        return APIResponse.success({
            'proxies': proxies,
            'count': len(proxies),
            'protocol': protocol,
            'source': 'scdn'
        }, "获取成功")
    except Exception as e:
        api_service.logger.error(f"获取代理失败: {e}")
        return APIResponse.error(f"获取代理失败: {str(e)}", 500)


@app.route('/api/proxy/refresh', methods=['POST'])
def refresh_proxy():
    """刷新代理池"""
    try:
        data = api_service._safe_get_request_data()
        protocol = data.get('protocol', 'all')

        valid_protocols = ['http', 'https', 'socks4', 'socks5', 'all']
        if protocol not in valid_protocols:
            protocol = 'all'

        count = proxy_pool.refresh(protocol)
        return APIResponse.success({'count': count}, f"刷新成功，获取到 {count} 个代理")
    except Exception as e:
        api_service.logger.error(f"刷新代理失败: {e}")
        return APIResponse.error(f"刷新代理失败: {str(e)}", 500)


@app.route('/api/proxy/protocols', methods=['GET'])
def proxy_protocols():
    """获取支持的代理协议"""
    return APIResponse.success({
        'protocols': [
            {'name': 'http', 'description': 'HTTP代理'},
            {'name': 'https', 'description': 'HTTPS代理'},
            {'name': 'socks4', 'description': 'SOCKS4代理'},
            {'name': 'socks5', 'description': 'SOCKS5代理'},
            {'name': 'all', 'description': '任意类型'}
        ]
    }, "获取成功")


def start_api_server():
    """启动API服务器"""
    try:
        print("\n" + "="*60)
        print("🚀 网易云音乐API服务启动中...")
        print("="*60)
        print(f"📡 服务地址: http://{config.host}:{config.port}")
        print(f"📁 下载目录: {api_service.downloads_path.absolute()}")
        print(f"📋 日志级别: {config.log_level}")
        print("\n📚 API端点:")
        print(f"  ├─ GET  /health        - 健康检查")
        print(f"  ├─ POST /song          - 获取歌曲信息")
        print(f"  ├─ POST /search        - 搜索音乐")
        print(f"  ├─ POST /playlist      - 获取歌单详情")
        print(f"  ├─ POST /album         - 获取专辑详情")
        print(f"  ├─ POST /download      - 下载音乐")
        print(f"  └─ GET  /api/info      - API信息")
        print("\n🎵 支持的音质:")
        print(f"  standard, exhigh, lossless, hires, sky, jyeffect, jymaster")
        print("="*60)
        print(f"⏰ 启动时间: {time.strftime('%Y-%m-%d %H:%M:%S')}")
        print("🌟 服务已就绪，等待请求...\n")
        
        # 启动Flask应用
        app.run(
            host=config.host,
            port=config.port,
            debug=config.debug,
            threaded=True
        )
        
    except KeyboardInterrupt:
        print("\n\n👋 服务已停止")
    except Exception as e:
        api_service.logger.error(f"启动服务失败: {e}")
        print(f"❌ 启动失败: {e}")
        sys.exit(1)


if __name__ == '__main__':
    start_api_server()