"""
Memory reset handler.

Handles requests to clear all memory layers.
"""
import json
from core.logger import setup_logger

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


class ResetHandler:
    """Handles memory reset/clear requests"""

    def __init__(self, sqlite_store, chroma_store):
        self.sqlite_store = sqlite_store
        self.chroma_store = chroma_store

    async def handle(self, msg) -> None:
        """Handle vi.memory.debug.reset requests - clears all three-layer memory"""
        try:
            logger.warning("[μ] Memory reset requested - clearing all three-layer memory contents")

            conn = self.sqlite_store.get_connection()
            cursor = conn.cursor()

            # Clear short-term memory
            cursor.execute("DELETE FROM short_term_memory")
            deleted_short_term = cursor.rowcount

            # Clear all identities
            cursor.execute("DELETE FROM identities")
            deleted_identities = cursor.rowcount

            # Reset sequences
            cursor.execute("DELETE FROM sqlite_sequence WHERE name IN ('short_term_memory', 'identities')")
            conn.commit()

            # Clear ChromaDB collections
            deleted_long_term = 0
            deleted_facts = 0

            long_term_collection = self.chroma_store.get_long_term_collection()
            facts_collection = self.chroma_store.get_facts_collection()

            if long_term_collection:
                deleted_long_term = long_term_collection.count()
                all_ids = long_term_collection.get()['ids']
                if all_ids:
                    long_term_collection.delete(ids=all_ids)

            if facts_collection:
                deleted_facts = facts_collection.count()
                all_ids = facts_collection.get()['ids']
                if all_ids:
                    facts_collection.delete(ids=all_ids)

            logger.warning(
                f"[μ] Memory reset completed: {deleted_short_term} short-term, "
                f"{deleted_long_term} long-term, {deleted_facts} facts, "
                f"{deleted_identities} identities cleared"
            )

            response = {
                "status": "success",
                "deleted_short_term": deleted_short_term,
                "deleted_long_term": deleted_long_term,
                "deleted_facts": deleted_facts,
                "deleted_identities": deleted_identities,
                "message": f"Cleared {deleted_short_term} short-term memories, {deleted_long_term} long-term summaries, {deleted_facts} facts, and {deleted_identities} identities"
            }
            await msg.respond(json.dumps(response).encode())

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