"""
Response Formatter - упрощение и форматирование ответов для Cursor
"""

import logging
from typing import Dict, Any, List

class ResponseFormatter:
    """Форматирование ответов для корректного отображения в Cursor"""
    
    @staticmethod
    def format_stats(api_response: Dict) -> str:
        """Форматирование статистики"""
        if not api_response.get('success'):
            return f"Error: {api_response.get('error', 'Unknown error')}"
        
        data = api_response.get('data', {})
        
        # 🧠 ПРИОРИТЕТ: Если есть ответ от Qwen - возвращаем его напрямую
        if data.get('qwen_controlled') and data.get('qwen_response'):
            return data['qwen_response']
        
        tables = data.get('tables', {})
        
        # Подсчёт общей статистики
        total_records = sum(t.get('records', 0) for t in tables.values())
        total_tables = len(tables)
        
        # Формируем простой текстовый ответ
        result = f"NMP Statistics:\n"
        result += f"- Total tables: {total_tables}\n"
        result += f"- Total records: {total_records:,}\n"
        result += f"- Database: {data.get('database_path', 'data/vectors')}\n\n"
        
        result += "Tables:\n"
        for name, info in sorted(tables.items()):
            records = info.get('records', 0)
            result += f"  - {name}: {records:,} records\n"
        
        return result
    
    @staticmethod
    def format_list(api_response: Dict) -> str:
        """Форматирование списка коллекций"""
        if not api_response.get('success'):
            return f"Error: {api_response.get('error', 'Unknown error')}"
        
        collections = api_response.get('data', {}).get('collections', [])
        
        result = f"Found {len(collections)} collections:\n"
        for coll in sorted(collections):
            result += f"  - {coll}\n"
        
        return result
    
    @staticmethod
    def format_search(api_response: Dict) -> str:
        """Форматирование результатов поиска"""
        # Если пришла строка вместо словаря – возвращаем как есть
        if not isinstance(api_response, dict):
            return str(api_response)

        if not api_response.get('success'):
            return f"Error: {api_response.get('error', 'Unknown error')}"
        
        # 🧠 ПРИОРИТЕТ: Если есть ответ от Qwen - возвращаем его напрямую
        if api_response.get('qwen_controlled') and api_response.get('qwen_response'):
            return api_response['qwen_response']
        
        # ИСПРАВЛЕНИЕ: Поддержка двух форматов ответа (старого и с generate_success_response)
        if 'results' in api_response:
            results = api_response.get('results', [])
            total = api_response.get('total_found', len(results))
            search_type = api_response.get('search_type', 'unknown')
        else:
            data_block = api_response.get('data', {}) if isinstance(api_response, dict) else {}
            if not isinstance(data_block, dict):
                data_block = {}
            results = data_block.get('results', data_block.get('additional_results', []))
            total = data_block.get('total_found', len(results))
            search_type = data_block.get('search_type', api_response.get('search_type', 'unknown'))
        
        if total == 0:
            # Определяем исходный запрос для корректного сообщения
            original_query = api_response.get('query')
            if original_query is None and isinstance(api_response, dict):
                original_query = api_response.get('data', {}).get('query', 'unknown')
            if original_query is None:
                original_query = 'unknown'
            return f"Found 0 results for query: {original_query}"
        
        result = f"Found {total} results:\n\n"
        
        # ОТЛАДКА: Проверяем тип первого элемента
        if results and isinstance(results[0], dict):
            first_item = results[0]
            # Можно логировать ключи при необходимости без прерывания
            # debug_info = f"DEBUG: First item keys: {list(first_item.keys())}\n"
        
        for i, item in enumerate(results[:5], 1):  # Показываем только первые 5
            # Новый формат с полными данными
            if isinstance(item, dict):
                # ID и базовая информация
                item_id = item.get('id', 'unknown')
                
                # ИСПРАВЛЕНИЕ: Определяем основное содержимое в зависимости от типа таблицы
                content = ""
                title = ""
                
                # Для разных типов таблиц используем разные поля
                if 'conversation' in item:  # chats
                    content = item.get('conversation', '')
                    title = item.get('topic', '')
                elif 'error' in item and 'solution' in item:  # errors_solutions
                    title = item.get('error', '')[:100]
                    content = item.get('solution', '')
                elif 'pattern' in item:  # code_patterns
                    title = item.get('description', '')
                    content = item.get('pattern', '')
                    # ОТЛАДКА: Если pattern пустой, используем description как контент
                    if not content.strip():
                        content = title
                        title = "Code Pattern"
                elif 'concept' in item:  # concepts
                    title = item.get('concept', '')
                    content = item.get('content', '')
                elif 'content' in item:  # общий случай
                    content = item.get('content', '')
                    title = item.get('title', item.get('name', ''))
                else:
                    # Fallback: берем первое текстовое поле
                    for key, value in item.items():
                        if key not in ['id', 'embedding', 'timestamp', 'project', 'metadata', 'tags'] and isinstance(value, str) and len(value) > 10:
                            content = value
                            break
                
                # Форматируем результат
                result += f"{i}. "
                if title:
                    result += f"[{title[:50]}{'...' if len(title) > 50 else ''}] "
                
                # ИСПРАВЛЕНИЕ: Убираем ограничение длины контента для полного отображения
                # if len(content) > 150:
                #     content = content[:150] + "..."
                result += f"{content}\n"
                
                # Добавляем метаданные
                project = item.get('project', '')
                category = item.get('category', '')
                tags = item.get('tags', [])
                timestamp = item.get('timestamp', '')
                score = item.get('score', 0)
                
                details = []
                if project:
                    details.append(f"Project: {project}")
                if category:
                    details.append(f"Category: {category}")
                if tags and isinstance(tags, list):
                    details.append(f"Tags: {', '.join(str(t) for t in tags)}")
                if timestamp:
                    details.append(f"Date: {timestamp[:10]}")  # Только дата
                if score:
                    details.append(f"Score: {score}")
                
                if details:
                    result += f"   {' | '.join(details)}\n"
                
                result += f"   ID: {item_id}\n\n"
            else:
                # Старый формат - просто строка
                content = str(item)
                # ИСПРАВЛЕНИЕ: Убираем ограничение длины для полного отображения
                # if len(content) > 200:
                #     content = content[:200] + "..."
                result += f"{i}. {content}\n\n"
        
        if total > 5:
            result += f"... and {total - 5} more results\n"
        
        result += f"\nSearch type: {search_type}"
        
        return result
    
    @staticmethod
    def format_save(api_response: Dict) -> str:
        """Форматирование результата сохранения"""
        if not api_response.get('success'):
            return f"Error: {api_response.get('error', 'Unknown error')}"
        
        data = api_response.get('data', {})
        return f"Successfully saved to {data.get('collection', 'unknown')} collection"
    
    @staticmethod
    def format_memory(api_response: Dict) -> str:
        """Форматирование операций с памятью (сохранение, создание, удаление)"""
        if not api_response.get('success'):
            return f"Error: {api_response.get('error', 'Unknown error')}"
        
        message = api_response.get('message', 'Operation completed')
        data = api_response.get('data', {})
        
        result = f"✅ {message}\n"
        
        # Добавляем детали если есть
        if isinstance(data, dict):
            if 'collection' in data:
                result += f"Collection: {data['collection']}\n"
            if 'id' in data:
                result += f"ID: {data['id']}\n"
            if 'records' in data:
                result += f"Records: {data['records']}\n"
        
        return result
    
    @staticmethod
    def format_context(api_response: Dict) -> str:
        """Форматирование контекста для мгновенного понимания"""
        # Отладочная информация
        import logging
        logger = logging.getLogger("uvicorn.error")
        logger.info(f"🔍 format_context получил: {api_response}")
        
        if not api_response.get('success'):
            return f"Error: {api_response.get('error', 'Unknown error')}"
        
        data = api_response.get('data', {})
        logger.info(f"🔍 format_context data keys: {list(data.keys())}")
        
        # 🚨 КРИТИЧЕСКАЯ ОТЛАДКА: Проверяем, что приходит в data
        logger.info(f"🚨 ОТЛАДКА: search_query = {data.get('search_query')}")
        logger.info(f"🚨 ОТЛАДКА: restored_items = {data.get('restored_items')}")
        logger.info(f"🚨 ОТЛАДКА: session_summary = {data.get('session_summary')}")
        logger.info(f"🚨 ОТЛАДКА: instant_understanding = {data.get('instant_understanding')}")
        logger.info(f"🚨 ОТЛАДКА: code_analysis = {data.get('code_analysis')}")
        
        # 🧠 ПРИОРИТЕТ: Если есть ответ от Qwen - возвращаем его напрямую
        if data.get('qwen_controlled') and data.get('qwen_response'):
            return data['qwen_response']
        
        # FALLBACK: Форматируем структурированные данные
        result = "🎯 INSTANT CONTEXT:\n\n"
        
        # Проверяем тип контекста
        if data.get('session_summary'):
            # Это work_summary
            session = data.get('session_summary', {})
            result = "📊 WORK SUMMARY:\n\n"
            result += f"📅 Session: {session.get('session_id', 'Unknown')}\n"
            result += f"⏱️ Duration: {session.get('duration', 'Unknown')}\n"
            result += f"📁 Files Modified: {session.get('files_modified', 0)}\n"
            result += f"⚡ Decisions Made: {session.get('decisions_made', 0)}\n\n"
            
            achievements = session.get('key_achievements', [])
            if achievements:
                result += "🏆 KEY ACHIEVEMENTS:\n"
                for achievement in achievements:
                    result += f"- {achievement}\n"
                result += "\n"
                
            # Добавляем изменения кода если есть
            code_changes = data.get('code_changes', [])
            if code_changes:
                result += "💻 CODE CHANGES:\n"
                for i, change in enumerate(code_changes):  # Показываем все
                    file_name = change.get('file', 'Unknown')
                    changes = change.get('changes', 'No details')
                    result += f"  {i+1}. {file_name}: {changes}\n"
                result += "\n"
                
            # Добавляем решения если есть
            decisions = data.get('decisions', [])
            if decisions:
                result += "🎯 DECISIONS:\n"
                for i, decision in enumerate(decisions):  # Показываем все
                    decision_text = decision.get('decision', 'Unknown')
                    impact = decision.get('impact', 'unknown')
                    result += f"  {i+1}. {decision_text} (impact: {impact})\n"
                result += "\n"
                
        elif data.get('code_analysis'):
            # Это code_intelligence
            analysis = data.get('code_analysis', {})
            result = "💻 CODE INTELLIGENCE:\n\n"
            result += f"📁 File: {analysis.get('file_path', 'project_wide')}\n"
            result += f"🔍 Analysis: {analysis.get('analysis_type', 'patterns')}\n"
            result += f"📊 Depth: {analysis.get('depth', 'shallow')}\n"
            result += f"🔢 Patterns Found: {analysis.get('patterns_found', 0)}\n"
            result += f"🔗 Dependencies: {analysis.get('dependencies_count', 0)}\n\n"
            
            patterns = data.get('patterns', [])
            if patterns:
                result += "🔍 PATTERNS:\n"
                for pattern in patterns[:3]:
                    pattern_text = pattern.get('pattern', 'Unknown')
                    confidence = pattern.get('confidence', 0)
                    usage = pattern.get('usage_count', 0)
                    result += f"- {pattern_text} (confidence: {confidence}, usage: {usage})\n"
                result += "\n"
                
            # Добавляем зависимости если есть
            dependencies = data.get('dependencies', [])
            if dependencies:
                result += "🔗 DEPENDENCIES:\n"
                for dep in dependencies[:3]:  # Показываем первые 3
                    dep_name = dep.get('dependency', 'Unknown')
                    dep_type = dep.get('type', 'unknown')
                    result += f"- {dep_name} ({dep_type})\n"
                result += "\n"
                
            # Добавляем предложения если есть
            suggestions = data.get('suggestions', [])
            if suggestions:
                result += "💡 SUGGESTIONS:\n"
                for suggestion in suggestions[:3]:  # Показываем первые 3
                    suggestion_text = suggestion.get('suggestion', 'Unknown')
                    priority = suggestion.get('priority', 'unknown')
                    result += f"- {suggestion_text} (priority: {priority})\n"
                result += "\n"
                
        elif data.get('search_query'):
            # Это context_search
            result = "🔍 CONTEXT SEARCH RESULTS:\n\n"
            result += f"🎯 Query: {data.get('search_query', 'Unknown')}\n"
            result += f"📁 Project: {data.get('project_filter', 'All')}\n"
            result += f"📊 Results Found: {data.get('results_found', 0)}\n\n"
            
            # Контексты
            contexts = data.get('contexts', [])
            if contexts:
                result += "📝 CONTEXTS:\n"
                for i, ctx in enumerate(contexts):
                    result += f"  {i+1}. ID: {ctx.get('id', 'unknown')}\n"
                    result += f"     Content: {ctx.get('content', 'No content')}\n"
                    result += f"     Project: {ctx.get('project', 'unknown')}\n"
                    result += f"     Timestamp: {ctx.get('timestamp', 'unknown')}\n"
                    if ctx.get('files_referenced'):
                        result += f"     Files: {ctx.get('files_referenced', [])}\n"
                    result += f"     Relevance: {ctx.get('relevance', 0):.2f}\n\n"
            
            # Чаты
            chats = data.get('legacy_chats', [])
            if chats:
                result += "💬 LEGACY CHATS:\n"
                for i, chat in enumerate(chats):
                    result += f"  {i+1}. ID: {chat.get('id', 'unknown')}\n"
                    result += f"     Content: {chat.get('content', 'No content')}\n"
                    result += f"     Project: {chat.get('project', 'unknown')}\n"
                    result += f"     Relevance: {chat.get('relevance', 0):.2f}\n\n"
            
            # Qwen инсайты
            insights = data.get('qwen_insights', [])
            if insights:
                result += "🧠 QWEN INSIGHTS:\n"
                for i, insight in enumerate(insights):
                    result += f"  {i+1}. {insight.get('insight', 'No insight')}\n"
                    result += f"     Confidence: {insight.get('confidence', 0):.2f}\n\n"
            
            # Связанные концепции
            concepts = data.get('related_concepts', [])
            if concepts:
                result += "🔗 RELATED CONCEPTS:\n"
                for i, concept in enumerate(concepts):
                    result += f"  {i+1}. {concept.get('concept', 'No concept')}\n"
                    result += f"     Relevance: {concept.get('relevance', 0):.2f}\n\n"
                    
        elif data.get('restored_items'):
            # Это context_restore
            result = "🔄 CONTEXT RESTORE RESULTS:\n\n"
            result += f"📁 Project: {data.get('project', 'Unknown')}\n"
            result += f"🎯 Restore Depth: {data.get('restore_depth', 'full')}\n"
            result += f"⏰ Timestamp: {data.get('restore_timestamp', 'Unknown')}\n\n"
            
            # Статистика восстановления
            restored = data.get('restored_items', {})
            result += "📊 RESTORED ITEMS:\n"
            result += f"- Contexts: {restored.get('contexts', 0)}\n"
            result += f"- Chats: {restored.get('chats', 0)}\n"
            result += f"- Code Patterns: {restored.get('code_patterns', 0)}\n"
            result += f"- Files: {restored.get('files', 0)}\n"
            result += f"- Architecture: {restored.get('architecture', 0)}\n"
            result += f"- Sessions: {restored.get('sessions', 0)}\n\n"
            
            # Полный контекст
            full_context = data.get('full_context', {})
            if full_context:
                # Недавние контексты
                recent_contexts = full_context.get('recent_contexts', [])
                if recent_contexts:
                    result += "📝 RECENT CONTEXTS:\n"
                    for i, ctx in enumerate(recent_contexts):
                        result += f"  {i+1}. ID: {ctx.get('id', 'unknown')}\n"
                        result += f"     Content: {ctx.get('content', 'No content')}\n"
                        result += f"     Timestamp: {ctx.get('timestamp', 'unknown')}\n"
                        if ctx.get('files_referenced'):
                            result += f"     Files: {ctx.get('files_referenced', [])}\n"
                        result += "\n"
                
                # Ключевые разговоры
                conversations = full_context.get('key_conversations', [])
                if conversations:
                    result += "💬 KEY CONVERSATIONS:\n"
                    for i, conv in enumerate(conversations):
                        result += f"  {i+1}. ID: {conv.get('id', 'unknown')}\n"
                        result += f"     Content: {conv.get('content', 'No content')}\n"
                        result += f"     Project: {conv.get('project', 'unknown')}\n\n"
                
                # Паттерны кода
                code_patterns = full_context.get('code_patterns', [])
                if code_patterns:
                    result += "💻 CODE PATTERNS:\n"
                    for i, pattern in enumerate(code_patterns):
                        result += f"  {i+1}. Pattern: {pattern.get('pattern', 'No pattern')}\n"
                        result += f"     Usage: {pattern.get('usage', 'unknown')}\n\n"
                
                # Архитектурные решения
                arch_decisions = full_context.get('architecture_decisions', [])
                if arch_decisions:
                    result += "🏗️ ARCHITECTURE DECISIONS:\n"
                    for i, decision in enumerate(arch_decisions):
                        result += f"  {i+1}. Decision: {decision.get('decision', 'No decision')}\n"
                        result += f"     Impact: {decision.get('impact', 'unknown')}\n\n"
                
                # Рабочие сессии
                work_sessions = full_context.get('work_sessions', [])
                if work_sessions:
                    result += "⚡ WORK SESSIONS:\n"
                    for i, session in enumerate(work_sessions):
                        result += f"  {i+1}. Session: {session.get('session', 'No session')}\n"
                        result += f"     Duration: {session.get('duration', 'unknown')}\n\n"
                        
        else:
            # Это instant_understanding
            instant = data.get('instant_understanding', {})
            if instant:
                result += "📍 PROJECT STATE:\n"
                result += f"- Project: {instant.get('project_name', 'Unknown')}\n"
                result += f"- My Role: {instant.get('my_role', 'Unknown')}\n"
                result += f"- Phase: {instant.get('current_phase', 'Unknown')}\n"
                result += f"- Last Action: {instant.get('my_last_action', 'Unknown')[:100]}...\n"
                result += f"- Recent Chat: {instant.get('recent_chat', 'Unknown')[:100]}...\n"
                result += f"- Current Problem: {instant.get('current_problem', 'None')}\n"
                result += f"- Last Solution: {instant.get('last_solution', 'None')[:100]}...\n"
                result += f"- Next Step: {instant.get('next_logical_step', 'Unknown')}\n"
                result += f"- Last Update: {instant.get('last_update', 'Unknown')}\n\n"
            
            # Добавляем контекст проекта
            project_context = data.get('project_context', {})
            if project_context:
                result += "🏗️ PROJECT CONTEXT:\n"
                result += f"- Main Concept: {project_context.get('main_concept', 'Unknown')[:100]}...\n"
                result += f"- Architecture: {project_context.get('architecture', 'Unknown')[:100]}...\n"
                result += f"- Work Session: {project_context.get('work_session', 'Unknown')[:100]}...\n"
                result += f"- Git Status: {project_context.get('git_status', 'Unknown')[:100]}...\n\n"
            
            # Добавляем активные задачи с улучшенным форматированием
            active_tasks = data.get('active_tasks', {})
            if active_tasks:
                result += "📋 ACTIVE TASKS:\n"
                todos = active_tasks.get('todos', [])
                if todos:
                    result += "TODO Items:\n"
                    for i, todo in enumerate(todos[:5]):  # Показываем первые 5
                        # ИСПРАВЛЕНИЕ: Используем новый парсер
                        parsed_items = ResponseFormatter._parse_todo_items(todo)
                        
                        if parsed_items:
                            for j, item in enumerate(parsed_items[:3]):  # Максимум 3 элемента на TODO
                                result += f"  {i+1}.{j+1} ✅ {item}\n"
                        else:
                            result += f"  {i+1}. 📝 {str(todo)}\n"
                result += f"- Recent Errors: {active_tasks.get('recent_errors', 0)}\n"
                
                # Улучшенное отображение debug info
                debug_info = active_tasks.get('debug_info', 'None')
                if debug_info and debug_info != 'None':
                    if isinstance(debug_info, dict):
                        error_text = debug_info.get('error', 'Unknown')
                        solution_text = debug_info.get('solution', 'Unknown')
                        result += f"- Debug Info: 🔧 {error_text[:50]}... → ✅ {solution_text[:50]}...\n\n"
                    else:
                        result += f"- Debug Info: {str(debug_info)[:100]}...\n\n"
                else:
                    result += "- Debug Info: None\n\n"
            
            # Добавляем свежесть данных
            data_freshness = data.get('data_freshness', {})
            if data_freshness:
                result += "📊 DATA FRESHNESS:\n"
                result += f"- Chats: {data_freshness.get('chats', 0)}\n"
                result += f"- Concepts: {data_freshness.get('concepts', 0)}\n"
                result += f"- Code Patterns: {data_freshness.get('code_patterns', 0)}\n"
                result += f"- Errors/Solutions: {data_freshness.get('errors_solutions', 0)}\n"
                result += f"- Sessions: {data_freshness.get('sessions', 0)}\n"
                result += f"- Total Context Pieces: {data_freshness.get('total_context_pieces', 0)}\n\n"
            
            # Контекст кода
            code_context = data.get('code_context', {})
            if code_context:
                result += "💻 CODE CONTEXT:\n"
                
                # Паттерны кода
                patterns = code_context.get('patterns', [])
                if patterns:
                    result += "Code Patterns:\n"
                    for i, pattern in enumerate(patterns):
                        result += f"  {i+1}. {str(pattern)}\n"
                
                # Файлы
                files = code_context.get('files', [])
                if files:
                    result += "Files:\n"
                    for i, file_info in enumerate(files):
                        result += f"  {i+1}. {str(file_info)}\n"
                
                # Конфигурации
                configs = code_context.get('configs', [])
                if configs:
                    result += "Configs:\n"
                    for i, config in enumerate(configs):
                        result += f"  {i+1}. {str(config)}\n"
                
                result += "\n"
        
        # Мои паттерны
        patterns = data.get('my_solution_patterns', [])
        if patterns:
            result += "🧠 MY PATTERNS:\n"
            for pattern in patterns[:3]:  # Показываем первые 3
                result += f"- {pattern}\n"
            result += "\n"
        
        # 🚨 FALLBACK: Если result все еще только заголовок, показываем RAW данные
        if result.strip() == "🎯 INSTANT CONTEXT:":
            logger.warning(f"⚠️ format_context: Ни одно условие не сработало! Показываем RAW данные")
            result += "\n🚨 RAW DATA (условия не сработали):\n"
            result += f"API Response: {str(api_response)[:1000]}...\n\n"
            result += f"Data keys: {list(data.keys())}\n\n"
            for key, value in data.items():
                result += f"{key}: {str(value)[:200]}...\n"
        
        return result
    
    @staticmethod
    def format_error(api_response: Dict) -> str:
        """Форматирование ошибки"""
        error = api_response.get('error', 'Unknown error')
        if isinstance(error, dict):
            error = error.get('message', str(error))
        return f"Error: {error}"
    
    @staticmethod
    def format_generic(api_response: Dict) -> str:
        """Общее форматирование для неизвестных типов ответов"""
        if not api_response.get('success'):
            return ResponseFormatter.format_error(api_response)
        
        data = api_response.get('data', {})
        
        # 🧠 ПРИОРИТЕТ: Если есть ответ от Qwen - возвращаем его напрямую
        if data.get('qwen_controlled') and data.get('qwen_response'):
            return data['qwen_response']
        
        # Простое текстовое представление
        message = api_response.get('message', 'Operation completed')
        
        result = f"{message}\n"
        if isinstance(data, dict) and data:
            for key, value in data.items():
                if isinstance(value, (str, int, float, bool)):
                    result += f"- {key}: {value}\n"
                elif isinstance(value, list):
                    result += f"- {key}: {len(value)} items\n"
                elif isinstance(value, dict):
                    result += f"- {key}: {len(value)} entries\n"
        
        return result 

    @staticmethod
    def _parse_todo_items(todo_raw):
        """
        Универсальный парсер TODO items из различных форматов:
        - "['item1' 'item2' 'item3']" (пробелы вместо запятых)
        - "['item1', 'item2', 'item3']" (обычный массив)
        - "'item1' 'item2' 'item3'" (без скобок)
        - простая строка
        """
        if not todo_raw or not isinstance(todo_raw, str):
            return []
            
        try:
            import re
            clean_text = todo_raw.strip()
            
            # Убираем внешние кавычки если есть
            if (clean_text.startswith("'") and clean_text.endswith("'")) or \
               (clean_text.startswith('"') and clean_text.endswith('"')):
                clean_text = clean_text[1:-1]
            
            todo_items = []
            
            # Формат 1: ['item1' 'item2'] - скобки с пробелами
            if clean_text.startswith('[') and clean_text.endswith(']'):
                inner_text = clean_text[1:-1].strip()
                # Ищем элементы в кавычках
                todo_items = re.findall(r"'([^']*)'", inner_text)
                if not todo_items:
                    todo_items = re.findall(r'"([^"]*)"', inner_text)
                    
                # Если не нашли - попробуем обычный массив с запятыми
                if not todo_items and ',' in inner_text:
                    items = inner_text.split(',')
                    todo_items = [item.strip().strip("'\"") for item in items if item.strip().strip("'\"")]
            
            # Формат 2: 'item1' 'item2' - без скобок
            elif "'" in clean_text or '"' in clean_text:
                todo_items = re.findall(r"'([^']*)'", clean_text)
                if not todo_items:
                    todo_items = re.findall(r'"([^"]*)"', clean_text)
            
            # Формат 3: простая строка
            else:
                if clean_text.strip():
                    todo_items = [clean_text.strip()]
            
            # Очищаем пустые элементы
            return [item.strip() for item in todo_items if item.strip()]
            
        except Exception as e:
            # Fallback: возвращаем как есть
            return [str(todo_raw)]