#!/usr/bin/env python3
"""
随机参数配置管理API
提供随机参数配置的读取和保存功能
"""

import os
import json
from flask import Blueprint, request, jsonify

# 创建蓝图
random_options_bp = Blueprint('random_options', __name__)

# 获取项目根目录
PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

# 配置文件路径
CONFIG_FILE_PATH = os.path.join(PROJECT_ROOT, 'model_prompt', 'advanced_random_options.json')

# 勾选状态配置文件路径
SELECTION_FILE_PATH = os.path.join(PROJECT_ROOT, 'model_prompt', 'advanced_random_selection.json')


@random_options_bp.route('/api/random-options', methods=['GET'])
def get_random_options():
    """
    获取随机参数配置
    
    返回参数:
    - success: bool, 是否成功
    - data: dict, 随机参数配置数据
    - error: str, 错误信息（如果失败）
    """
    try:
        if not os.path.exists(CONFIG_FILE_PATH):
            return jsonify({
                'success': False,
                'error': '配置文件不存在'
            }), 404
        
        with open(CONFIG_FILE_PATH, 'r', encoding='utf-8') as f:
            data = json.load(f)
        
        return jsonify({
            'success': True,
            'data': data
        })
    
    except json.JSONDecodeError as e:
        return jsonify({
            'success': False,
            'error': f'配置文件格式错误: {str(e)}'
        }), 500
    
    except Exception as e:
        return jsonify({
            'success': False,
            'error': f'读取配置失败: {str(e)}'
        }), 500


@random_options_bp.route('/api/random-options', methods=['POST'])
def save_random_options():
    """
    保存随机参数配置
    
    请求参数:
    - data: dict, 随机参数配置数据
    
    返回参数:
    - success: bool, 是否成功
    - message: str, 成功消息
    - error: str, 错误信息（如果失败）
    """
    try:
        req_data = request.get_json()
        
        if not req_data or 'data' not in req_data:
            return jsonify({
                'success': False,
                'error': '请求参数无效，需要提供data字段'
            }), 400
        
        config_data = req_data['data']
        
        # 验证数据格式
        if not isinstance(config_data, dict):
            return jsonify({
                'success': False,
                'error': '配置数据必须是对象类型'
            }), 400
        
        # 验证每个类别的数据格式
        for category, items in config_data.items():
            if not isinstance(category, str) or not category.strip():
                return jsonify({
                    'success': False,
                    'error': '类别名称必须是非空字符串'
                }), 400
            
            # 允许字符串（如"风格"字段）或数组类型
            if not isinstance(items, (list, str)):
                return jsonify({
                    'success': False,
                    'error': f'类别 "{category}" 的值必须是数组或字符串'
                }), 400
            
            # 如果是数组，验证每个元素
            if isinstance(items, list):
                for item in items:
                    if not isinstance(item, str):
                        return jsonify({
                            'success': False,
                            'error': f'类别 "{category}" 中的词条必须是字符串'
                        }), 400
        
        # 确保目录存在
        os.makedirs(os.path.dirname(CONFIG_FILE_PATH), exist_ok=True)
        
        # 保存配置文件
        with open(CONFIG_FILE_PATH, 'w', encoding='utf-8') as f:
            json.dump(config_data, f, ensure_ascii=False, indent=4)
        
        return jsonify({
            'success': True,
            'message': '配置保存成功'
        })
    
    except Exception as e:
        return jsonify({
            'success': False,
            'error': f'保存配置失败: {str(e)}'
        }), 500


@random_options_bp.route('/api/random-options/category', methods=['POST'])
def add_category():
    """
    添加新类别
    
    请求参数:
    - name: str, 类别名称
    - items: list, 词条列表（可选，默认为空数组）
    
    返回参数:
    - success: bool, 是否成功
    - message: str, 成功消息
    - data: dict, 更新后的配置数据
    - error: str, 错误信息（如果失败）
    """
    try:
        req_data = request.get_json()
        
        if not req_data or 'name' not in req_data:
            return jsonify({
                'success': False,
                'error': '请求参数无效，需要提供name字段'
            }), 400
        
        category_name = req_data['name'].strip()
        items = req_data.get('items', [])
        
        if not category_name:
            return jsonify({
                'success': False,
                'error': '类别名称不能为空'
            }), 400
        
        # 读取现有配置
        if os.path.exists(CONFIG_FILE_PATH):
            with open(CONFIG_FILE_PATH, 'r', encoding='utf-8') as f:
                config_data = json.load(f)
        else:
            config_data = {}
        
        # 检查类别是否已存在
        if category_name in config_data:
            return jsonify({
                'success': False,
                'error': f'类别 "{category_name}" 已存在'
            }), 400
        
        # 添加新类别
        config_data[category_name] = items if isinstance(items, list) else []
        
        # 保存配置
        with open(CONFIG_FILE_PATH, 'w', encoding='utf-8') as f:
            json.dump(config_data, f, ensure_ascii=False, indent=4)
        
        return jsonify({
            'success': True,
            'message': f'类别 "{category_name}" 添加成功',
            'data': config_data
        })
    
    except Exception as e:
        return jsonify({
            'success': False,
            'error': f'添加类别失败: {str(e)}'
        }), 500


@random_options_bp.route('/api/random-options/category/<category_name>', methods=['DELETE'])
def delete_category(category_name):
    """
    删除类别
    
    路径参数:
    - category_name: str, 类别名称
    
    返回参数:
    - success: bool, 是否成功
    - message: str, 成功消息
    - data: dict, 更新后的配置数据
    - error: str, 错误信息（如果失败）
    """
    try:
        if not os.path.exists(CONFIG_FILE_PATH):
            return jsonify({
                'success': False,
                'error': '配置文件不存在'
            }), 404
        
        with open(CONFIG_FILE_PATH, 'r', encoding='utf-8') as f:
            config_data = json.load(f)
        
        if category_name not in config_data:
            return jsonify({
                'success': False,
                'error': f'类别 "{category_name}" 不存在'
            }), 404
        
        # 删除类别
        del config_data[category_name]
        
        # 保存配置
        with open(CONFIG_FILE_PATH, 'w', encoding='utf-8') as f:
            json.dump(config_data, f, ensure_ascii=False, indent=4)
        
        return jsonify({
            'success': True,
            'message': f'类别 "{category_name}" 删除成功',
            'data': config_data
        })
    
    except Exception as e:
        return jsonify({
            'success': False,
            'error': f'删除类别失败: {str(e)}'
        }), 500


@random_options_bp.route('/api/random-options/selection', methods=['GET'])
def get_selection():
    """
    获取勾选状态配置
    
    返回参数:
    - success: bool, 是否成功
    - data: dict, 勾选状态数据
        - 格式: { "类别名": ["已勾选的词条1", "已勾选的词条2", ...] }
        - 如果类别的值为 true，表示该类别整体被勾选（用于字符串类型的类别）
    - error: str, 错误信息（如果失败）
    """
    try:
        if not os.path.exists(SELECTION_FILE_PATH):
            # 如果勾选状态文件不存在，默认全选
            # 读取配置文件，生成默认的全选状态
            if os.path.exists(CONFIG_FILE_PATH):
                with open(CONFIG_FILE_PATH, 'r', encoding='utf-8') as f:
                    config_data = json.load(f)
                
                # 生成默认全选状态
                selection_data = {}
                for category, items in config_data.items():
                    if isinstance(items, list):
                        selection_data[category] = items.copy()
                    else:
                        selection_data[category] = True
                
                return jsonify({
                    'success': True,
                    'data': selection_data
                })
            else:
                return jsonify({
                    'success': True,
                    'data': {}
                })
        
        with open(SELECTION_FILE_PATH, 'r', encoding='utf-8') as f:
            selection_data = json.load(f)
        
        return jsonify({
            'success': True,
            'data': selection_data
        })
    
    except json.JSONDecodeError as e:
        return jsonify({
            'success': False,
            'error': f'勾选状态文件格式错误: {str(e)}'
        }), 500
    
    except Exception as e:
        return jsonify({
            'success': False,
            'error': f'读取勾选状态失败: {str(e)}'
        }), 500


@random_options_bp.route('/api/random-options/selection', methods=['POST'])
def save_selection():
    """
    保存勾选状态配置
    
    请求参数:
    - data: dict, 勾选状态数据
        - 格式: { "类别名": ["已勾选的词条1", "已勾选的词条2", ...] }
        - 如果类别的值为 true，表示该类别整体被勾选（用于字符串类型的类别）
    
    返回参数:
    - success: bool, 是否成功
    - message: str, 成功消息
    - error: str, 错误信息（如果失败）
    """
    try:
        req_data = request.get_json()
        
        if not req_data or 'data' not in req_data:
            return jsonify({
                'success': False,
                'error': '请求参数无效，需要提供data字段'
            }), 400
        
        selection_data = req_data['data']
        
        # 验证数据格式
        if not isinstance(selection_data, dict):
            return jsonify({
                'success': False,
                'error': '勾选状态数据必须是对象类型'
            }), 400
        
        # 确保目录存在
        os.makedirs(os.path.dirname(SELECTION_FILE_PATH), exist_ok=True)
        
        # 保存勾选状态文件
        with open(SELECTION_FILE_PATH, 'w', encoding='utf-8') as f:
            json.dump(selection_data, f, ensure_ascii=False, indent=4)
        
        return jsonify({
            'success': True,
            'message': '勾选状态保存成功'
        })
    
    except Exception as e:
        return jsonify({
            'success': False,
            'error': f'保存勾选状态失败: {str(e)}'
        }), 500