#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
Content Transformer
内容转换器 - 重构版本，使用AI将整合的文档内容转换为标准化格式
"""

import logging
from typing import Dict, Any, Optional, List
from dataclasses import dataclass
from datetime import datetime

from .content_integrator import IntegratedContent
from ..config import AlgorithmConfig
from ..core import AIService, PromptManager, JSONProcessor
from ..exceptions import ContentGenerationError, DocumentProcessingError

logger = logging.getLogger(__name__)


@dataclass
class TransformedContent:
    """转换后的内容"""
    original_content: IntegratedContent
    transformed_text: str
    format_type: str
    transformation_metadata: Dict[str, Any]
    transformed_at: datetime
    structured_data: Optional[Dict[str, Any]] = None
    quality_score: Optional[float] = None
    
    def __post_init__(self):
        """初始化后处理"""
        if not self.transformed_at:
            self.transformed_at = datetime.now()
    
    def to_dict(self) -> Dict[str, Any]:
        """转换为字典格式"""
        return {
            'transformed_text': self.transformed_text,
            'format_type': self.format_type,
            'transformation_metadata': self.transformation_metadata,
            'transformed_at': self.transformed_at.isoformat(),
            'structured_data': self.structured_data,
            'quality_score': self.quality_score,
            'original_summary': self.original_content.content_summary,
            'original_document_count': self.original_content.document_count
        }
    
    def get_summary(self) -> Dict[str, Any]:
        """获取转换摘要"""
        return {
            'format_type': self.format_type,
            'transformed_length': len(self.transformed_text),
            'quality_score': self.quality_score,
            'source_documents': self.original_content.document_count,
            'transformation_method': self.transformation_metadata.get('method'),
            'transformed_at': self.transformed_at.isoformat()
        }


class ContentTransformer:
    """
    内容转换器 - 重构版本
    使用AI模型将整合的文档内容转换为指定的标准化格式
    """
    
    SUPPORTED_FORMATS = {
        'attraction_standard': '景区标准信息格式',
        'product_sales': '产品销售介绍格式',
        'travel_guide': '旅游攻略格式',
        'blog_post': '博客文章格式',
        'summary': '内容摘要格式',
        'structured_data': '结构化数据格式',
        'marketing_copy': '营销文案格式',
        'faq': '常见问题格式'
    }
    
    def __init__(self, config: AlgorithmConfig):
        """
        初始化内容转换器
        
        Args:
            config: 算法配置
        """
        self.config = config
        self.ai_service = AIService(config.ai_model)
        self.prompt_manager = PromptManager(config.prompts, config.resources)
        self.json_processor = JSONProcessor(
            enable_repair=config.content_generation.enable_json_repair,
            max_repair_attempts=config.content_generation.json_repair_attempts
        )
        
        # 获取任务特定的模型配置
        self.task_model_config = config.ai_model.get_task_config("content_transformation")
        
        # 格式转换方法映射
        self.format_methods = {
            'attraction_standard': self._transform_to_attraction_standard,
            'product_sales': self._transform_to_product_sales,
            'travel_guide': self._transform_to_travel_guide,
            'blog_post': self._transform_to_blog_post,
            'summary': self._transform_to_summary,
            'structured_data': self._transform_to_structured_data,
            'marketing_copy': self._transform_to_marketing_copy,
            'faq': self._transform_to_faq
        }
        
        logger.info(f"内容转换器初始化完成，支持格式: {list(self.SUPPORTED_FORMATS.keys())}")
    
    async def transform_content(
        self,
        integrated_content: IntegratedContent,
        format_type: str = 'summary',
        custom_prompt: Optional[str] = None,
        additional_requirements: Optional[str] = None
    ) -> TransformedContent:
        """
        转换内容
        
        Args:
            integrated_content: 整合后的内容
            format_type: 目标格式类型
            custom_prompt: 自定义提示词
            additional_requirements: 额外要求
            
        Returns:
            TransformedContent: 转换后的内容
            
        Raises:
            DocumentProcessingError: 转换失败时抛出
        """
        if format_type not in self.SUPPORTED_FORMATS:
            raise DocumentProcessingError(f"不支持的格式类型: {format_type}")
        
        if not integrated_content.combined_content.strip():
            raise DocumentProcessingError("没有可转换的内容")
        
        try:
            logger.info(f"开始转换内容为 {format_type} 格式")
            
            # 获取转换方法
            transform_method = self.format_methods[format_type]
            
            # 执行转换
            transformed_text, structured_data, metadata = await transform_method(
                integrated_content,
                custom_prompt,
                additional_requirements
            )
            
            # 计算质量评分
            quality_score = self._calculate_quality_score(
                integrated_content,
                transformed_text,
                format_type
            )
            
            # 收集转换元数据
            transformation_metadata = {
                'method': transform_method.__name__,
                'format_type': format_type,
                'custom_prompt_used': bool(custom_prompt),
                'additional_requirements': additional_requirements,
                'source_document_count': integrated_content.document_count,
                'source_content_length': len(integrated_content.combined_content),
                'target_content_length': len(transformed_text),
                'model_config': self.task_model_config,
                'transformation_timestamp': datetime.now().isoformat(),
                **metadata
            }
            
            transformed_content = TransformedContent(
                original_content=integrated_content,
                transformed_text=transformed_text,
                format_type=format_type,
                transformation_metadata=transformation_metadata,
                transformed_at=datetime.now(),
                structured_data=structured_data,
                quality_score=quality_score
            )
            
            logger.info(f"内容转换完成，输出长度: {len(transformed_text)}")
            return transformed_content
            
        except Exception as e:
            error_msg = f"内容转换失败 ({format_type}): {str(e)}"
            logger.error(error_msg, exc_info=True)
            raise DocumentProcessingError(error_msg)
    
    async def _transform_to_attraction_standard(
        self,
        content: IntegratedContent,
        custom_prompt: Optional[str],
        additional_requirements: Optional[str]
    ) -> tuple[str, Optional[Dict[str, Any]], Dict[str, Any]]:
        """转换为景区标准信息格式"""
        
        system_prompt = custom_prompt or self._get_system_prompt("attraction_standard")
        user_prompt = self._build_user_prompt(
            content,
            "景区标准信息",
            additional_requirements,
            """
            请按照以下结构整理景区信息：
            1. 景区基本信息（名称、位置、类型、等级）
            2. 门票信息（价格、优惠政策、购票方式）
            3. 开放时间（营业时间、季节性变化）
            4. 交通指南（公共交通、自驾路线、停车信息）
            5. 景区特色（主要景点、特色活动、文化背景）
            6. 服务设施（餐饮、住宿、购物、卫生间等）
            7. 游览建议（推荐路线、游览时长、最佳时间）
            8. 注意事项（安全提醒、禁止事项、特殊要求）
            """
        )
        
        result, tokens_input, tokens_output, elapsed_time = await self.ai_service.generate_text(
            system_prompt=system_prompt,
            user_prompt=user_prompt,
            stage="景区标准信息转换",
            **self.task_model_config
        )
        
        # 尝试提取结构化数据
        structured_data = self._extract_structured_data(result, "attraction")
        
        metadata = {
            'tokens_input': tokens_input,
            'tokens_output': tokens_output,
            'elapsed_time': elapsed_time,
            'extraction_method': 'ai_attraction_standard'
        }
        
        return result.strip(), structured_data, metadata
    
    async def _transform_to_product_sales(
        self,
        content: IntegratedContent,
        custom_prompt: Optional[str],
        additional_requirements: Optional[str]
    ) -> tuple[str, Optional[Dict[str, Any]], Dict[str, Any]]:
        """转换为产品销售介绍格式"""
        
        system_prompt = custom_prompt or self._get_system_prompt("product_sales")
        user_prompt = self._build_user_prompt(
            content,
            "产品销售介绍",
            additional_requirements,
            """
            请按照销售文案的要求整理产品信息：
            1. 产品亮点（核心卖点、独特优势）
            2. 产品详情（套餐内容、服务项目、规格说明）
            3. 价格体系（原价、优惠价、性价比分析）
            4. 适用人群（目标客户、使用场景）
            5. 购买指南（预订方式、使用方法、有效期）
            6. 客户保障（退改政策、服务承诺、联系方式）
            7. 用户评价（客户反馈、推荐理由）
            """
        )
        
        result, tokens_input, tokens_output, elapsed_time = await self.ai_service.generate_text(
            system_prompt=system_prompt,
            user_prompt=user_prompt,
            stage="产品销售介绍转换",
            **self.task_model_config
        )
        
        structured_data = self._extract_structured_data(result, "product")
        
        metadata = {
            'tokens_input': tokens_input,
            'tokens_output': tokens_output,
            'elapsed_time': elapsed_time,
            'extraction_method': 'ai_product_sales'
        }
        
        return result.strip(), structured_data, metadata
    
    async def _transform_to_travel_guide(
        self,
        content: IntegratedContent,
        custom_prompt: Optional[str],
        additional_requirements: Optional[str]
    ) -> tuple[str, Optional[Dict[str, Any]], Dict[str, Any]]:
        """转换为旅游攻略格式"""
        
        system_prompt = custom_prompt or self._get_system_prompt("travel_guide")
        user_prompt = self._build_user_prompt(
            content,
            "旅游攻略",
            additional_requirements,
            """
            请整理成实用的旅游攻略：
            1. 目的地概览（地理位置、气候特点、最佳旅游时间）
            2. 行程规划（推荐天数、必游景点、路线安排）
            3. 交通攻略（到达方式、当地交通、费用预算）
            4. 住宿推荐（不同档次选择、位置建议、预订提醒）
            5. 美食指南（特色菜品、推荐餐厅、小吃街区）
            6. 购物指南（特产推荐、购物地点、注意事项）
            7. 实用贴士（天气准备、必备物品、省钱技巧）
            8. 安全提醒（注意事项、紧急联系方式）
            """
        )
        
        result, tokens_input, tokens_output, elapsed_time = await self.ai_service.generate_text(
            system_prompt=system_prompt,
            user_prompt=user_prompt,
            stage="旅游攻略转换",
            **self.task_model_config
        )
        
        structured_data = self._extract_structured_data(result, "guide")
        
        metadata = {
            'tokens_input': tokens_input,
            'tokens_output': tokens_output,
            'elapsed_time': elapsed_time,
            'extraction_method': 'ai_travel_guide'
        }
        
        return result.strip(), structured_data, metadata
    
    async def _transform_to_blog_post(
        self,
        content: IntegratedContent,
        custom_prompt: Optional[str],
        additional_requirements: Optional[str]
    ) -> tuple[str, Optional[Dict[str, Any]], Dict[str, Any]]:
        """转换为博客文章格式"""
        
        system_prompt = custom_prompt or self._get_system_prompt("blog_post")
        user_prompt = self._build_user_prompt(
            content,
            "博客文章",
            additional_requirements,
            """
            请整理成吸引人的博客文章：
            1. 引人入胜的标题
            2. 开头引言（吸引读者兴趣）
            3. 主体内容（详细介绍、个人体验、实用信息）
            4. 精彩亮点（重点推荐、独特发现）
            5. 实用建议（贴心提醒、经验分享）
            6. 总结感悟（个人感受、推荐理由）
            7. 互动结尾（鼓励评论、分享邀请）
            
            要求：语言生动有趣，有个人色彩，适合社交媒体分享。
            """
        )
        
        result, tokens_input, tokens_output, elapsed_time = await self.ai_service.generate_text(
            system_prompt=system_prompt,
            user_prompt=user_prompt,
            stage="博客文章转换",
            **self.task_model_config
        )
        
        structured_data = self._extract_structured_data(result, "blog")
        
        metadata = {
            'tokens_input': tokens_input,
            'tokens_output': tokens_output,
            'elapsed_time': elapsed_time,
            'extraction_method': 'ai_blog_post'
        }
        
        return result.strip(), structured_data, metadata
    
    async def _transform_to_summary(
        self,
        content: IntegratedContent,
        custom_prompt: Optional[str],
        additional_requirements: Optional[str]
    ) -> tuple[str, Optional[Dict[str, Any]], Dict[str, Any]]:
        """转换为内容摘要格式"""
        
        system_prompt = custom_prompt or self._get_system_prompt("summary")
        user_prompt = self._build_user_prompt(
            content,
            "内容摘要",
            additional_requirements,
            """
            请提供简洁的内容摘要：
            1. 核心信息总结（主要内容、关键信息）
            2. 重要数据提取（价格、时间、数量等）
            3. 关键特色亮点（独特卖点、优势特征）
            4. 实用信息汇总（联系方式、地址、网址等）
            
            要求：简洁明了，突出重点，便于快速了解。
            """
        )
        
        result, tokens_input, tokens_output, elapsed_time = await self.ai_service.generate_text(
            system_prompt=system_prompt,
            user_prompt=user_prompt,
            stage="内容摘要转换",
            **self.task_model_config
        )
        
        structured_data = self._extract_structured_data(result, "summary")
        
        metadata = {
            'tokens_input': tokens_input,
            'tokens_output': tokens_output,
            'elapsed_time': elapsed_time,
            'extraction_method': 'ai_summary'
        }
        
        return result.strip(), structured_data, metadata
    
    async def _transform_to_structured_data(
        self,
        content: IntegratedContent,
        custom_prompt: Optional[str],
        additional_requirements: Optional[str]
    ) -> tuple[str, Optional[Dict[str, Any]], Dict[str, Any]]:
        """转换为结构化数据格式"""
        
        system_prompt = custom_prompt or """你是一个数据结构化专家，负责将非结构化的文档内容转换为标准的JSON格式数据。

请按照以下JSON结构提取和整理信息：
{
    "basic_info": {
        "name": "名称",
        "type": "类型",
        "location": "位置",
        "description": "简介"
    },
    "pricing": {
        "ticket_price": "门票价格",
        "package_price": "套餐价格",
        "discount_info": "优惠信息"
    },
    "schedule": {
        "opening_hours": "开放时间",
        "best_visit_time": "最佳游览时间",
        "duration": "建议游览时长"
    },
    "transportation": {
        "public_transport": "公共交通",
        "self_driving": "自驾信息",
        "parking": "停车信息"
    },
    "services": {
        "facilities": ["设施列表"],
        "dining": ["餐饮选择"],
        "accommodation": ["住宿选择"]
    },
    "highlights": ["亮点特色"],
    "tips": ["游览贴士"],
    "contact": {
        "phone": "联系电话",
        "website": "官方网站",
        "address": "详细地址"
    }
}

请严格按照JSON格式输出，没有信息的字段可以设为null或空数组。"""
        
        user_prompt = f"""请将以下文档内容转换为结构化的JSON数据：

{content.combined_content}

{f'额外要求：{additional_requirements}' if additional_requirements else ''}

请提取所有可用信息并按照指定的JSON结构格式化输出。"""
        
        result, tokens_input, tokens_output, elapsed_time = await self.ai_service.generate_text(
            system_prompt=system_prompt,
            user_prompt=user_prompt,
            stage="结构化数据转换",
            **self.task_model_config
        )
        
        # 解析JSON结构化数据
        try:
            structured_data = self.json_processor.parse_llm_output(
                raw_output=result,
                expected_fields=["basic_info", "pricing", "schedule", "transportation", "services"],
                required_fields=["basic_info"]
            )
        except Exception as e:
            logger.warning(f"结构化数据解析失败: {e}")
            structured_data = None
        
        metadata = {
            'tokens_input': tokens_input,
            'tokens_output': tokens_output,
            'elapsed_time': elapsed_time,
            'extraction_method': 'ai_structured_data',
            'json_parsing_success': structured_data is not None
        }
        
        return result.strip(), structured_data, metadata
    
    async def _transform_to_marketing_copy(
        self,
        content: IntegratedContent,
        custom_prompt: Optional[str],
        additional_requirements: Optional[str]
    ) -> tuple[str, Optional[Dict[str, Any]], Dict[str, Any]]:
        """转换为营销文案格式"""
        
        system_prompt = custom_prompt or self._get_system_prompt("marketing_copy")
        user_prompt = self._build_user_prompt(
            content,
            "营销文案",
            additional_requirements,
            """
            请创作有吸引力的营销文案：
            1. 吸引眼球的标题（突出卖点、制造悬念）
            2. 开头钩子（抓住痛点、激发兴趣）
            3. 价值主张（核心利益、独特优势）
            4. 社会证明（客户好评、权威认证）
            5. 紧迫感营造（限时优惠、数量有限）
            6. 行动召唤（明确指引、简化流程）
            7. 风险消除（保障承诺、退款政策）
            
            要求：语言有感染力，突出情感共鸣，促进转化行动。
            """
        )
        
        result, tokens_input, tokens_output, elapsed_time = await self.ai_service.generate_text(
            system_prompt=system_prompt,
            user_prompt=user_prompt,
            stage="营销文案转换",
            **self.task_model_config
        )
        
        structured_data = self._extract_structured_data(result, "marketing")
        
        metadata = {
            'tokens_input': tokens_input,
            'tokens_output': tokens_output,
            'elapsed_time': elapsed_time,
            'extraction_method': 'ai_marketing_copy'
        }
        
        return result.strip(), structured_data, metadata
    
    async def _transform_to_faq(
        self,
        content: IntegratedContent,
        custom_prompt: Optional[str],
        additional_requirements: Optional[str]
    ) -> tuple[str, Optional[Dict[str, Any]], Dict[str, Any]]:
        """转换为常见问题格式"""
        
        system_prompt = custom_prompt or self._get_system_prompt("faq")
        user_prompt = self._build_user_prompt(
            content,
            "常见问题FAQ",
            additional_requirements,
            """
            请整理成常见问题FAQ格式：
            
            基本信息类：
            - 景区/产品介绍相关问题
            - 位置交通相关问题
            
            预订购买类：
            - 门票价格和购买问题
            - 预订流程和注意事项
            
            游览体验类：
            - 开放时间和游览时长
            - 设施服务和特色项目
            
            实用贴士类：
            - 注意事项和安全提醒
            - 最佳游览时间和建议
            
            售后服务类：
            - 退改政策和联系方式
            - 投诉建议和客服支持
            
            每个问题要简洁明了，答案要准确详细。
            """
        )
        
        result, tokens_input, tokens_output, elapsed_time = await self.ai_service.generate_text(
            system_prompt=system_prompt,
            user_prompt=user_prompt,
            stage="FAQ转换",
            **self.task_model_config
        )
        
        structured_data = self._extract_structured_data(result, "faq")
        
        metadata = {
            'tokens_input': tokens_input,
            'tokens_output': tokens_output,
            'elapsed_time': elapsed_time,
            'extraction_method': 'ai_faq'
        }
        
        return result.strip(), structured_data, metadata
    
    def _get_system_prompt(self, format_type: str) -> str:
        """获取系统提示词"""
        try:
            return self.prompt_manager.get_prompt(f"content_transformation_{format_type}", "system")
        except:
            # 使用默认系统提示词
            return f"""你是一个专业的内容编辑和转换专家，擅长将各种文档内容转换为 {self.SUPPORTED_FORMATS.get(format_type, format_type)} 格式。

你的任务是：
1. 理解和分析原始文档内容
2. 提取关键信息和要点
3. 按照目标格式的要求重新组织内容
4. 确保信息准确、完整、易读

要求：
- 保持信息的准确性和完整性
- 语言简洁明了，逻辑清晰
- 适合目标受众阅读
- 突出重点信息和特色内容"""
    
    def _build_user_prompt(
        self,
        content: IntegratedContent,
        format_name: str,
        additional_requirements: Optional[str],
        format_template: str
    ) -> str:
        """构建用户提示词"""
        
        prompt_parts = [
            f"请将以下文档内容转换为{format_name}格式：",
            "",
            f"原始文档摘要：",
            content.content_summary,
            "",
            f"关键主题：{', '.join(content.key_topics)}",
            "",
            f"文档内容：",
            content.combined_content,
            "",
            f"转换要求：",
            format_template
        ]
        
        if additional_requirements:
            prompt_parts.extend([
                "",
                f"额外要求：",
                additional_requirements
            ])
        
        return "\n".join(prompt_parts)
    
    def _extract_structured_data(self, text: str, data_type: str) -> Optional[Dict[str, Any]]:
        """从转换结果中提取结构化数据"""
        try:
            # 简单的关键信息提取
            structured = {}
            
            if data_type == "attraction":
                # 提取景区相关结构化信息
                structured = self._extract_attraction_data(text)
            elif data_type == "product":
                # 提取产品相关结构化信息
                structured = self._extract_product_data(text)
            elif data_type in ["guide", "blog", "summary", "marketing", "faq"]:
                # 提取通用结构化信息
                structured = self._extract_general_data(text)
            
            return structured if structured else None
            
        except Exception as e:
            logger.warning(f"结构化数据提取失败: {e}")
            return None
    
    def _extract_attraction_data(self, text: str) -> Dict[str, Any]:
        """提取景区数据"""
        import re
        
        data = {}
        
        # 提取价格信息
        price_patterns = [
            r'门票[：:]?\s*(\d+(?:\.\d+)?)\s*元',
            r'票价[：:]?\s*(\d+(?:\.\d+)?)\s*元',
            r'价格[：:]?\s*(\d+(?:\.\d+)?)\s*元'
        ]
        
        for pattern in price_patterns:
            match = re.search(pattern, text)
            if match:
                data['ticket_price'] = float(match.group(1))
                break
        
        # 提取时间信息
        time_patterns = [
            r'开放时间[：:]?\s*([^\n]+)',
            r'营业时间[：:]?\s*([^\n]+)',
            r'游览时间[：:]?\s*([^\n]+)'
        ]
        
        for pattern in time_patterns:
            match = re.search(pattern, text)
            if match:
                data['opening_hours'] = match.group(1).strip()
                break
        
        return data
    
    def _extract_product_data(self, text: str) -> Dict[str, Any]:
        """提取产品数据"""
        import re
        
        data = {}
        
        # 提取价格信息
        price_patterns = [
            r'原价[：:]?\s*(\d+(?:\.\d+)?)',
            r'现价[：:]?\s*(\d+(?:\.\d+)?)',
            r'售价[：:]?\s*(\d+(?:\.\d+)?)'
        ]
        
        for pattern in price_patterns:
            match = re.search(pattern, text)
            if match:
                data['price'] = float(match.group(1))
                break
        
        return data
    
    def _extract_general_data(self, text: str) -> Dict[str, Any]:
        """提取通用数据"""
        data = {
            'word_count': len(text.split()),
            'character_count': len(text),
            'paragraph_count': len([p for p in text.split('\n\n') if p.strip()])
        }
        
        return data
    
    def _calculate_quality_score(
        self,
        original_content: IntegratedContent,
        transformed_text: str,
        format_type: str
    ) -> float:
        """计算转换质量评分"""
        try:
            score = 0.0
            
            # 基于长度的评分（30%）
            original_length = len(original_content.combined_content)
            transformed_length = len(transformed_text)
            
            if original_length > 0:
                length_ratio = min(transformed_length / original_length, 1.0)
                score += length_ratio * 0.3
            
            # 基于内容完整性的评分（40%）
            key_topics = original_content.key_topics
            topics_found = sum(1 for topic in key_topics if topic in transformed_text)
            
            if key_topics:
                topic_coverage = topics_found / len(key_topics)
                score += topic_coverage * 0.4
            else:
                score += 0.2  # 如果没有关键主题，给予部分分数
            
            # 基于格式适配性的评分（30%）
            format_indicators = {
                'attraction_standard': ['景区', '门票', '开放时间', '交通'],
                'product_sales': ['产品', '价格', '优惠', '购买'],
                'travel_guide': ['攻略', '行程', '推荐', '贴士'],
                'blog_post': ['体验', '感受', '推荐', '分享'],
                'summary': ['总结', '要点', '关键', '概述'],
                'marketing_copy': ['优惠', '限时', '立即', '独家'],
                'faq': ['问题', '答案', '如何', '什么']
            }
            
            format_words = format_indicators.get(format_type, [])
            if format_words:
                format_matches = sum(1 for word in format_words if word in transformed_text)
                format_score = min(format_matches / len(format_words), 1.0)
                score += format_score * 0.3
            else:
                score += 0.15  # 默认格式分数
            
            return min(score, 1.0)  # 确保分数不超过1.0
            
        except Exception as e:
            logger.warning(f"质量评分计算失败: {e}")
            return 0.5  # 返回中等分数
    
    def get_supported_formats(self) -> Dict[str, str]:
        """获取支持的转换格式"""
        return self.SUPPORTED_FORMATS.copy()
    
    def is_supported_format(self, format_type: str) -> bool:
        """检查格式是否支持"""
        return format_type in self.SUPPORTED_FORMATS
    
    def get_transformation_stats(self) -> Dict[str, Any]:
        """获取转换器统计信息"""
        return {
            'supported_formats': list(self.SUPPORTED_FORMATS.keys()),
            'task_model_config': self.task_model_config,
            'ai_model_info': self.ai_service.get_model_info(),
            'json_repair_enabled': self.json_processor.enable_repair,
            'available_methods': list(self.format_methods.keys())
        } 