"""
Memory store handler.

Handles requests to store new memories in short-term memory.
"""
import json
from uuid import uuid4
from datetime import datetime
from typing import Dict, Any
from core.logger import setup_logger

logger = setup_logger('store_handler', service_name='memory_service')


class StoreHandler:
    """Handles memory store requests"""

    def __init__(self, sqlite_store):
        """
        Initialize store handler.

        Args:
            sqlite_store: SQLiteStore instance
        """
        self.sqlite_store = sqlite_store

    async def handle(self, msg) -> None:
        """
        Handle vi.memory.store requests - routes to short-term memory.

        Args:
            msg: NATS message with request payload
        """
        try:
            # Parse request payload
            payload = json.loads(msg.data.decode())

            # Extract required fields
            content = payload.get('content')
            if not content:
                logger.warning("[μ] Memory store request missing content")
                error_response = {
                    "status": "error",
                    "error": "Missing required field: content"
                }
                await msg.respond(json.dumps(error_response).encode())
                return

            # Extract optional fields
            identities = payload.get('identities', [])
            interaction_id = payload.get('interaction_id')
            modality = payload.get('modality', 'dialogue')
            metadata = payload.get('metadata', {})

            # Store in simplified short-term memory table
            memory_id = str(uuid4())
            timestamp = datetime.utcnow().isoformat()

            conn = self.sqlite_store.get_connection()
            cursor = conn.cursor()
            cursor.execute("""
            INSERT INTO short_term_memory (id, timestamp, content, identities, interaction_id, modality, metadata)
            VALUES (?, ?, ?, ?, ?, ?, ?)
            """, (
                memory_id,
                timestamp,
                content,
                json.dumps(identities) if identities else None,
                interaction_id,
                modality,
                json.dumps(metadata) if metadata else None
            ))

            conn.commit()
            logger.info(f"[μ] Stored short-term memory: '{content[:60]}...' identities={identities}")

            # Send response using NATS request-reply
            response = {
                "memory_id": memory_id,
                "status": "stored"
            }
            await msg.respond(json.dumps(response).encode())

        except Exception as e:
            logger.exception(f"[μ] Failed to store memory: {e}")
            error_response = {
                "status": "error",
                "error": str(e)
            }
            await msg.respond(json.dumps(error_response).encode())