web_app.py

#!/usr/bin/env python3
"""
Web UI for the Dynamic AI Framework - Updated to use new architecture
"""

from flask import Flask, render_template, request, jsonify, send_file
from flask_cors import CORS
import traceback
from datetime import datetime
import os
import base64
from pathlib import Path
from typing import Optional, Dict, Any

# Import framework components
from dynamic_ai_framework import (
    PromptStructure, DynamicPromptManager, 
    OllamaProvider, OpenAICompatibleProvider, FileStorageBackend, CharacterManager,
    EventSystem, TypedPromptComponent, ComponentType, LLMResponse, StreamChunk,
    get_component_type_registry
)
from dynamic_ai_framework.config import get_config_manager, get_config, get_external_services_config
from dynamic_ai_framework.core.exceptions import (
    FrameworkError, ComponentError, CharacterError, LLMProviderError
)
from dynamic_ai_framework.core.logging_config import get_logger

app = Flask(__name__)
CORS(app)

# Initialize logging
logger = get_logger("web_app")

# Global framework instances
prompt_manager: Optional[DynamicPromptManager] = None
llm_provider = None  # Can be OllamaProvider or OpenAICompatibleProvider
character_manager: Optional[CharacterManager] = None
event_system: Optional[EventSystem] = None
current_model: Optional[str] = None
current_character: Optional[str] = None
current_provider_type: str = "ollama"  # "ollama" or "openai_compatible"

# Storage backends
character_storage: Optional[FileStorageBackend] = None
portrait_storage_dir = Path("portraits")
portrait_storage_dir.mkdir(exist_ok=True)


def initialize_framework():
    """Initialize the framework components."""
    global character_storage, character_manager, event_system
    
    # Initialize event system
    event_system = EventSystem()
    
    # Initialize storage backends
    character_storage = FileStorageBackend("characters")
    
    # Initialize character manager
    character_manager = CharacterManager(character_storage, event_system)


def initialize_chat_system(model_name: str = "llama3.2", provider_type: str = "ollama", 
                           provider_settings: Dict[str, Any] = None) -> tuple[bool, Optional[str]]:
    """Initialize the chat system with specified model using new provider architecture."""
    global prompt_manager, llm_provider, current_model, current_character, current_provider_type
    
    if provider_settings is None:
        provider_settings = {}
    
    try:
        # Initialize LLM provider based on type
        if provider_type == "ollama":
            llm_provider = OllamaProvider(model_name, **provider_settings)
        elif provider_type == "openai_compatible":
            llm_provider = OpenAICompatibleProvider(model_name, **provider_settings)
        else:
            return False, f"Unknown provider type: {provider_type}"
        
        # Test connection
        if not llm_provider.test_connection():
            return False, f"Failed to connect to model '{model_name}' using {provider_type}"
        
        # Create default prompt structure
        structure = create_default_prompt_structure()
        
        # Initialize prompt manager with character manager integration
        prompt_manager = DynamicPromptManager(structure, llm_provider, event_system, character_manager, current_character)
        
        current_model = model_name
        current_provider_type = provider_type
        return True, None
        
    except LLMProviderError as e:
        error_msg = f"LLM Provider error initializing chat with model '{model_name}' using {provider_type}: {e}"
        logger.error(error_msg)
        return False, error_msg
    except (ConnectionError, TimeoutError) as e:
        error_msg = f"Connection error initializing chat with model '{model_name}' using {provider_type}: {e}"
        logger.error(error_msg)
        return False, error_msg
    except Exception as e:
        error_msg = f"Unexpected error initializing chat with model '{model_name}' using {provider_type}: {e}"
        logger.error(error_msg)
        return False, error_msg


def create_default_prompt_structure() -> PromptStructure:
    """Create a default prompt structure with basic components."""
    # Create basic typed components
    personality = TypedPromptComponent(
        "personality", 
        ComponentType.PERSONALITY,
        "You are a helpful AI assistant.",
        update_strategy="simple"
    )
    
    context = TypedPromptComponent(
        "context",
        ComponentType.CONTEXT, 
        "General conversation",
        update_strategy="simple"
    )
    
    memory = TypedPromptComponent(
        "memory",
        ComponentType.MEMORY,
        update_strategy="advanced"
    )
    
    # Create template
    template = """{personality}

CURRENT CONTEXT: {context}

CONVERSATION MEMORY:
{memory}

Please respond to the user appropriately based on the above information."""
    
    # Create structure
    structure = PromptStructure(template, "web_chat", event_system)
    
    # Add components
    structure.add_component(personality)
    structure.add_component(context)
    structure.add_component(memory)
    
    return structure


def export_current_system_state() -> Dict[str, Any]:
    """Export current system state as character data."""
    if not prompt_manager:
        return None
    
    components = {}
    for name, component in prompt_manager.structure.components.items():
        components[name] = {
            'name': component.name,
            'content': component.content,
            'update_strategy': component.update_strategy,
            'metadata': component.metadata
        }
    
    return {
        'components': components,
        'component_order': prompt_manager.structure.component_order,
        'template': prompt_manager.structure.template
    }


def apply_character_to_system(character_data: Dict[str, Any]) -> bool:
    """Apply character data to current system using framework."""
    if not prompt_manager or not character_manager:
        return False
    
    try:
        # Use framework's character manager
        return character_manager.apply_character(character_data, prompt_manager)
    except Exception as e:
        logger.error(f"Error applying character: {e}")
        return False


# Initialize framework on startup
initialize_framework()

# Note: Character loading is now handled by the frontend based on user's last choice


@app.route('/')
def index():
    """Main page."""
    return render_template('index.html')


@app.route('/documentation')
def documentation():
    """Documentation page."""
    return render_template('documentation.html')


@app.route('/api/status')
def get_status():
    """Get current system status."""
    if not prompt_manager:
        return jsonify({
            'status': 'not_initialized',
            'current_model': current_model,
            'provider_type': current_provider_type,
            'timestamp': datetime.now().isoformat()
        }), 200
    
    try:
        system_info = prompt_manager.get_system_info()
        
        # Add provider information
        provider_info = {}
        if llm_provider:
            provider_info = llm_provider.get_provider_info()
            
        return jsonify({
            'status': 'ready',
            'current_model': current_model,
            'provider_type': current_provider_type,
            'current_character': current_character,
            'system_info': system_info,
            'provider_info': provider_info,
            'timestamp': datetime.now().isoformat()
        })
    except (FrameworkError, LLMProviderError) as e:
        logger.error(f"Framework/LLM error in status endpoint: {e}")
        return jsonify({'error': str(e)}), 500
    except Exception as e:
        logger.error(f"Unexpected error in status endpoint: {e}")
        return jsonify({'error': 'Internal server error'}), 500


@app.route('/api/chat', methods=['POST'])
def chat():
    """Process chat message using framework."""
    if not prompt_manager:
        return jsonify({'error': 'Chat not initialized'}), 500
    
    try:
        data = request.get_json()
        user_input = data.get('message', '').strip()
        stream = data.get('stream', False)
        
        if not user_input:
            return jsonify({'error': 'Empty message'}), 400
        
        if stream:
            return chat_stream(user_input)
        
        # Get AI response using framework (conversation is automatically saved by prompt manager)
        response = prompt_manager.get_response(user_input)
        
        # Debug: Check conversation history
        if current_character and character_manager:
            history = character_manager.get_conversation_history(current_character)
            logger.debug(f"Chat processed. Current character: {current_character}")
            logger.debug(f"Character {current_character} now has {len(history)} conversation exchanges")
        
        return jsonify({
            'response': response,
            'timestamp': datetime.now().isoformat()
        })
    
    except LLMProviderError as e:
        return jsonify({'error': f'LLM Error: {str(e)}'}), 500
    except Exception as e:
        return jsonify({'error': str(e), 'traceback': traceback.format_exc()}), 500


def chat_stream(user_input: str):
    """Handle streaming chat response."""
    from flask import Response, stream_template
    import json
    
    def generate_stream():
        try:
            # Yield initial message
            yield f"data: {json.dumps({'type': 'start', 'message': 'Starting response...'})}\n\n"
            
            full_response = ""
            
            # Get streaming response
            for chunk in prompt_manager.get_streaming_response(user_input):
                if hasattr(chunk, 'content'):
                    content = chunk.content
                    is_complete = getattr(chunk, 'is_complete', False)
                else:
                    # Backward compatibility
                    content = str(chunk)
                    is_complete = False
                
                full_response += content
                
                # Yield chunk
                chunk_data = {
                    'type': 'chunk',
                    'content': content,
                    'is_complete': is_complete
                }
                yield f"data: {json.dumps(chunk_data)}\n\n"
                
                if is_complete:
                    break
            
            # Debug: Check conversation history
            if current_character and character_manager:
                history = character_manager.get_conversation_history(current_character)
                logger.debug(f"Streaming chat processed. Current character: {current_character}")
                logger.debug(f"Character {current_character} now has {len(history)} conversation exchanges")
            
            # Yield completion message
            completion_data = {
                'type': 'complete',
                'full_response': full_response,
                'timestamp': datetime.now().isoformat()
            }
            yield f"data: {json.dumps(completion_data)}\n\n"
            yield "data: [DONE]\n\n"
            
        except Exception as e:
            error_data = {
                'type': 'error',
                'error': str(e)
            }
            yield f"data: {json.dumps(error_data)}\n\n"
            yield "data: [DONE]\n\n"
    
    return Response(
        generate_stream(),
        mimetype='text/event-stream',
        headers={
            'Cache-Control': 'no-cache',
            'Connection': 'keep-alive',
            'Access-Control-Allow-Origin': '*',
            'Access-Control-Allow-Headers': 'Cache-Control'
        }
    )


@app.route('/api/components')
def get_components():
    """Get information about current components."""
    if not prompt_manager:
        return jsonify({
            'components': {},
            'component_order': []
        })
    
    try:
        components = {}
        for name, component in prompt_manager.structure.components.items():
            components[name] = {
                'name': component.name,
                'content': component.content,
                'metadata': component.metadata,
                'update_strategy': component.update_strategy,
                'last_updated': component.last_updated.isoformat(),
                'update_count': component.update_count,
                'component_type': getattr(component, 'component_type', ComponentType.CUSTOM).value if hasattr(component, 'component_type') else 'custom'
            }
        
        return jsonify({
            'components': components,
            'component_order': prompt_manager.structure.component_order
        })
    
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/components', methods=['POST'])
def create_component():
    """Create a new custom component using framework."""
    if not prompt_manager:
        return jsonify({'error': 'Chat not initialized'}), 500
    
    try:
        data = request.get_json()
        name = data.get('name', '').strip()
        content = data.get('content', '')
        update_strategy = data.get('update_strategy', 'simple')
        component_type = data.get('component_type', 'custom')
        metadata = data.get('metadata', {})
        
        if not name:
            return jsonify({'error': 'Component name is required'}), 400
        
        if prompt_manager.structure.get_component(name):
            return jsonify({'error': f'Component "{name}" already exists'}), 400
        
        # Create component using framework
        try:
            component_type_enum = ComponentType(component_type)
            new_component = TypedPromptComponent(
                name, component_type_enum, content, update_strategy, metadata
            )
        except ValueError:
            # Fallback to custom component
            new_component = TypedPromptComponent(
                name, ComponentType.CUSTOM, content, update_strategy, metadata
            )
        
        # Add to structure
        prompt_manager.structure.add_component(new_component)
        
        return jsonify({
            'success': True,
            'message': f'Component "{name}" created successfully',
            'component': {
                'name': new_component.name,
                'content': new_component.content,
                'update_strategy': new_component.update_strategy,
                'metadata': new_component.metadata,
                'component_type': new_component.component_type.value
            }
        })
    
    except ComponentError as e:
        return jsonify({'error': str(e)}), 400
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/components/<component_name>', methods=['PUT'])
def update_component(component_name):
    """Update a specific component using framework."""
    if not prompt_manager:
        return jsonify({'error': 'Chat not initialized'}), 500
    
    try:
        data = request.get_json()
        new_content = data.get('content', '')
        metadata = data.get('metadata', {})
        
        # Update using framework
        prompt_manager.update_component(component_name, new_content, metadata)
        
        component = prompt_manager.structure.get_component(component_name)
        return jsonify({
            'success': True,
            'message': f'Component "{component_name}" updated successfully',
            'component': {
                'name': component.name,
                'content': component.content,
                'update_strategy': component.update_strategy,
                'metadata': component.metadata
            }
        })
    
    except ComponentError as e:
        return jsonify({'error': str(e)}), 404
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/components/<component_name>', methods=['DELETE'])
def delete_component(component_name):
    """Delete a specific component using framework."""
    if not prompt_manager:
        return jsonify({'error': 'Chat not initialized'}), 500
    
    try:
        # Prevent deletion of core components
        core_components = ['personality', 'memory', 'context']
        if component_name in core_components:
            return jsonify({'error': f'Cannot delete core component "{component_name}"'}), 400
        
        # Remove using framework
        prompt_manager.structure.remove_component(component_name)
        
        return jsonify({
            'success': True,
            'message': f'Component "{component_name}" deleted successfully'
        })
    
    except ComponentError as e:
        return jsonify({'error': str(e)}), 404
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/components/reorder', methods=['POST'])
def reorder_components():
    """Reorder components using framework."""
    if not prompt_manager:
        return jsonify({'error': 'Chat not initialized'}), 500
    
    try:
        data = request.get_json()
        new_order = data.get('order', [])
        
        if not isinstance(new_order, list):
            return jsonify({'error': 'Order must be a list of component names'}), 400
        
        # Reorder using framework
        prompt_manager.structure.reorder_components(new_order)
        
        return jsonify({
            'success': True,
            'message': 'Component order updated successfully',
            'order': new_order
        })
    
    except ComponentError as e:
        return jsonify({'error': str(e)}), 400
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/history')
def get_history():
    """Get conversation history from character storage."""
    character_id = request.args.get('character_id')
    
    if not character_manager:
        return jsonify({'error': 'Character manager not initialized'}), 500
    
    # If no character_id specified, use current character
    if not character_id:
        character_id = current_character
    
    # If still no character, return empty history
    if not character_id:
        return jsonify({
            'history': [],
            'total_exchanges': 0
        })
    
    try:
        # Get full history from character storage
        character_history = character_manager.get_conversation_history(character_id)
        
        history = []
        for entry in character_history:
            history.append({
                'user_input': entry['user_input'],
                'ai_response': entry['ai_response'],
                'timestamp': entry['timestamp'],
                'metadata': entry.get('metadata', {})
            })
        
        return jsonify({
            'history': history,
            'total_exchanges': len(history),
            'character_id': character_id
        })
    
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/history/clear', methods=['POST'])
def clear_conversation_history():
    """Clear conversation history using framework."""
    if not prompt_manager:
        return jsonify({'error': 'Chat not initialized'}), 500
    
    try:
        prompt_manager.clear_conversation_history()
        
        return jsonify({
            'success': True,
            'message': 'Conversation history cleared successfully'
        })
    
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/template', methods=['GET'])
def get_template():
    """Get the current template."""
    if not prompt_manager:
        return jsonify({'error': 'Chat not initialized'}), 500
    
    try:
        return jsonify({
            'template': prompt_manager.structure.template,
            'name': prompt_manager.structure.name
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/template', methods=['PUT'])
def update_template():
    """Update the template using framework."""
    if not prompt_manager:
        return jsonify({'error': 'Chat not initialized'}), 500
    
    try:
        data = request.get_json()
        new_template = data.get('template', '')
        
        if not new_template.strip():
            return jsonify({'error': 'Template cannot be empty'}), 400
        
        # Update using framework
        prompt_manager.structure.update_template(new_template)
        
        return jsonify({
            'success': True,
            'message': 'Template updated successfully'
        })
    
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/template/auto-generate', methods=['POST'])
def auto_generate_template():
    """Auto-generate a template using framework."""
    if not prompt_manager:
        return jsonify({'error': 'Chat not initialized'}), 500
    
    try:
        data = request.get_json() or {}
        style = data.get('style', 'detailed')
        
        new_template = prompt_manager.structure.auto_generate_template(style)
        
        return jsonify({
            'success': True,
            'message': 'Template auto-generated successfully',
            'template': new_template
        })
    
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/characters')
def get_characters():
    """Get list of all characters using framework."""
    if not character_manager:
        return jsonify({'error': 'Character manager not initialized'}), 500
    
    try:
        characters = character_manager.list_characters()
        return jsonify({
            'characters': characters,
            'current_character': current_character
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/characters', methods=['POST'])
def create_character():
    """Create a new character using framework."""
    if not character_manager:
        return jsonify({'error': 'Character manager not initialized'}), 500
    
    try:
        data = request.get_json()
        name = data.get('name', '').strip()
        description = data.get('description', '').strip()
        
        if not name:
            return jsonify({'error': 'Character name is required'}), 400
        
        # Create character using framework
        character_data = character_manager.create_empty_character(name, description)
        character_id = character_manager.save_character(character_data)
        
        return jsonify({
            'success': True,
            'message': f'Character "{name}" created successfully',
            'character_id': character_id
        })
        
    except CharacterError as e:
        return jsonify({'error': str(e)}), 400
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/characters/base')
def get_base_character():
    """Get base character data - a special endpoint for the default character."""
    if not character_manager:
        return jsonify({'error': 'Character manager not initialized'}), 500
    
    try:
        # Check if 'base' character exists
        character_data = character_manager.load_character('base')
        if character_data:
            return jsonify({'character': character_data})
        else:
            return jsonify({'error': 'Base character not found'}), 404
    except Exception as e:
        logger.error(f"Error loading base character: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/characters/<character_id>')
def get_character(character_id):
    """Get specific character details using framework."""
    if not character_manager:
        return jsonify({'error': 'Character manager not initialized'}), 500
    
    try:
        character_data = character_manager.load_character(character_id)
        if not character_data:
            return jsonify({'error': 'Character not found'}), 404
            
        return jsonify({'character': character_data})
        
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/characters/<character_id>/load', methods=['POST'])
def load_character_into_system(character_id):
    """Load a character into the current system using framework."""
    global current_character
    
    if not prompt_manager or not character_manager:
        return jsonify({'error': 'Chat system not initialized. Please initialize first.'}), 400
    
    if not llm_provider:
        return jsonify({'error': 'LLM provider not initialized. Please initialize first.'}), 400
    
    try:
        character_data = character_manager.load_character(character_id)
        if not character_data:
            return jsonify({'error': 'Character not found'}), 404
        
        # Apply character using framework
        if character_manager.apply_character(character_data, prompt_manager):
            current_character = character_id
            # Load character's conversation history into current session
            prompt_manager.load_character_history(character_id)
            
            # Trigger memory component update to reflect loaded conversation history
            memory_component = prompt_manager.get_component('memory')
            if memory_component and hasattr(memory_component, 'auto_update'):
                try:
                    # Trigger an auto-update of the memory component with dummy inputs
                    # This will cause it to read the conversation history and update accordingly
                    memory_component.auto_update("", "", {}, None)
                except Exception as e:
                    logger.warning(f"Could not update memory component: {e}")
            
            return jsonify({
                'success': True,
                'message': f'Character "{character_data["name"]}" loaded successfully',
                'character_name': character_data['name']
            })
        else:
            return jsonify({'error': 'Failed to apply character to system'}), 500
            
    except CharacterError as e:
        return jsonify({'error': str(e)}), 404
    except Exception as e:
        return jsonify({'error': str(e)}), 500


# Continue with remaining endpoints...
@app.route('/api/models')
def get_available_models():
    """Get list of available models using framework."""
    try:
        if llm_provider:
            models = llm_provider.get_available_models()
        else:
            # Direct Ollama query as last resort
            import subprocess
            result = subprocess.run(['ollama', 'list'], capture_output=True, text=True, timeout=10)
            
            if result.returncode == 0:
                lines = result.stdout.strip().split('\n')[1:]  # Skip header
                models = []
                for line in lines:
                    if line.strip():
                        model_name = line.split()[0]  # First column is model name
                        models.append(model_name)
            else:
                models = []
        
        return jsonify({
            'models': models,
            'current_model': current_model,
            'provider_type': current_provider_type
        })
            
    except Exception as e:
        return jsonify({'error': f'Error getting models: {str(e)}', 'models': []}), 200


@app.route('/api/models/test-openai', methods=['POST'])
def test_openai_connection():
    """Test OpenAI-compatible API connection and get models."""
    try:
        data = request.get_json()
        host = data.get('host', '127.0.0.1')
        port = data.get('port', 1234)
        api_key = data.get('api_key')
        use_https = data.get('use_https', False)
        endpoint_path = data.get('endpoint_path', '/v1/chat/completions')
        
        # Create a temporary provider for testing
        test_provider = OpenAICompatibleProvider(
            model_name="test-model",
            host=host,
            port=port,
            api_key=api_key,
            use_https=use_https,
            endpoint_path=endpoint_path
        )
        
        # Test connection
        connection_ok = test_provider.test_connection()
        models = test_provider.get_available_models()
        
        return jsonify({
            'success': connection_ok,
            'models': models,
            'connection_info': {
                'host': host,
                'port': port,
                'use_https': use_https,
                'base_url': test_provider.base_url
            }
        })
        
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e),
            'models': []
        }), 200


@app.route('/api/initialize', methods=['POST'])
def initialize():
    """Initialize or reinitialize the chat system using new provider architecture."""
    try:
        data = request.get_json()
        model_name = data.get('model', 'llama3.2')
        provider_type = data.get('provider_type', 'ollama')
        provider_settings = data.get('provider_settings', {})
        
        success, error_msg = initialize_chat_system(model_name, provider_type, provider_settings)
        
        if success:
            return jsonify({
                'success': True, 
                'message': f'Chat system initialized with model: {model_name} using {provider_type}',
                'model': model_name,
                'provider_type': provider_type,
                'provider_info': llm_provider.get_provider_info() if llm_provider else None
            })
        else:
            return jsonify({'error': error_msg}), 500
            
    except Exception as e:
        return jsonify({'error': f'Initialization failed: {str(e)}'}), 500


@app.route('/api/providers')
def get_providers():
    """Get available provider types and their settings definitions."""
    try:
        providers = {
            'ollama': {
                'name': 'Ollama',
                'description': 'Local Ollama server with native API and OpenAI compatibility',
                'settings': OllamaProvider('dummy')._get_default_settings(),
                'setting_definitions': OllamaProvider('dummy').get_setting_definitions()
            },
            'openai_compatible': {
                'name': 'OpenAI Compatible',
                'description': 'OpenAI API and compatible services (Anthropic, LM Studio, etc.)',
                'settings': OpenAICompatibleProvider('dummy')._get_default_settings(),
                'setting_definitions': OpenAICompatibleProvider('dummy').get_setting_definitions()
            }
        }
        
        return jsonify({
            'providers': providers,
            'current_provider': current_provider_type,
            'current_model': current_model
        })
    except Exception as e:
        return jsonify({'error': f'Failed to get providers: {str(e)}'}), 500


@app.route('/api/provider/settings', methods=['GET'])
def get_provider_settings():
    """Get current provider settings."""
    try:
        if not llm_provider:
            # Return default settings for the current provider type if no provider initialized
            return jsonify({
                'provider_type': current_provider_type,
                'model': current_model or 'llama3.2',
                'settings': {},
                'setting_definitions': {},
                'validation_errors': {},
                'initialized': False
            })
        
        return jsonify({
            'provider_type': llm_provider.get_provider_type(),
            'model': llm_provider.model_name,
            'settings': llm_provider.settings,
            'setting_definitions': llm_provider.get_setting_definitions(),
            'validation_errors': llm_provider.validate_settings(),
            'initialized': True
        })
    except Exception as e:
        return jsonify({'error': f'Failed to get provider settings: {str(e)}'}), 500


@app.route('/api/provider/settings', methods=['PUT'])
def update_provider_settings():
    """Update provider settings."""
    global current_provider_type
    try:
        data = request.get_json()
        provider_type = data.get('provider_type', current_provider_type)
        settings = data.get('settings', {})
        
        # Create a temporary provider instance for validation if none exists
        temp_provider = None
        target_provider = llm_provider
        
        if not target_provider:
            if provider_type == "ollama":
                temp_provider = OllamaProvider("temp_model", **settings)
                target_provider = temp_provider
            elif provider_type == "openai_compatible":
                temp_provider = OpenAICompatibleProvider("temp_model", **settings)
                target_provider = temp_provider
            else:
                return jsonify({'error': f'Unknown provider type: {provider_type}'}), 400
        
        # Validate settings
        validation_errors = {}
        setting_defs = target_provider.get_setting_definitions()
        
        for key, value in settings.items():
            if key not in setting_defs:
                validation_errors[key] = f"Unknown setting: {key}"
                continue
            
            # Basic type validation
            definition = setting_defs[key]
            expected_type = definition.get('type')
            
            if expected_type == 'number' and not isinstance(value, (int, float)):
                try:
                    settings[key] = float(value)
                except (ValueError, TypeError):
                    validation_errors[key] = "Must be a number"
            elif expected_type == 'boolean' and not isinstance(value, bool):
                if isinstance(value, str):
                    settings[key] = value.lower() in ('true', '1', 'yes', 'on')
                else:
                    validation_errors[key] = "Must be a boolean"
        
        if validation_errors:
            return jsonify({'error': 'Validation failed', 'validation_errors': validation_errors}), 400
        
        # Update settings only if we have an initialized provider
        if llm_provider and not temp_provider:
            llm_provider.update_settings(**settings)
        
        # Update current provider type
        current_provider_type = provider_type
        
        return jsonify({
            'success': True,
            'message': 'Provider settings validated and saved' if temp_provider else 'Provider settings updated',
            'settings': target_provider.settings,
            'validation_errors': target_provider.validate_settings(),
            'provider_type': provider_type,
            'initialized': llm_provider is not None
        })
    except Exception as e:
        return jsonify({'error': f'Failed to update provider settings: {str(e)}'}), 500


@app.route('/api/provider/test', methods=['POST'])
def test_provider():
    """Test the provider connection with provided settings."""
    try:
        data = request.get_json()
        provider_type = data.get('provider_type', current_provider_type)
        model_name = data.get('model', current_model or 'llama3.2')
        settings = data.get('settings', {})
        
        # Create a temporary provider for testing
        test_provider = None
        if provider_type == "ollama":
            test_provider = OllamaProvider(model_name, **settings)
        elif provider_type == "openai_compatible":
            test_provider = OpenAICompatibleProvider(model_name, **settings)
        else:
            return jsonify({'error': f'Unknown provider type: {provider_type}'}), 400
        
        success = test_provider.test_connection()
        
        response_data = {
            'success': success,
            'provider_type': test_provider.get_provider_type(),
            'model': test_provider.model_name,
            'message': 'Connection successful' if success else 'Connection failed'
        }
        
        if hasattr(test_provider, 'get_health_status'):
            response_data['health_status'] = test_provider.get_health_status()
        
        return jsonify(response_data)
    except Exception as e:
        return jsonify({'error': f'Provider test failed: {str(e)}', 'success': False}), 500


@app.route('/api/provider/models')
def get_provider_models():
    """Get available models for a specific provider."""
    try:
        provider_type = request.args.get('provider', current_provider_type)
        
        if not provider_type:
            return jsonify({'error': 'No provider specified'}), 400
        
        # Use existing provider if available and matches type, otherwise create temporary
        temp_provider = None
        if llm_provider and llm_provider.get_provider_type() == provider_type:
            temp_provider = llm_provider
        else:
            # Create a temporary provider instance to get models with default settings
            if provider_type == 'ollama':
                from dynamic_ai_framework.providers.ollama import OllamaProvider
                temp_provider = OllamaProvider("temp")
            elif provider_type == 'openai_compatible':
                from dynamic_ai_framework.providers.openai_compatible import OpenAICompatibleProvider
                temp_provider = OpenAICompatibleProvider("temp")
            else:
                return jsonify({'error': f'Unknown provider type: {provider_type}'}), 400
        
        models = temp_provider.get_available_models()
        
        return jsonify({
            'models': models,
            'provider_type': provider_type
        })
        
    except Exception as e:
        return jsonify({'error': f'Error getting models: {str(e)}', 'models': []}), 200


@app.route('/api/prompt')
def get_current_prompt():
    """Get the current rendered prompt for debugging."""
    if not prompt_manager:
        return jsonify({'error': 'Chat not initialized'}), 500
    
    try:
        current_prompt = prompt_manager.structure.render()
        return jsonify({
            'prompt': current_prompt,
            'length': len(current_prompt)
        })
    
    except Exception as e:
        return jsonify({'error': str(e)}), 500


# Portrait management endpoints (simplified)
@app.route('/api/characters/<character_id>/portrait', methods=['POST'])
def upload_character_portrait(character_id):
    """Upload portrait image for a character."""
    try:
        data = request.get_json()
        
        if not data or 'image_data' not in data:
            return jsonify({'error': 'No image data provided'}), 400
        
        image_data = data['image_data']
        filename = data.get('filename', 'portrait.png')
        
        # Extract file extension
        file_ext = os.path.splitext(filename)[1].lower() or '.png'
        portrait_filename = f"{character_id}{file_ext}"
        portrait_path = portrait_storage_dir / portrait_filename
        
        # Decode and save image
        if image_data.startswith('data:image'):
            image_data = image_data.split(',')[1]
        
        try:
            image_bytes = base64.b64decode(image_data)
        except Exception as e:
            return jsonify({'error': f'Invalid image data: {str(e)}'}), 400
        
        with open(portrait_path, 'wb') as f:
            f.write(image_bytes)
        
        return jsonify({
            'success': True,
            'portrait_path': str(portrait_filename),
            'message': f'Portrait saved for character {character_id}'
        })
        
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/characters/<character_id>/portrait', methods=['GET'])
def get_character_portrait(character_id):
    """Get portrait image for a character."""
    try:
        extensions = ['.png', '.jpg', '.jpeg', '.gif', '.webp']
        
        for ext in extensions:
            portrait_path = portrait_storage_dir / f"{character_id}{ext}"
            if portrait_path.exists():
                return send_file(portrait_path)
        
        return jsonify({'error': 'Portrait not found'}), 404
        
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/characters/<character_id>/portrait', methods=['DELETE'])
def delete_character_portrait(character_id):
    """Delete portrait image for a character."""
    try:
        extensions = ['.png', '.jpg', '.jpeg', '.gif', '.webp']
        deleted = False
        
        for ext in extensions:
            portrait_path = portrait_storage_dir / f"{character_id}{ext}"
            if portrait_path.exists():
                portrait_path.unlink()
                deleted = True
        
        if deleted:
            return jsonify({
                'success': True,
                'message': f'Portrait deleted for character {character_id}'
            })
        else:
            return jsonify({'error': 'Portrait not found'}), 404
        
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/characters/<character_id>', methods=['PUT'])
def update_character(character_id):
    """Update an existing character metadata using framework."""
    if not character_manager:
        return jsonify({'error': 'Character manager not initialized'}), 500
    
    try:
        existing_character = character_manager.load_character(character_id)
        if not existing_character:
            return jsonify({'error': 'Character not found'}), 404
        
        data = request.get_json()
        
        # Update metadata, keep existing components and template
        existing_character.update({
            'name': data.get('name', existing_character['name']),
            'description': data.get('description', existing_character.get('description', '')),
            'max_history_entries': data.get('max_history_entries', existing_character.get('max_history_entries', 1000))
        })
        
        # Save updated character using framework
        character_manager.save_character(existing_character)
        
        return jsonify({
            'success': True,
            'message': f'Character "{existing_character["name"]}" metadata updated successfully'
        })
        
    except CharacterError as e:
        return jsonify({'error': str(e)}), 400
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/characters/<character_id>/save-current-state', methods=['POST'])
def save_current_state_to_character(character_id):
    """Update an existing character with current system state using framework."""
    if not prompt_manager or not character_manager:
        return jsonify({'error': 'System not initialized'}), 500
    
    try:
        existing_character = character_manager.load_character(character_id)
        if not existing_character:
            return jsonify({'error': 'Character not found'}), 404
        
        # Export current system state using framework
        character_data = character_manager.export_from_prompt_manager(prompt_manager)
        if not character_data:
            return jsonify({'error': 'No system state to export'}), 500
        
        # Update with current state but preserve metadata and conversation history
        character_data.update({
            'id': character_id,
            'name': existing_character['name'],
            'description': existing_character.get('description', ''),
            'created_at': existing_character.get('created_at', datetime.now().isoformat()),
            'conversation_history': existing_character.get('conversation_history', []),
            'max_history_entries': existing_character.get('max_history_entries', 1000)
        })
        
        # Save updated character using framework
        character_manager.save_character(character_data)
        
        return jsonify({
            'success': True,
            'message': f'Character "{character_data["name"]}" updated with current system state'
        })
        
    except CharacterError as e:
        return jsonify({'error': str(e)}), 400
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/characters/<character_id>', methods=['DELETE'])
def delete_character(character_id):
    """Delete a character using framework."""
    global current_character
    
    if not character_manager:
        return jsonify({'error': 'Character manager not initialized'}), 500
    
    try:
        character_data = character_manager.load_character(character_id)
        if not character_data:
            return jsonify({'error': 'Character not found'}), 404
        
        # Don't allow deleting currently loaded character
        if current_character == character_id:
            current_character = None
        
        # Delete character using framework
        if character_manager.delete_character(character_id):
            return jsonify({
                'success': True,
                'message': f'Character "{character_data["name"]}" deleted successfully'
            })
        else:
            return jsonify({'error': 'Failed to delete character'}), 500
            
    except CharacterError as e:
        return jsonify({'error': str(e)}), 404
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/characters/<character_id>/delete-exchanges', methods=['DELETE'])
def delete_exchanges(character_id):
    """Delete the last N conversation exchanges from character history."""
    try:
        if not character_manager:
            return jsonify({'error': 'Character manager not initialized'}), 500
        
        # Get the count from request body
        data = request.get_json() or {}
        count = data.get('count', 1)
        
        if not isinstance(count, int) or count < 1:
            return jsonify({'error': 'Count must be a positive integer'}), 400
        
        # Get current conversation history
        history = character_manager.get_conversation_history(character_id)
        
        if not history:
            return jsonify({'error': 'No conversation history to delete'}), 400
        
        if count > len(history):
            return jsonify({'error': f'Cannot delete {count} exchanges, only {len(history)} available'}), 400
        
        # Remove the last N exchanges
        for _ in range(count):
            if history:
                history.pop()
        
        # Update the character's conversation history directly
        character_data = character_manager.load_character(character_id)
        if not character_data:
            return jsonify({'error': 'Character not found'}), 404
        
        character_data['conversation_history'] = history
        character_manager.save_character(character_data)
        
        return jsonify({
            'success': True,
            'message': f'{count} exchange(s) deleted successfully',
            'remaining_exchanges': len(history),
            'deleted_count': count
        })
        
    except Exception as e:
        return jsonify({'error': f'Failed to delete exchanges: {str(e)}'}), 500


@app.route('/api/characters/<character_id>/export')
def export_character(character_id):
    """Export character as downloadable JSON using framework."""
    if not character_manager:
        return jsonify({'error': 'Character manager not initialized'}), 500
    
    try:
        character_data = character_manager.export_character(character_id)
        if not character_data:
            return jsonify({'error': 'Character not found'}), 404
        
        # Return character data for download
        response = jsonify(character_data)
        response.headers['Content-Disposition'] = f'attachment; filename="{character_id}.json"'
        return response
        
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/characters/import', methods=['POST'])
def import_character():
    """Import character from uploaded JSON using framework."""
    if not character_manager:
        return jsonify({'error': 'Character manager not initialized'}), 500
    
    try:
        data = request.get_json()
        character_data = data.get('character_data')
        
        if not character_data:
            return jsonify({'error': 'No character data provided'}), 400
        
        # Import character using framework
        character_id = character_manager.import_character(character_data)
        
        return jsonify({
            'success': True,
            'message': f'Character "{character_data["name"]}" imported successfully',
            'character_id': character_id
        })
        
    except CharacterError as e:
        return jsonify({'error': str(e)}), 400
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/context', methods=['PUT'])
def update_context():
    """Update the conversation context using framework."""
    if not prompt_manager:
        return jsonify({'error': 'Chat not initialized'}), 500
    
    try:
        data = request.get_json()
        new_context = data.get('context', '')
        
        prompt_manager.update_component("context", new_context)
        
        return jsonify({
            'success': True,
            'message': 'Context updated'
        })
    
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/personality', methods=['PUT'])
def update_personality():
    """Update the AI personality using framework."""
    if not prompt_manager:
        return jsonify({'error': 'Chat not initialized'}), 500
    
    try:
        data = request.get_json()
        personality_type = data.get('personality', 'helpful')
        
        # Get personality content from predefined types
        from dynamic_ai_framework.components.basic import create_personality_component
        personality_component = create_personality_component(personality_type)
        
        prompt_manager.update_component("personality", personality_component.content)
        
        return jsonify({
            'success': True,
            'message': f'Personality changed to {personality_type}'
        })
    
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/config')
def get_configuration():
    """Get current framework configuration."""
    try:
        config = get_config()
        return jsonify({
            'conversation': {
                'max_history_entries': config.conversation.max_history_entries,
                'summary_threshold': config.conversation.summary_threshold,
                'recent_exchanges_count': config.conversation.recent_exchanges_count,
                'compression_threshold': config.conversation.compression_threshold,
                'max_total_exchanges': config.conversation.max_total_exchanges,
                'compression_ratio': config.conversation.compression_ratio
            },
            'text_processing': {
                'tokens_per_char_ratio': config.text_processing.tokens_per_char_ratio,
                'trigger_preview_length': config.text_processing.trigger_preview_length
            },
            'server': {
                'host': config.server.host,
                'port': config.server.port,
                'debug': config.server.debug,
                'auto_open_browser': config.server.auto_open_browser,
                'browser_delay_seconds': config.server.browser_delay_seconds
            },
            'external_services': {
                'ollama_timeout_seconds': config.external_services.ollama_timeout_seconds,
                'default_temperature': config.external_services.default_temperature,
                'max_retries': config.external_services.max_retries
            },
            'ui': {
                'max_component_display_length': config.ui.max_component_display_length,
                'component_description_max_length': config.ui.component_description_max_length,
                'auto_refresh_interval_ms': config.ui.auto_refresh_interval_ms,
                'show_debug_info': config.ui.show_debug_info
            }
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500


@app.route('/api/config', methods=['PUT'])
def update_configuration():
    """Update framework configuration."""
    try:
        data = request.get_json()
        config_manager = get_config_manager()
        
        # Update configuration with provided values
        config_manager.update_config(**data)
        
        # Save to file
        config_manager.save_config()
        
        return jsonify({
            'success': True,
            'message': 'Configuration updated successfully'
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500


# Memory configuration endpoints removed - settings now handled at component level

@app.route('/api/config/reset', methods=['POST'])
def reset_config():
    """Reset configuration to defaults."""
    try:
        from dynamic_ai_framework.config import get_config_manager
        config_manager = get_config_manager()
        config_manager.reset_to_defaults()
        config_manager.save_config()
        
        return jsonify({
            'message': 'Configuration reset to defaults successfully',
            'config': {
                'conversation': {
                    'max_history_entries': config_manager.get_config().conversation.max_history_entries,
                    'summary_threshold': config_manager.get_config().conversation.summary_threshold,
                    'recent_exchanges_count': config_manager.get_config().conversation.recent_exchanges_count,
                    'compression_threshold': config_manager.get_config().conversation.compression_threshold,
                    'max_total_exchanges': config_manager.get_config().conversation.max_total_exchanges,
                    'compression_ratio': config_manager.get_config().conversation.compression_ratio
                },
                'text_processing': {
                    'tokens_per_char_ratio': config_manager.get_config().text_processing.tokens_per_char_ratio,
                    'trigger_preview_length': config_manager.get_config().text_processing.trigger_preview_length
                },
                'server': {
                    'host': config_manager.get_config().server.host,
                    'port': config_manager.get_config().server.port,
                    'debug': config_manager.get_config().server.debug,
                    'auto_open_browser': config_manager.get_config().server.auto_open_browser,
                    'browser_delay_seconds': config_manager.get_config().server.browser_delay_seconds
                }
            }
        })
    except Exception as e:
        logger.error(f"Error resetting configuration: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/test-script', methods=['POST'])
def test_script():
    """Test a script with sample data."""
    try:
        data = request.get_json()
        script = data.get('script', '').strip()
        
        if not script:
            return jsonify({'error': 'No script provided'}), 400
        
        # Get sample data for testing
        sample_user_input = data.get('user_input', 'Hello, how are you?')
        sample_ai_response = data.get('ai_response', 'I am doing well, thank you!')
        sample_current_content = data.get('current_content', 'Sample current content')
        
        # Get component contents for testing
        component_contents = {}
        if prompt_manager:
            component_contents = {
                name: comp.content 
                for name, comp in prompt_manager.structure.components.items()
            }
        else:
            # Provide sample component contents if no manager is available
            component_contents = {
                'personality': 'You are a helpful AI assistant.',
                'memory': 'This is the beginning of our conversation.',
                'context': 'General conversation'
            }
        
        # Import and use the script executor
        from dynamic_ai_framework.core.scripting import SafeScriptExecutor
        
        # Create executor with framework access if available
        executor = SafeScriptExecutor(
            llm_provider=llm_provider,
            conversation_history=prompt_manager.history if prompt_manager else None,
            conversation_summarizer=prompt_manager.summarizer if prompt_manager else None,
            event_system=event_system
        )
        
        # Execute the script
        result = executor.execute_script(
            script=script,
            component_contents=component_contents,
            user_input=sample_user_input,
            ai_response=sample_ai_response,
            current_content=sample_current_content
        )
        
        return jsonify({
            'success': True,
            'result': str(result),
            'message': 'Script executed successfully',
            'sample_data': {
                'user_input': sample_user_input,
                'ai_response': sample_ai_response,
                'current_content': sample_current_content,
                'available_components': list(component_contents.keys())
            }
        })
        
    except Exception as e:
        error_msg = str(e)
        return jsonify({
            'success': False,
            'error': error_msg,
            'traceback': traceback.format_exc()
        }), 200  # Return 200 so frontend can handle the error display


@app.route('/api/auto-save-settings', methods=['POST'])
def auto_save_settings():
    """Auto-save settings and apply memory/framework configuration changes."""
    try:
        data = request.get_json()
        
        # Memory configuration is now handled at component level - skipping auto-save memory settings
        
        # Apply framework configuration if provided
        if 'frameworkConfig' in data:
            framework_config = data['frameworkConfig']
            
            # Validate and update framework configuration
            config_updates = {}
            if 'maxHistory' in framework_config:
                config_updates['max_history_entries'] = int(framework_config['maxHistory'])
            if 'summaryThreshold' in framework_config:
                config_updates['summary_threshold'] = int(framework_config['summaryThreshold'])
            
            text_processing_updates = {}
            if 'tokensPerChar' in framework_config:
                text_processing_updates['tokens_per_char_ratio'] = float(framework_config['tokensPerChar'])
            
            if config_updates or text_processing_updates:
                config_manager = get_config_manager()
                if config_updates:
                    config_manager.update_config(conversation=config_updates)
                if text_processing_updates:
                    config_manager.update_config(text_processing=text_processing_updates)
                config_manager.save_config()
        
        return jsonify({
            'success': True,
            'message': 'Settings auto-saved successfully'
        })
        
    except Exception as e:
        return jsonify({'error': str(e)}), 500


if __name__ == '__main__':
    logger.info("Starting Dynamic AI Framework Web UI (New Architecture)...")
    app.run(debug=True, host='0.0.0.0', port=5000)