# -*- coding: utf-8 -*-
"""
AI 配置 API

提供 AI 提供商配置的 CRUD 接口
"""

from flask import Blueprint, jsonify, request, g
from app.models.database import db, AIProviderConfig, AIProviderType, SystemAIConfig
from app.models.database.user import Role
from app.services.auth.decorators import login_required, admin_required
from app.services.ai.providers import AIProviderFactory

ai_config_bp = Blueprint('ai_config', __name__, url_prefix='/api/ai-config')


# ============================================================
# 公共接口
# ============================================================

@ai_config_bp.route('/providers', methods=['GET'])
@login_required
def get_providers():
    """获取所有可用的 AI 提供商信息"""
    try:
        providers = SystemAIConfig.get_all_provider_info()
        return jsonify({
            'success': True,
            'providers': providers
        })
    except Exception as e:
        return jsonify({
            'success': False,
            'message': str(e)
        }), 500


@ai_config_bp.route('/current', methods=['GET'])
@login_required
def get_current_config():
    """获取当前用户有效的 AI 配置"""
    try:
        user_id = g.user.id
        
        # 检查是否强制使用系统 AI
        force_system = SystemAIConfig.force_system_ai()
        allow_custom = SystemAIConfig.allow_user_custom_ai()
        
        # 获取有效配置
        config = AIProviderConfig.get_effective_config(user_id)
        
        result = {
            'has_config': config is not None,
            'force_system_ai': force_system,
            'allow_custom_ai': allow_custom,
            'config': config.to_dict(include_key_preview=True) if config else None,
            'is_system_config': config.user_id is None if config else False
        }
        
        return jsonify({
            'success': True,
            'data': result
        })
    except Exception as e:
        return jsonify({
            'success': False,
            'message': str(e)
        }), 500


# ============================================================
# 用户配置接口
# ============================================================

@ai_config_bp.route('/user/list', methods=['GET'])
@login_required
def list_user_configs():
    """获取当前用户的所有 AI 配置"""
    try:
        user_id = g.user.id
        configs = AIProviderConfig.query.filter_by(user_id=user_id, is_active=True).all()
        
        return jsonify({
            'success': True,
            'configs': [c.to_dict(include_key_preview=True) for c in configs]
        })
    except Exception as e:
        return jsonify({
            'success': False,
            'message': str(e)
        }), 500


@ai_config_bp.route('/user/available', methods=['GET'])
@login_required
def get_available_configs():
    """获取用户可用的 AI 配置列表（用于向导页面选择）
    
    返回用户的个人配置和系统级配置池（如果允许）
    """
    try:
        user_id = g.user.id
        result = []

        # 预先计算“当前有效配置”，用于标记 is_default
        effective_config = AIProviderConfig.get_effective_config(user_id)

        # 检查系统配置策略
        force_system = SystemAIConfig.force_system_ai()
        allow_custom = SystemAIConfig.allow_user_custom_ai()

        # 用户首选的系统 AI 配置（如果存在）
        preferred_system_id = getattr(g.user, "preferred_system_ai_config_id", None)

        # 获取用户个人配置（仅在允许自定义且未强制系统 AI 时暴露）
        if allow_custom and not force_system:
            user_configs = AIProviderConfig.query.filter_by(
                user_id=user_id, 
                is_active=True
            ).order_by(AIProviderConfig.is_default.desc()).all()
            
            for config in user_configs:
                result.append({
                    'id': config.id,
                    'name': config.name or config.provider_type,
                    'provider_type': config.provider_type,
                    'provider_name': AIProviderType.get_display_name(config.provider_type),
                    'model': config.model,
                    # is_default 由 effective_config 决定，以“当前实际生效”的配置为准
                    'is_default': bool(effective_config and effective_config.id == config.id),
                    'is_system': False,
                    'scope': 'user',
                    'is_user_default': bool(config.is_default),
                    'test_status': config.test_status
                })
        
        # 获取所有系统级配置池（user_id 为 None）
        # 注意：不再按 is_default 排序，因为不再有"系统全局默认"概念
        system_configs = AIProviderConfig.query.filter_by(
            user_id=None,
            is_active=True
        ).order_by(
            AIProviderConfig.created_at.asc()
        ).all()

        for config in system_configs:
            result.append({
                'id': config.id,
                'name': config.name or config.provider_type,
                'provider_type': config.provider_type,
                'provider_name': AIProviderType.get_display_name(config.provider_type),
                'model': config.model,
                # is_default：标识"当前对该用户真正生效的配置"，与 effective_config 对齐
                'is_default': bool(effective_config and effective_config.id == config.id),
                'is_system': True,
                'scope': 'system',
                # 是否为该用户在系统池中选择的配置
                'is_user_chosen_system': bool(preferred_system_id and preferred_system_id == config.id),
                'test_status': config.test_status
            })
        
        return jsonify({
            'success': True,
            'configs': result,
            'force_system_ai': force_system,
            'allow_custom_ai': allow_custom
        })
    except Exception as e:
        return jsonify({
            'success': False,
            'message': str(e)
        }), 500


@ai_config_bp.route('/user/create', methods=['POST'])
@login_required
def create_user_config():
    """创建用户 AI 配置"""
    try:
        # 检查是否允许用户自定义
        if not SystemAIConfig.allow_user_custom_ai():
            return jsonify({
                'success': False,
                'message': '管理员已禁用用户自定义 AI 配置'
            }), 403
        
        data = request.get_json()
        user_id = g.user.id
        
        # 验证必需字段
        provider_type = data.get('provider_type')
        api_key = data.get('api_key')
        
        if not provider_type:
            return jsonify({
                'success': False,
                'message': '请选择 AI 提供商'
            }), 400
        
        if not api_key:
            return jsonify({
                'success': False,
                'message': '请输入 API Key'
            }), 400
        
        # 检查提供商是否启用
        if not SystemAIConfig.is_provider_enabled(provider_type):
            return jsonify({
                'success': False,
                'message': f'提供商 {provider_type} 未启用'
            }), 400
        
        # 创建配置
        config = AIProviderConfig.create_config(
            user_id=user_id,
            provider_type=provider_type,
            api_key=api_key,
            model=data.get('model'),
            base_url=data.get('base_url'),
            name=data.get('name'),
            is_default=data.get('is_default', False)
        )
        
        # 如果前端传递了测试状态，更新它
        if data.get('test_status'):
            config.test_status = data.get('test_status')
            config.test_message = data.get('test_message')
            db.session.commit()
        
        return jsonify({
            'success': True,
            'message': 'AI 配置创建成功',
            'config': config.to_dict(include_key_preview=True)
        })
        
    except Exception as e:
        db.session.rollback()
        return jsonify({
            'success': False,
            'message': f'创建失败: {str(e)}'
        }), 500


@ai_config_bp.route('/user/<int:config_id>', methods=['PUT'])
@login_required
def update_user_config(config_id):
    """更新用户 AI 配置"""
    try:
        user_id = g.user.id
        config = AIProviderConfig.query.get(config_id)
        
        if not config or config.user_id != user_id:
            return jsonify({
                'success': False,
                'message': '配置不存在'
            }), 404
        
        data = request.get_json()
        
        # 更新字段
        if 'provider_type' in data:
            config.provider_type = data['provider_type']
        if 'name' in data:
            config.name = data['name']
        if 'model' in data:
            config.model = data['model']
        if 'base_url' in data:
            config.base_url = data['base_url']
        if 'api_key' in data and data['api_key']:
            config.set_api_key(data['api_key'])
        if 'is_active' in data:
            config.is_active = data['is_active']
        if 'is_default' in data and data['is_default']:
            AIProviderConfig.set_user_default(user_id, config_id)
        
        db.session.commit()
        
        return jsonify({
            'success': True,
            'message': '配置更新成功',
            'config': config.to_dict(include_key_preview=True)
        })
        
    except Exception as e:
        db.session.rollback()
        return jsonify({
            'success': False,
            'message': f'更新失败: {str(e)}'
        }), 500


@ai_config_bp.route('/user/<int:config_id>', methods=['DELETE'])
@login_required
def delete_user_config(config_id):
    """删除用户 AI 配置"""
    try:
        user_id = g.user.id
        config = AIProviderConfig.query.get(config_id)
        
        if not config or config.user_id != user_id:
            return jsonify({
                'success': False,
                'message': '配置不存在'
            }), 404
        
        db.session.delete(config)
        db.session.commit()
        
        return jsonify({
            'success': True,
            'message': '配置已删除'
        })
        
    except Exception as e:
        db.session.rollback()
        return jsonify({
            'success': False,
            'message': f'删除失败: {str(e)}'
        }), 500


@ai_config_bp.route('/user/<int:config_id>/set-default', methods=['POST'])
@login_required
def set_user_default_config(config_id):
    """设置用户默认 AI 配置"""
    try:
        user_id = g.user.id
        success = AIProviderConfig.set_user_default(user_id, config_id)
        
        if success:
            return jsonify({
                'success': True,
                'message': '已设为默认配置'
            })
        else:
            return jsonify({
                'success': False,
                'message': '配置不存在'
            }), 404
            
    except Exception as e:
        db.session.rollback()
        return jsonify({
            'success': False,
            'message': f'设置失败: {str(e)}'
        }), 500


@ai_config_bp.route('/test', methods=['POST'])
@login_required
def test_connection():
    """测试 AI 连接"""
    try:
        data = request.get_json()
        
        provider_type = data.get('provider_type')
        api_key = data.get('api_key')
        base_url = data.get('base_url')
        model = data.get('model')
        
        if not provider_type:
            return jsonify({
                'success': False,
                'message': '请提供提供商类型'
            }), 400
        
        # 对于augment，api_key可以为空（使用USE_EXISTING）
        # 对于其他类型，需要api_key
        if provider_type not in ['augment'] and not api_key:
            return jsonify({
                'success': False,
                'message': '请提供 API Key'
            }), 400
        
        # CLI 模式的提供商（AnyRouter、AgentRouter、Augment）需要特殊处理
        if provider_type in ['anyrouter', 'agentrouter', 'augment']:
            if provider_type == 'anyrouter':
                # 如果是 USE_EXISTING，尝试从数据库获取
                actual_token = api_key
                if api_key == 'USE_EXISTING':
                    config = AIProviderConfig.get_user_config(
                        user_id=g.user.id,
                        provider_type='anyrouter'
                    )
                    if config:
                        actual_token = config.get_api_key()
                    if not actual_token:
                        global_config = AIProviderConfig.query.filter_by(
                            user_id=None,
                            provider_type='anyrouter',
                            is_active=True,
                            is_default=True
                        ).first()
                        if global_config:
                            actual_token = global_config.get_api_key()
                
                if not actual_token:
                    return jsonify({
                        'success': True,
                        'test_result': {
                            'success': False,
                            'message': '未配置 AnyRouter Token，请先输入 Token'
                        }
                    })
                if not actual_token.startswith('sk-'):
                    return jsonify({
                        'success': True,
                        'test_result': {
                            'success': False,
                            'message': 'Token 格式不正确，应以 sk- 开头'
                        }
                    })
                
                # 通过调用 Claude CLI 命令行测试 Token（参考 Augment 的调用方式）
                import subprocess
                import time
                import os
                
                try:
                    start_time = time.time()
                    
                    # 设置临时环境变量（不影响系统环境）
                    env = os.environ.copy()
                    env['ANTHROPIC_AUTH_TOKEN'] = actual_token
                    env['ANTHROPIC_BASE_URL'] = 'https://anyrouter.top'
                    
                    # 使用 Popen 执行命令，类似 Augment 的方式
                    process = subprocess.Popen(
                        ['claude', '-p', 'Reply with exactly: ANYROUTER_OK'],
                        stdout=subprocess.PIPE,
                        stderr=subprocess.STDOUT,
                        text=True,
                        env=env,
                        bufsize=0
                    )
                    
                    # 读取输出
                    output_lines = []
                    try:
                        while True:
                            line = process.stdout.readline()
                            if not line:
                                if process.poll() is not None:
                                    break
                                continue
                            output_lines.append(line)
                    except:
                        pass
                    
                    # 等待进程结束
                    return_code = process.wait(timeout=60)
                    latency = int((time.time() - start_time) * 1000)
                    output = ''.join(output_lines).strip()
                    
                    if return_code == 0:
                        if 'ANYROUTER_OK' in output:
                            return jsonify({
                                'success': True,
                                'test_result': {
                                    'success': True,
                                    'message': 'AnyRouter 连接成功！AI 回复验证通过',
                                    'latency': latency
                                }
                            })
                        else:
                            # 即使没有精确匹配，只要有输出也算成功
                            return jsonify({
                                'success': True,
                                'test_result': {
                                    'success': True,
                                    'message': f'AnyRouter 连接成功！AI 回复: {output[:100]}',
                                    'latency': latency
                                }
                            })
                    else:
                        error_msg = output
                        if 'Invalid API Key' in error_msg or 'authentication' in error_msg.lower():
                            return jsonify({
                                'success': True,
                                'test_result': {
                                    'success': False,
                                    'message': 'Token 无效或已过期'
                                }
                            })
                        elif 'offline' in error_msg.lower():
                            return jsonify({
                                'success': True,
                                'test_result': {
                                    'success': False,
                                    'message': '网络连接失败，请检查网络'
                                }
                            })
                        return jsonify({
                            'success': True,
                            'test_result': {
                                'success': False,
                                'message': f'CLI 执行失败: {error_msg[:200]}'
                            }
                        })
                        
                except FileNotFoundError:
                    return jsonify({
                        'success': True,
                        'test_result': {
                            'success': False,
                            'message': 'Claude CLI 未安装，请先运行: npm install -g @anthropic-ai/claude-code'
                        }
                    })
                except subprocess.TimeoutExpired:
                    process.kill()
                    return jsonify({
                        'success': True,
                        'test_result': {
                            'success': False,
                            'message': '连接超时（60秒），请检查网络'
                        }
                    })
                except Exception as e:
                    return jsonify({
                        'success': True,
                        'test_result': {
                            'success': False,
                            'message': f'测试失败: {str(e)}'
                        }
                    })
            elif provider_type == 'agentrouter':
                # AgentRouter 测试逻辑（与 AnyRouter 类似，只是 URL 不同）
                actual_token = api_key
                if api_key == 'USE_EXISTING':
                    config = AIProviderConfig.get_user_config(
                        user_id=g.user.id,
                        provider_type='agentrouter'
                    )
                    if config:
                        actual_token = config.get_api_key()
                    if not actual_token:
                        global_config = AIProviderConfig.query.filter_by(
                            user_id=None,
                            provider_type='agentrouter',
                            is_active=True,
                            is_default=True
                        ).first()
                        if global_config:
                            actual_token = global_config.get_api_key()
                
                if not actual_token:
                    return jsonify({
                        'success': True,
                        'test_result': {
                            'success': False,
                            'message': '未配置 AgentRouter Token，请先输入 Token'
                        }
                    })
                if not actual_token.startswith('sk-'):
                    return jsonify({
                        'success': True,
                        'test_result': {
                            'success': False,
                            'message': 'Token 格式不正确，应以 sk- 开头'
                        }
                    })
                
                # 通过调用 Claude CLI 命令行测试 Token
                import subprocess
                import time
                import os
                
                try:
                    start_time = time.time()
                    
                    # 设置临时环境变量
                    env = os.environ.copy()
                    env['ANTHROPIC_AUTH_TOKEN'] = actual_token
                    env['ANTHROPIC_API_KEY'] = actual_token
                    env['ANTHROPIC_BASE_URL'] = 'https://agentrouter.org/'
                    
                    # 使用 Popen 执行命令
                    process = subprocess.Popen(
                        ['claude', '-p', 'Reply with exactly: AGENTROUTER_OK'],
                        stdout=subprocess.PIPE,
                        stderr=subprocess.STDOUT,
                        text=True,
                        env=env,
                        bufsize=0
                    )
                    
                    # 读取输出
                    output_lines = []
                    try:
                        while True:
                            line = process.stdout.readline()
                            if not line:
                                if process.poll() is not None:
                                    break
                                continue
                            output_lines.append(line)
                    except:
                        pass
                    
                    # 等待进程结束
                    return_code = process.wait(timeout=60)
                    latency = int((time.time() - start_time) * 1000)
                    output = ''.join(output_lines).strip()
                    
                    if return_code == 0:
                        if 'AGENTROUTER_OK' in output:
                            return jsonify({
                                'success': True,
                                'test_result': {
                                    'success': True,
                                    'message': 'AgentRouter 连接成功！AI 回复验证通过',
                                    'latency': latency
                                }
                            })
                        else:
                            return jsonify({
                                'success': True,
                                'test_result': {
                                    'success': True,
                                    'message': f'AgentRouter 连接成功！AI 回复: {output[:100]}',
                                    'latency': latency
                                }
                            })
                    else:
                        error_msg = output
                        if 'Invalid API Key' in error_msg or 'authentication' in error_msg.lower():
                            return jsonify({
                                'success': True,
                                'test_result': {
                                    'success': False,
                                    'message': 'Token 无效或已过期'
                                }
                            })
                        elif 'offline' in error_msg.lower():
                            return jsonify({
                                'success': True,
                                'test_result': {
                                    'success': False,
                                    'message': '网络连接失败，请检查网络'
                                }
                            })
                        return jsonify({
                            'success': True,
                            'test_result': {
                                'success': False,
                                'message': f'CLI 执行失败: {error_msg[:200]}'
                            }
                        })
                        
                except FileNotFoundError:
                    return jsonify({
                        'success': True,
                        'test_result': {
                            'success': False,
                            'message': 'Claude CLI 未安装，请先运行: npm install -g @anthropic-ai/claude-code'
                        }
                    })
                except subprocess.TimeoutExpired:
                    process.kill()
                    return jsonify({
                        'success': True,
                        'test_result': {
                            'success': False,
                            'message': '连接超时（60秒），请检查网络'
                        }
                    })
                except Exception as e:
                    return jsonify({
                        'success': True,
                        'test_result': {
                            'success': False,
                            'message': f'测试失败: {str(e)}'
                        }
                    })
            else:  # augment
                result = {
                    'success': True,
                    'message': 'Augment Token 已配置（CLI 模式）'
                }
                
                # 如果是已保存的配置，更新测试状态
                config_id = data.get('config_id')
                if config_id:
                    config = AIProviderConfig.query.get(config_id)
                    if config:
                        # 用户配置：只有配置所有者可以更新
                        # 系统配置：管理员可以更新
                        can_update = False
                        if config.user_id == g.user.id:
                            can_update = True
                        elif config.user_id is None and g.user and g.user.role in [Role.ADMIN, Role.MODERATOR]:
                            can_update = True
                        
                        if can_update:
                            config.update_test_status('success', result['message'])
                            db.session.commit()  # 确保测试状态被保存到数据库
                
                return jsonify({
                    'success': True,
                    'test_result': result
                })
        
        # 创建临时提供商实例进行测试
        provider = AIProviderFactory.create(
            provider_type=provider_type,
            api_key=api_key,
            base_url=base_url,
            model=model
        )
        
        # 测试连接
        result = provider.test_connection()
        
        # 如果是已保存的配置，更新测试状态
        config_id = data.get('config_id')
        if config_id:
            config = AIProviderConfig.query.get(config_id)
            if config:
                # 用户配置：只有配置所有者可以更新
                # 系统配置：管理员可以更新
                can_update = False
                if config.user_id == g.user.id:
                    can_update = True
                elif config.user_id is None and g.user and g.user.role in [Role.ADMIN, Role.MODERATOR]:
                    can_update = True
                
                if can_update:
                    config.update_test_status(
                        'success' if result['success'] else 'failed',
                        result['message']
                    )
                    db.session.commit()  # 确保测试状态被保存到数据库
        
        return jsonify({
            'success': True,
            'test_result': result
        })
        
    except Exception as e:
        return jsonify({
            'success': False,
            'message': f'测试失败: {str(e)}'
        }), 500


# ============================================================
# 管理员接口 - 系统级 AI 配置（与个人配置风格统一）
# 使用 AIProviderConfig，user_id 为 None 表示系统级配置
# ============================================================


@ai_config_bp.route('/admin/system/configs', methods=['GET'])
@admin_required
def list_system_ai_configs():
    """获取所有系统级 AI 配置列表"""
    try:
        configs = AIProviderConfig.query.filter_by(
            user_id=None,
            is_active=True
        ).order_by(
            AIProviderConfig.is_default.desc(),
            AIProviderConfig.created_at.asc()
        ).all()

        return jsonify({
            'success': True,
            'configs': [c.to_dict(include_key_preview=True) for c in configs]
        })
    except Exception as e:
        return jsonify({
            'success': False,
            'message': str(e)
        }), 500


@ai_config_bp.route('/admin/system/configs', methods=['POST'])
@admin_required
def create_system_ai_config():
    """创建系统级 AI 配置（user_id 为 None）"""
    try:
        data = request.get_json() or {}

        provider_type = data.get('provider_type')
        api_key = data.get('api_key')

        if not provider_type:
            return jsonify({
                'success': False,
                'message': '请选择 AI 提供商'
            }), 400

        if not api_key:
            return jsonify({
                'success': False,
                'message': '请输入 API Key'
            }), 400

        # 检查提供商是否启用
        if not SystemAIConfig.is_provider_enabled(provider_type):
            return jsonify({
                'success': False,
                'message': f'提供商 {provider_type} 未启用'
            }), 400

        is_default = bool(data.get('is_default', False))

        config = AIProviderConfig.create_config(
            user_id=None,
            provider_type=provider_type,
            api_key=api_key,
            model=data.get('model'),
            base_url=data.get('base_url'),
            name=data.get('name'),
            is_default=is_default
        )

        return jsonify({
            'success': True,
            'message': '系统 AI 配置创建成功',
            'config': config.to_dict(include_key_preview=True)
        })
    except Exception as e:
        db.session.rollback()
        return jsonify({
            'success': False,
            'message': f'创建失败: {str(e)}'
        }), 500


@ai_config_bp.route('/admin/system/configs/<int:config_id>', methods=['PUT'])
@admin_required
def update_system_ai_config(config_id):
    """更新系统级 AI 配置"""
    try:
        config = AIProviderConfig.query.get(config_id)
        if not config or config.user_id is not None:
            return jsonify({
                'success': False,
                'message': '系统 AI 配置不存在'
            }), 404

        data = request.get_json() or {}

        if 'provider_type' in data:
            provider_type = data['provider_type']
            if not SystemAIConfig.is_provider_enabled(provider_type):
                return jsonify({
                    'success': False,
                    'message': f'提供商 {provider_type} 未启用'
                }), 400
            config.provider_type = provider_type

        if 'name' in data:
            config.name = data['name'] or AIProviderType.get_display_name(config.provider_type)
        if 'model' in data:
            config.model = data['model']
        if 'base_url' in data:
            config.base_url = data['base_url'] or AIProviderType.get_default_base_url(config.provider_type)
        if 'api_key' in data and data['api_key']:
            config.set_api_key(data['api_key'])
        if 'is_active' in data:
            config.is_active = bool(data['is_active'])

        # 处理是否设为默认
        if 'is_default' in data and data['is_default']:
            # 复用 set_user_default 逻辑，user_id 为 None
            AIProviderConfig.set_user_default(None, config_id)

        db.session.commit()

        return jsonify({
            'success': True,
            'message': '系统 AI 配置更新成功',
            'config': config.to_dict(include_key_preview=True)
        })
    except Exception as e:
        db.session.rollback()
        return jsonify({
            'success': False,
            'message': f'更新失败: {str(e)}'
        }), 500


@ai_config_bp.route('/admin/system/configs/<int:config_id>', methods=['DELETE'])
@admin_required
def delete_system_ai_config(config_id):
    """删除系统级 AI 配置"""
    try:
        config = AIProviderConfig.query.get(config_id)
        if not config or config.user_id is not None:
            return jsonify({
                'success': False,
                'message': '系统 AI 配置不存在'
            }), 404

        db.session.delete(config)
        db.session.commit()

        return jsonify({
            'success': True,
            'message': '系统 AI 配置已删除'
        })
    except Exception as e:
        db.session.rollback()
        return jsonify({
            'success': False,
            'message': f'删除失败: {str(e)}'
        }), 500


@ai_config_bp.route('/admin/system/configs/<int:config_id>/set-default', methods=['POST'])
@admin_required
def set_system_default_ai_config(config_id):
    """设置系统默认 AI 配置（在系统配置池中选一个为默认）"""
    try:
        config = AIProviderConfig.query.get(config_id)
        if not config or config.user_id is not None:
            return jsonify({
                'success': False,
                'message': '系统 AI 配置不存在'
            }), 404

        success = AIProviderConfig.set_user_default(None, config_id)
        if not success:
            return jsonify({
                'success': False,
                'message': '设置默认配置失败'
            }), 400

        return jsonify({
            'success': True,
            'message': '已设为系统默认 AI 配置'
        })
    except Exception as e:
        db.session.rollback()
        return jsonify({
            'success': False,
            'message': f'设置失败: {str(e)}'
        }), 500


# ============================================================
# 管理员接口
# ============================================================

@ai_config_bp.route('/admin/system', methods=['GET'])
@admin_required
def get_system_config():
    """获取系统 AI 配置"""
    try:
        # 获取系统默认配置
        system_config = AIProviderConfig.get_system_default()
        
        # 获取系统设置
        settings = {
            'enabled_providers': SystemAIConfig.get_enabled_providers(),
            'allow_user_custom_ai': SystemAIConfig.allow_user_custom_ai(),
            'force_system_ai': SystemAIConfig.force_system_ai(),
        }
        
        return jsonify({
            'success': True,
            'system_config': system_config.to_dict(include_key_preview=True) if system_config else None,
            'settings': settings,
            'all_providers': SystemAIConfig.get_all_provider_info()
        })
        
    except Exception as e:
        return jsonify({
            'success': False,
            'message': str(e)
        }), 500


@ai_config_bp.route('/admin/system', methods=['POST'])
@admin_required
def update_system_config():
    """更新系统 AI 配置"""
    try:
        data = request.get_json()
        
        # 更新系统默认 AI 配置
        if 'default_ai' in data:
            ai_data = data['default_ai']
            provider_type = ai_data.get('provider_type')
            api_key = ai_data.get('api_key')
            
            if provider_type and api_key:
                # 查找或创建系统配置
                system_config = AIProviderConfig.query.filter_by(
                    user_id=None,
                    is_default=True
                ).first()
                
                if system_config:
                    # 更新现有配置
                    system_config.provider_type = provider_type
                    system_config.set_api_key(api_key)
                    system_config.model = ai_data.get('model')
                    system_config.base_url = ai_data.get('base_url') or AIProviderType.get_default_base_url(provider_type)
                    system_config.name = ai_data.get('name', '系统默认')
                else:
                    # 创建新配置
                    system_config = AIProviderConfig.create_config(
                        user_id=None,
                        provider_type=provider_type,
                        api_key=api_key,
                        model=ai_data.get('model'),
                        base_url=ai_data.get('base_url'),
                        name=ai_data.get('name', '系统默认'),
                        is_default=True
                    )
        
        # 更新启用的提供商
        if 'enabled_providers' in data:
            SystemAIConfig.set_enabled_providers(data['enabled_providers'])
        
        # 更新用户权限设置
        if 'allow_user_custom_ai' in data:
            SystemAIConfig.set_allow_user_custom_ai(data['allow_user_custom_ai'])
        
        if 'force_system_ai' in data:
            SystemAIConfig.set_force_system_ai(data['force_system_ai'])
        
        db.session.commit()
        
        return jsonify({
            'success': True,
            'message': '系统配置更新成功'
        })
        
    except Exception as e:
        db.session.rollback()
        return jsonify({
            'success': False,
            'message': f'更新失败: {str(e)}'
        }), 500


# ============================================================
# 普通用户视角的系统 AI 池接口
# ============================================================


@ai_config_bp.route('/system/list', methods=['GET'])
@login_required
def list_system_ai_for_user():
    """获取系统级 AI 配置池（普通用户视角）

    不返回完整 API Key，只返回必要的展示字段和测试状态。
    """
    try:
        user_id = g.user.id

        # 当前对该用户生效的配置，用于高亮 is_default
        effective_config = AIProviderConfig.get_effective_config(user_id)

        # 用户首选的系统 AI 配置
        preferred_system_id = getattr(g.user, "preferred_system_ai_config_id", None)

        system_configs = AIProviderConfig.query.filter_by(
            user_id=None,
            is_active=True
        ).order_by(
            AIProviderConfig.is_default.desc(),
            AIProviderConfig.created_at.asc()
        ).all()

        configs = []
        for config in system_configs:
            configs.append({
                'id': config.id,
                'name': config.name or config.provider_type,
                'provider_type': config.provider_type,
                'provider_name': AIProviderType.get_display_name(config.provider_type),
                'model': config.model,
                'base_url': config.base_url,
                'is_active': config.is_active,
                # 当前对于该用户是否生效
                'is_default_for_user': bool(effective_config and effective_config.id == config.id),
                # 管理员设置的系统全局默认
                'is_system_global_default': bool(config.is_default),
                # 当前用户是否显式选择了该系统配置
                'is_user_chosen_system': bool(preferred_system_id and preferred_system_id == config.id),
                'test_status': config.test_status,
                'test_message': config.test_message,
            })

        return jsonify({
            'success': True,
            'configs': configs
        })
    except Exception as e:
        return jsonify({
            'success': False,
            'message': str(e)
        }), 500


@ai_config_bp.route('/system/choice', methods=['POST'])
@login_required
def set_user_system_ai_choice():
    """设置当前用户在系统 AI 池中的首选配置

    body: { "config_id": int | null }
    - 如果为 null 或未传，表示清除用户的系统 AI 选择（回到系统默认逻辑）
    - 否则必须是 user_id 为 None 且 is_active=True 的配置
    """
    try:
        user = g.user
        data = request.get_json() or {}
        config_id = data.get('config_id')

        # 清除用户选择
        if not config_id:
            user.preferred_system_ai_config_id = None
            db.session.commit()
            return jsonify({
                'success': True,
                'message': '已清除系统 AI 选择'
            })

        # 校验该配置属于系统级配置池且可用
        config = AIProviderConfig.query.get(config_id)
        if not config or config.user_id is not None or not config.is_active:
            return jsonify({
                'success': False,
                'message': '无效的系统 AI 配置'
            }), 400

        user.preferred_system_ai_config_id = config.id
        db.session.commit()

        return jsonify({
            'success': True,
            'message': '系统 AI 选择已更新'
        })
    except Exception as e:
        db.session.rollback()
        return jsonify({
            'success': False,
            'message': f'更新失败: {str(e)}'
        }), 500


@ai_config_bp.route('/admin/system/test', methods=['POST'])
@admin_required
def test_system_connection():
    """测试系统 AI 连接"""
    try:
        data = request.get_json()
        
        provider_type = data.get('provider_type')
        api_key = data.get('api_key')
        base_url = data.get('base_url')
        model = data.get('model')
        
        if not provider_type or not api_key:
            return jsonify({
                'success': False,
                'message': '请提供提供商类型和 API Key'
            }), 400
        
        # 创建临时提供商实例进行测试
        provider = AIProviderFactory.create(
            provider_type=provider_type,
            api_key=api_key,
            base_url=base_url,
            model=model
        )
        
        # 测试连接
        result = provider.test_connection()
        
        return jsonify({
            'success': True,
            'test_result': result
        })
        
    except Exception as e:
        return jsonify({
            'success': False,
            'message': f'测试失败: {str(e)}'
        }), 500


# ============================================================
# Augment Token 接口（简化版，供 AI 配置页面使用）
# ============================================================

@ai_config_bp.route('/augment/token', methods=['GET'])
@login_required
def get_augment_token():
    """获取用户的 Augment Token 状态和模型配置"""
    try:
        user_id = g.user.id
        
        # 获取Augment配置（包含模型信息和Token）
        augment_config = AIProviderConfig.query.filter_by(
            user_id=user_id,
            provider_type='augment',
            is_active=True
        ).first()
        
        model = augment_config.model if augment_config and augment_config.model else 'augment-cli'
        
        if augment_config:
            api_key = augment_config.get_api_key()
            if api_key and api_key.strip():
                # 生成预览（只显示前后几个字符）
                token_str = api_key.strip()
                if len(token_str) > 20:
                    preview = f"{token_str[:10]}...{token_str[-10:]}"
                else:
                    preview = "已配置"
                
                return jsonify({
                    'success': True,
                    'has_token': True,
                    'preview': preview,
                    'model': model,
                    'updated_at': augment_config.updated_at.isoformat() if augment_config.updated_at else None
                })
        
        return jsonify({
            'success': True,
            'has_token': False,
            'model': model
        })
            
    except Exception as e:
        return jsonify({
            'success': False,
            'message': str(e)
        }), 500


@ai_config_bp.route('/augment/token', methods=['POST'])
@login_required
def save_augment_token():
    """保存用户的 Augment Token 并设置为默认 AI"""
    import json
    
    try:
        user_id = g.user.id
        data = request.get_json()
        
        if not data or 'token' not in data:
            return jsonify({'success': False, 'message': 'Token 不能为空'}), 400
        
        token_str = data['token'].strip()
        
        if not token_str:
            return jsonify({'success': False, 'message': 'Token 不能为空'}), 400
        
        # 验证 JSON 格式
        try:
            json.loads(token_str)
        except json.JSONDecodeError:
            return jsonify({'success': False, 'message': 'Token 格式错误，请确保是有效的 JSON'}), 400
        
        # 1. 先将用户的所有 AI 配置设为非默认状态
        AIProviderConfig.query.filter(
            AIProviderConfig.user_id == user_id
        ).update({'is_default': False})
        
        # 2. 创建/更新 AIProviderConfig 记录，将 Augment 设置为用户的默认 AI
        augment_config = AIProviderConfig.query.filter_by(
            user_id=user_id,
            provider_type='augment'
        ).first()
        
        # 获取模型参数（如果提供）
        model = data.get('model', 'augment-cli')  # 默认模型ID
        
        if augment_config:
            # 更新现有配置
            augment_config.set_api_key(token_str)  # 保存 Token 到 api_key_encrypted
            augment_config.is_active = True
            augment_config.is_default = True  # 设为默认
            augment_config.model = model  # 更新模型
            augment_config.updated_at = datetime.utcnow()
        else:
            # 创建新配置
            augment_config = AIProviderConfig(
                user_id=user_id,
                provider_type='augment',
                model=model,  # 使用传入的模型ID
                base_url='',
                is_active=True,
                is_default=True,  # 设为默认
                name='Augment CLI',
                created_at=datetime.utcnow(),
                updated_at=datetime.utcnow()
            )
            augment_config.set_api_key(token_str)  # 保存 Token 到 api_key_encrypted
            db.session.add(augment_config)
        
        # 验证Token并更新测试状态（如果Token有效）
        try:
            from app.services.ai.helpers.augment_helper import validate_augment_token
            token_result = validate_augment_token(token_str)
            if token_result['valid']:
                augment_config.update_test_status('success', 'Token验证成功')
            else:
                augment_config.update_test_status('failed', token_result['message'])
        except Exception as e:
            # 如果验证失败，不阻止保存，但记录警告
            augment_config.update_test_status('pending', f'Token保存成功，但验证时出错: {str(e)}')
        
        db.session.commit()
        
        return jsonify({
            'success': True,
            'message': 'Token 保存成功，已设置 Augment 为默认 AI'
        })
        
    except Exception as e:
        db.session.rollback()
        return jsonify({
            'success': False,
            'message': f'保存失败: {str(e)}'
        }), 500


@ai_config_bp.route('/augment/token/validate', methods=['POST'])
@login_required
def validate_augment_token_api():
    """验证 Augment Token 是否有效"""
    from app.services.ai.helpers.augment_helper import validate_augment_token
    
    try:
        data = request.get_json()
        
        if not data or 'token' not in data:
            return jsonify({'success': False, 'message': 'Token 不能为空'}), 400
        
        token_str = data['token'].strip()
        
        if not token_str:
            return jsonify({'success': False, 'message': 'Token 不能为空'}), 400
        
        # 调用验证函数
        result = validate_augment_token(token_str)
        
        # 更新对应的Augment配置的测试状态
        user_id = g.user.id
        augment_config = AIProviderConfig.query.filter_by(
            user_id=user_id,
            provider_type='augment'
        ).first()
        
        if augment_config:
            if result['valid']:
                augment_config.update_test_status('success', result['message'])
            else:
                augment_config.update_test_status('failed', result['message'])
            db.session.commit()  # 确保测试状态被保存到数据库
        
        return jsonify({
            'success': result['valid'],
            'message': result['message'],
            'token_info': result.get('token_info')
        })
        
    except Exception as e:
        return jsonify({
            'success': False,
            'message': f'验证失败: {str(e)}'
        }), 500


@ai_config_bp.route('/augment/token', methods=['DELETE'])
@login_required
def delete_augment_token():
    """删除用户的 Augment Token"""
    try:
        user_id = g.user.id
        
        # 从 AIProviderConfig 删除
        config = AIProviderConfig.query.filter_by(
            user_id=user_id,
            provider_type='augment',
            is_active=True
        ).first()
        
        if config:
            config.set_api_key('')
            config.is_active = False
            db.session.commit()
            return jsonify({
                'success': True,
                'message': 'Token 已删除'
            })
        else:
            return jsonify({
                'success': False,
                'message': 'Token 不存在'
            }), 404
            
    except Exception as e:
        db.session.rollback()
        return jsonify({
            'success': False,
            'message': f'删除失败: {str(e)}'
        }), 500


# ============================================================