import uuid
import re
import copy
import concurrent
import logging
import json
import threading
from datetime import datetime, timedelta
from typing import Any, Dict, Literal, Optional, List, Tuple, Union
from pydantic import ValidationError
from lightmem.configs.base import BaseMemoryConfigs
from lightmem.factory.pre_compressor.factory import PreCompressorFactory
from lightmem.factory.topic_segmenter.factory import TopicSegmenterFactory
from lightmem.factory.memory_manager.factory import MemoryManagerFactory
from lightmem.factory.text_embedder.factory import TextEmbedderFactory
from lightmem.factory.retriever.contextretriever.factory import ContextRetrieverFactory
from lightmem.factory.retriever.embeddingretriever.factory import EmbeddingRetrieverFactory
from lightmem.factory.retriever.embeddingretriever.qdrant import QdrantConfig
from lightmem.factory.memory_buffer.sensory_memory import SenMemBufferManager
from lightmem.factory.memory_buffer.short_term_memory import ShortMemBufferManager
from lightmem.memory.utils import MemoryEntry, assign_sequence_numbers_with_timestamps, save_memory_entries,convert_extraction_results_to_memory_entries,normalize_extraction_prompts,process_extraction_results
from lightmem.memory.prompts import METADATA_GENERATE_PROMPT, UPDATE_PROMPT
from lightmem.configs.logging.utils import get_logger

GLOBAL_TOPIC_IDX = 0
GLOBAL_LAST_SUMMARY_TIME = None

class MessageNormalizer:

    _SESSION_RE = re.compile(
        r'(?P<date>\d{4}[/-]\d{1,2}[/-]\d{1,2})\s*\((?P<weekday>[^)]+)\)\s*(?P<time>\d{1,2}:\d{2}(?::\d{2})?)'
    )

    def __init__(self, offset_ms: int = 1000):
        self.last_timestamp_map: Dict[str, datetime] = {}
        self.offset = timedelta(milliseconds=offset_ms)

    def _parse_session_timestamp(self, raw_ts: str) -> Tuple[datetime, str]:
        """
        Parse a session-level timestamp and return (base_datetime, weekday).
        Supports formats like "2023/05/20 (Sat) 00:44" (also accepts '-' as separator, and optional seconds).
        Raises ValueError if parsing fails.
        """
        m = self._SESSION_RE.search(raw_ts)
        if m:
            date_str = m.group('date').replace('-', '/')
            time_str = m.group('time')
            weekday = m.group('weekday')
            fmt = "%Y/%m/%d %H:%M:%S" if time_str.count(':') == 2 else "%Y/%m/%d %H:%M"
            base_dt = datetime.strptime(f"{date_str} {time_str}", fmt)
            return base_dt, weekday

        try:
            dt = datetime.fromisoformat(raw_ts)
            return dt, dt.strftime("%a")
        except Exception as e:
            raise ValueError(f"{str(e)}: Failed to parse session time format: '{raw_ts}'. Expected something like '2023/05/20 (Sat) 00:44'")

    def normalize_messages(self, messages: Any) -> List[Dict[str, Any]]:
        """
        Accepts str / dict / list[dict]:
          - If str -> treated as a single user message (if 'time_stamp' is required, use dict form)
          - If dict -> single message
          - If list -> multiple messages (each must be a dict and contain 'time_stamp')
        Returns: List[Dict] (each item is a copied and enriched message)
        """
        # Normalize input into a list
        if isinstance(messages, dict):
            messages_list = [messages]
        elif isinstance(messages, list):
            messages_list = messages
        elif isinstance(messages, str):
            raise ValueError("Please provide messages as dict or list[dict], and ensure each dict contains a 'time_stamp' field (session-level).")
        else:
            raise ValueError("messages must be dict or list[dict] (or str, but not recommended).")

        enriched_list: List[Dict[str, Any]] = []

        for msg in messages_list:
            if not isinstance(msg, dict):
                raise ValueError("Each item in messages list must be a dict.")
            raw_ts = msg.get("time_stamp")
            if not raw_ts:
                raise ValueError("Each message should contain a 'time_stamp' field (e.g., '2023/05/20 (Sat) 00:44').")

            base_dt, weekday = self._parse_session_timestamp(raw_ts)

            # Maintain incrementing time based on raw_ts as session key
            last_dt = self.last_timestamp_map.get(raw_ts)
            if last_dt is None:
                new_dt = base_dt
            else:
                new_dt = last_dt + self.offset

            self.last_timestamp_map[raw_ts] = new_dt

            enriched = copy.deepcopy(msg)
            enriched["session_time"] = raw_ts
            enriched["time_stamp"] = new_dt.isoformat(timespec="milliseconds")
            enriched["weekday"] = weekday

            enriched_list.append(enriched)

        return enriched_list


class LightMemory:
    def __init__(self, config: BaseMemoryConfigs = BaseMemoryConfigs()):
        
        """
        Initialize a LightMemory instance.

        This constructor initializes various memory-related components based on the provided configuration (`config`), 
        including the memory manager, optional pre-compressor, optional topic segmenter, text embedder, 
        and retrievers based on the configured strategies.

        This design supports flexible extension of the memory system, making it easy to integrate 
        different processing and retrieval capabilities.

        Args:
            config (BaseMemoryConfigs): The configuration object for the memory system, 
                containing initialization parameters for all submodules.

        Components initialized:
            - compressor (optional): Pre-compression model if pre_compress=True
            - segmenter (optional): Topic segmentation model if topic_segment=True
            - manager: Memory management model for metadata generation and text summarization
            - text_embedder (optional): Text embedding model if index_strategy is 'embedding' or 'hybrid'
            - retrieve_strategy (optional): Retrieval strategy ('context', 'embedding', or 'hybrid')
            - context_retriever (optional): Context-based retriever if retrieve_strategy is 'context' or 'hybrid'
            - embedding_retriever (optional): Embedding-based retriever if retrieve_strategy is 'embedding' or 'hybrid'
            - graph (optional): Graph memory store if graph_mem is enabled

        Note:
            - Multimodal embedder initialization is currently commented out
            - Graph memory initialization is conditional on graph_mem configuration
        """
        if config.logging is not None:
            config.logging.apply()
        
        self.logger = get_logger("LightMemory")
        self.logger.info("Initializing LightMemory with provided configuration")
        self.token_stats = {
            "add_memory_calls": 0,
            "add_memory_prompt_tokens": 0,
            "add_memory_completion_tokens": 0,
            "add_memory_total_tokens": 0,
            "update_calls": 0,
            "update_prompt_tokens": 0,
            "update_completion_tokens": 0,
            "update_total_tokens": 0,
            "embedding_calls": 0,
            "embedding_total_tokens": 0,
            "summarize_calls": 0,
            "summarize_prompt_tokens": 0,
            "summarize_completion_tokens": 0,
            "summarize_total_tokens": 0,
            "embedding_calls": 0,
            "embedding_total_tokens": 0,
        }
        self.logger.info("Token statistics tracking initialized")
        
        self.config = config
        self.compressor = None
        self.segmenter = None
        if self.config.pre_compress:
            self.logger.info("Initializing pre-compressor")
            self.compressor = PreCompressorFactory.from_config(self.config.pre_compressor)
        if self.config.topic_segment:
            self.logger.info("Initializing topic segmenter")
            self.segmenter = TopicSegmenterFactory.from_config(self.config.topic_segmenter, self.config.precomp_topic_shared, self.compressor)
            self.senmem_buffer_manager = SenMemBufferManager(max_tokens=self.segmenter.buffer_len, tokenizer=self.segmenter.tokenizer)
        self.logger.info("Initializing memory manager")
        self.manager = MemoryManagerFactory.from_config(self.config.memory_manager)
        self.shortmem_buffer_manager = ShortMemBufferManager(max_tokens = 512, tokenizer=getattr(self.manager, "tokenizer", self.manager.config.model))
        if self.config.index_strategy == 'embedding' or self.config.index_strategy == 'hybrid':
            self.logger.info("Initializing text embedder")
            self.text_embedder = TextEmbedderFactory.from_config(self.config.text_embedder)
        # if self.config.multimodal_embedder:
        self.retrieve_strategy = self.config.retrieve_strategy
        if self.retrieve_strategy in ["context", "hybrid"]:
            self.logger.info("Initializing context retriever")
            self.context_retriever = ContextRetrieverFactory.from_config(self.config.context_retriever)
        if self.retrieve_strategy in ["embedding", "hybrid"]:
            self.logger.info("Initializing embedding retriever")
            self.embedding_retriever = EmbeddingRetrieverFactory.from_config(self.config.embedding_retriever)
            if hasattr(self.config, 'summary_retriever') and self.config.summary_retriever is not None:
                self.logger.info("Initializing summary retriever")
                self.summary_retriever = EmbeddingRetrieverFactory.from_config(self.config.summary_retriever)
        if self.config.graph_mem:
            from .graph import GraphMem
            self.logger.info("Initializing graph memory")
            self.graph = GraphMem(self.config.graph_mem)
        self.logger.info("LightMemory initialization completed successfully")

    @classmethod
    def from_config(cls, config: Dict[str,Any]):
        try:
            configs = BaseMemoryConfigs(**config)
        except ValidationError as e:
            print(f"Configuration validation error: {e}")
            raise
        return cls(configs)
    
    
    def add_memory(
        self,
        messages,
        METADATA_GENERATE_PROMPT: Optional[Union[str, Dict[str, str]]] = None,
        *,
        force_segment: bool = False, 
        force_extract: bool = False
    ):
        """
        Add new memory entries from message history.

        This method serves as the main pipeline for constructing new memory units from 
        incoming messages. It performs message normalization, optional pre-compression,
        segmentation, and knowledge extraction to produce structured memory entries.

        The process is as follows:
          1. Normalize input messages with standardized timestamps and session tracking.
          2. Optionally compress messages using the pre-defined compression model (if enabled).
          3. If topic segmentation is enabled, split messages into coherent segments and add them to the sentence-level buffer.
          4. Trigger memory extraction based on configured thresholds or forced flags.
          5. Optionally perform metadata summarization using an external model if enabled.
          6. Convert extracted results into `MemoryEntry` objects and update memory storage
             (either in online or offline mode depending on configuration).

        Args:
            messages (dict or List[dict]): Input message(s) to process.
            METADATA_GENERATE_PROMPT: Custom prompt(s) for extraction. Supports multiple formats:
                - str: Legacy format for flat mode (single factual prompt)
                    Example: METADATA_GENERATE_PROMPT="Your extraction prompt..."
                - dict: New format supporting multiple perspectives
                    For flat mode: {"factual": "..."}
                    For event mode: {"factual": "...", "relational": "..."}
                - None: Use default prompts based on self.config.extraction_mode
            force_segment (bool, optional): If True, forces segmentation regardless of buffer conditions.
            force_extract (bool, optional): If True, forces memory extraction even if thresholds are not met.

        Returns:
            dict: A dictionary containing the intermediate results of the memory addition pipeline.
                  Typically includes:
                    - `"add_input_prompt"`: List of input prompts used for metadata generation (if enabled)
                    - `"add_output_prompt"`: Corresponding output results from metadata generation
                    - `"api_call_nums"`: Number of API calls made for extraction/summarization
                    - (In early termination cases) A segmentation result dict with keys such as
                      `"triggered"`, `"cut_index"`, `"boundaries"`, and `"emitted_messages"`

        Notes:
            - If `self.config.pre_compress` is True, messages will first be token-compressed before segmentation.
            - If `self.config.topic_segment` is disabled, the function returns early with segmentation info only.
            - Memory extraction results are wrapped into `MemoryEntry` objects containing timestamps,
              weekdays, and extracted factual content.
            - Depending on `self.config.update`, the function triggers either online or offline memory updates.
        """
        extract_prompts = normalize_extraction_prompts(
            prompts=METADATA_GENERATE_PROMPT,
            extraction_mode=self.config.extraction_mode,
            logger=self.logger
        )
        
        call_id = f"add_memory_{datetime.now().strftime('%Y%m%d_%H%M%S_%f')}"
        self.logger.info(f"========== START {call_id} ==========")
        self.logger.info(f"force_segment={force_segment}, force_extract={force_extract}")
        result = {
            "add_input_prompt": [],
            "add_output_prompt": [],
            "api_call_nums": 0
        }
        self.logger.debug(f"[{call_id}] Raw input type: {type(messages)}")
        if isinstance(messages, list):
            self.logger.debug(f"[{call_id}] Raw input sample: {json.dumps(messages)}")
        normalizer = MessageNormalizer(offset_ms=500)
        msgs = normalizer.normalize_messages(messages)
        self.logger.debug(f"[{call_id}] Normalized messages sample: {json.dumps(msgs)}")
        if self.config.pre_compress:
            if hasattr(self.compressor, "tokenizer") and self.compressor.tokenizer is not None:
                args = (msgs, self.compressor.tokenizer)
            elif self.config.topic_segment and hasattr(self.segmenter, "tokenizer") and self.segmenter.tokenizer is not None:
                args = (msgs, self.segmenter.tokenizer)
            else:
                args = (msgs,)
            # fixed: empty 'content' in the 'messages' of 'compress(*args)'
            compressed_messages = self.compressor.compress(*args)
            cfg = getattr(self.compressor, "config", None)
            target_rate = None
            if cfg is not None:
                if hasattr(cfg, 'entropy_config') and isinstance(cfg.entropy_config, dict):
                    target_rate = cfg.entropy_config.get('compress_rate')
                elif hasattr(cfg, 'compress_config') and isinstance(cfg.compress_config, dict):
                    target_rate = cfg.compress_config.get('rate')
            self.logger.info(f"[{call_id}] Target compression rate: {target_rate}")
            self.logger.debug(f"[{call_id}] Compressed messages sample: {json.dumps(compressed_messages)}")
        else:
            compressed_messages = msgs
            self.logger.info(f"[{call_id}] Pre-compression disabled, using normalized messages")
        
        if not self.config.topic_segment:
            # TODO:
            self.logger.info(f"[{call_id}] Topic segmentation disabled, returning emitted messages")
            return {
                "triggered": True,
                "cut_index": len(msgs),
                "boundaries": [0, len(msgs)],
                "emitted_messages": msgs,
                "carryover_size": 0,
            }

        all_segments = self.senmem_buffer_manager.add_messages(compressed_messages, self.segmenter, self.text_embedder)

        if force_segment:
            all_segments = self.senmem_buffer_manager.cut_with_segmenter(self.segmenter, self.text_embedder, force_segment)
        
        if not all_segments:
            self.logger.debug(f"[{call_id}] No segments generated, returning empty result")
            return result # TODO

        self.logger.info(f"[{call_id}] Generated {len(all_segments)} segments")
        self.logger.debug(f"[{call_id}] Segments sample: {json.dumps(all_segments)}")

        extract_trigger_num, extract_list = self.shortmem_buffer_manager.add_segments(all_segments, self.config.messages_use, force_extract)

        if extract_trigger_num == 0:
            self.logger.debug(f"[{call_id}] Extraction not triggered, returning result")
            return result # TODO 
        
        global GLOBAL_TOPIC_IDX
        topic_id_mapping = []
        for api_call_segments in extract_list:
            api_call_topic_ids = []
            for topic_segment in api_call_segments:
                api_call_topic_ids.append(GLOBAL_TOPIC_IDX)
                GLOBAL_TOPIC_IDX += 1
            topic_id_mapping.append(api_call_topic_ids)
        self.logger.debug(f"topic_id_mapping: {topic_id_mapping}")
        self.logger.info(f"[{call_id}] Assigned global topic IDs: total={sum(len(x) for x in topic_id_mapping)}, mapping={topic_id_mapping}")
        self.logger.info(f"[{call_id}] Extraction triggered {extract_trigger_num} times, extract_list length: {len(extract_list)}")
        extract_list, timestamps_list, weekday_list, speaker_list, topic_id_map = assign_sequence_numbers_with_timestamps(extract_list, offset_ms=500, topic_id_mapping=topic_id_mapping)
        self.logger.debug(f"[{call_id}] Extract list sample: {json.dumps(extract_list)}")
        max_source_ids = [sum(1 for seg in batch for msg in seg if msg.get("role") == "user") - 1 for batch in extract_list]
        self.logger.info(f"[{call_id}] Batch max_source_ids: {max_source_ids}")
        if self.config.metadata_generate and self.config.text_summary:
            self.logger.info(f"[{call_id}] Starting metadata generation")
            extracted_results = self.manager.meta_text_extract(
                extract_list=extract_list,
                messages_use=self.config.messages_use,
                topic_id_mapping=topic_id_mapping,
                extraction_mode=self.config.extraction_mode,
                custom_prompts=extract_prompts  
            )
            # ============ API token Consumption ============
            process_extraction_results(
                extracted_results=extracted_results,
                token_stats=self.token_stats,
                result_dict=result,
                call_id=call_id,
                logger=self.logger
            )
            self.logger.info(f"[{call_id}] Metadata generation completed with {result['api_call_nums']} API calls")

        memory_entries = convert_extraction_results_to_memory_entries(
            extracted_results=extracted_results,
            timestamps_list=timestamps_list,
            weekday_list=weekday_list,
            speaker_list=speaker_list,
            topic_id_map=topic_id_map,
            max_source_ids=max_source_ids,
            logger=self.logger
        )
        self.logger.info(f"[{call_id}] Created {len(memory_entries)} MemoryEntry objects")
        for i, mem in enumerate(memory_entries):
            self.logger.debug(f"[{call_id}] MemoryEntry[{i}]: time={mem.time_stamp}, weekday={mem.weekday}, speaker_id={mem.speaker_id}, speaker_name={mem.speaker_name}, topic_id={mem.topic_id}, memory={mem.memory}")

        if self.config.update == "online":
            self.online_update(memory_entries)
        elif self.config.update == "offline":
            self.offline_update(memory_entries)
        
        self.logger.info(
            f"[{call_id}] Cumulative token stats - "
            f"Total API calls: {self.token_stats['add_memory_calls']}, "
            f"Total tokens: {self.token_stats['add_memory_total_tokens']}"
        )
        return result

    def online_update(self, memory_list: List):
        return None

    def offline_update(self, memory_list: List, construct_update_queue_trigger: bool = False, offline_update_trigger: bool = False):
        call_id = f"offline_update_{datetime.now().strftime('%Y%m%d_%H%M%S_%f')}"
        self.logger.info(f"========== START {call_id} ==========")
        self.logger.info(f"[{call_id}] Received {len(memory_list)} memory entries")
        self.logger.info(f"[{call_id}] construct_update_queue_trigger={construct_update_queue_trigger}, offline_update_trigger={offline_update_trigger}")

        if self.config.index_strategy in ["context", "hybrid"]:
            self.logger.info(f"[{call_id}] Saving memory entries to file (strategy: {self.config.index_strategy})")
            save_memory_entries(memory_list, "memory_entries.json")

        if self.config.index_strategy in ["embedding", "hybrid"]:
            inserted_count = 0
            self.logger.info(f"[{call_id}] Starting embedding and insertion to vector database")
            embeddings = self.text_embedder.embed([mem_obj.memory for mem_obj in memory_list]) if memory_list else []
            batched_vectors = []
            batched_payloads = []
            batched_ids = []
            for mem_obj, embedding_vector in zip(memory_list, embeddings):
                ids = mem_obj.id
                while self.embedding_retriever.exists(ids):
                    ids = str(uuid.uuid4())
                    mem_obj.id = ids
                payload = {
                    "time_stamp": mem_obj.time_stamp,
                    "float_time_stamp": mem_obj.float_time_stamp,
                    "weekday": mem_obj.weekday,
                    "topic_id": mem_obj.topic_id,
                    "topic_summary": mem_obj.topic_summary,
                    "category": mem_obj.category,
                    "subcategory": mem_obj.subcategory,
                    "memory_class": mem_obj.memory_class,
                    "memory": mem_obj.memory,
                    "original_memory": mem_obj.original_memory,
                    "compressed_memory": mem_obj.compressed_memory,
                    "speaker_id": mem_obj.speaker_id,
                    "speaker_name": mem_obj.speaker_name,
                    "consolidated": mem_obj.consolidated,
                }
                batched_vectors.append(embedding_vector)
                batched_payloads.append(payload)
                batched_ids.append(ids)
                inserted_count += 1

            if batched_vectors:
                self.embedding_retriever.insert(
                    vectors=batched_vectors,
                    payloads=batched_payloads,
                    ids=batched_ids,
                )

            self.logger.info(f"[{call_id}] Successfully inserted {inserted_count} entries to vector database")
            if construct_update_queue_trigger:
                self.logger.info(f"[{call_id}] Triggering update queue construction")
                self.construct_update_queue_all_entries(
                    top_k=20,
                    keep_top_n=10
                )
            
            if offline_update_trigger:
                self.logger.info(f"[{call_id}] Triggering offline update for all entries")
                self.offline_update_all_entries(
                    update_sim_threshold = 0.8
                )

    def construct_update_queue_all_entries(self, top_k: int = 20, keep_top_n: int = 10, max_workers: int = 8):

        """
        Offline update all entries in parallel using multithreading.
        Each entry updates its own update_queue based on entries with earlier timestamps.

        Args:
            top_k (int): Number of nearest neighbors to consider for each entry.
            keep_top_n (int): Number of top entries to keep in update_queue.
            max_workers (int): Maximum number of threads to use.
        """
        call_id = f"construct_queue_{datetime.now().strftime('%Y%m%d_%H%M%S_%f')}"
        self.logger.info(f"========== START {call_id} ==========")
        self.logger.info(f"[{call_id}] Parameters: top_k={top_k}, keep_top_n={keep_top_n}, max_workers={max_workers}")
        all_entries = self.embedding_retriever.get_all()
        self.logger.info(f"[{call_id}] Retrieved {len(all_entries)} entries from vector database")
        if not all_entries:
            self.logger.warning(f"[{call_id}] No entries found in database, skipping queue construction")
            self.logger.info(f"========== END {call_id} ==========")
            return
        updated_count = 0
        skipped_count = 0
        nonempty_queue_count = 0
        empty_queue_count = 0
        lock = threading.Lock()
        write_lock = threading.Lock()
        def _update_queue_construction(entry):
            nonlocal updated_count, skipped_count, nonempty_queue_count, empty_queue_count
            eid = entry["id"]
            payload = entry["payload"]
            vec = entry.get("vector")
            ts = payload.get("float_time_stamp", None)
            
            if vec is None or ts is None:
                self.logger.debug(f"[{call_id}] Skipping entry {eid}: missing vector={vec is None}, float_time_stamp={ts is None} ({ts})")
                with lock:
                    skipped_count += 1
                return

            hits = self.embedding_retriever.search(
                query_vector=vec,
                limit=top_k,
                filters={"float_time_stamp": {"lte": ts}}
            )

            candidates = []
            for h in hits:
                hid = h["id"]
                if hid == eid:
                    continue
                candidates.append({"id": hid, "score": h.get("score")})

            candidates.sort(key=lambda x: x["score"], reverse=True)
            update_queue = candidates[:keep_top_n]

            new_payload = dict(payload)
            new_payload["update_queue"] = update_queue

            if update_queue:
                with lock:
                    nonempty_queue_count += 1
                self.logger.debug(f"[{call_id}] Entry {eid} update_queue length={len(update_queue)} top_candidates=" + str(update_queue[:3]))
            else:
                with lock:
                    empty_queue_count += 1
                self.logger.debug(f"[{call_id}] Entry {eid} has no candidates after filtering (hits may be only itself)")

            with write_lock:
                self.embedding_retriever.update(vector_id=eid, vector=vec, payload=new_payload)

            with lock:
                updated_count += 1
        self.logger.info(f"[{call_id}] Starting parallel queue construction with {max_workers} workers")

        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
            executor.map(_update_queue_construction, all_entries)
        self.logger.info(
            f"[{call_id}] Queue construction completed: {updated_count} updated, {skipped_count} skipped, "
            f"nonempty_queues={nonempty_queue_count}, empty_queues={empty_queue_count}"
        )
        self.logger.info(f"========== END {call_id} ==========")

    def offline_update_all_entries(self, score_threshold: float = 0.9, max_workers: int = 5):
        """
        Perform offline updates for all entries based on their update_queue, in parallel.

        Args:
            score_threshold (float): Minimum similarity score for considering update candidates.
            max_workers (int): Maximum number of worker threads.
        """
        call_id = f"offline_update_all_{datetime.now().strftime('%Y%m%d_%H%M%S_%f')}"
        
        self.logger.info(f"========== START {call_id} ==========")
        self.logger.info(f"[{call_id}] Parameters: score_threshold={score_threshold}, max_workers={max_workers}")
        all_entries = self.embedding_retriever.get_all()
        self.logger.info(f"[{call_id}] Retrieved {len(all_entries)} entries from vector database")
        if not all_entries:
            self.logger.warning(f"[{call_id}] No entries found in database, skipping offline update")
            self.logger.info(f"========== END {call_id} ==========")
            return
        processed_count = 0
        updated_count = 0
        deleted_count = 0
        skipped_count = 0
        lock = threading.Lock()
        write_lock = threading.Lock()
        update_token_stats = {
            "calls": 0,
            "prompt_tokens": 0,
            "completion_tokens": 0,
            "total_tokens": 0
        }
        token_lock = threading.Lock()
        def update_entry(entry):
            nonlocal processed_count, updated_count, deleted_count, skipped_count
            
            eid = entry["id"]
            payload = entry["payload"]

            candidate_sources = []
            for other in all_entries:
                update_queue = other["payload"].get("update_queue", [])
                for candidate in update_queue:
                    if candidate["id"] == eid and candidate["score"] >= score_threshold:
                        candidate_sources.append(other)
                        break

            if not candidate_sources:
                with lock:
                    skipped_count += 1
                return

            with lock:
                processed_count += 1

            updated_entry = self.manager._call_update_llm(UPDATE_PROMPT, entry, candidate_sources)

            if updated_entry is None:
                return
            # ====== token consumption ======
            usage = updated_entry["usage"]
            with token_lock:
                update_token_stats["calls"] += 1
                update_token_stats["prompt_tokens"] += usage.get("prompt_tokens", 0)
                update_token_stats["completion_tokens"] += usage.get("completion_tokens", 0)
                update_token_stats["total_tokens"] += usage.get("total_tokens", 0)
                
            self.logger.debug(
                f"[{call_id}] Update LLM call for {eid} - "
                f"Tokens: {usage.get('total_tokens', 0)}"
            )
            # ==================== token consumption ====================
            action = updated_entry.get("action")
            if action == "delete":
                with write_lock:
                    self.embedding_retriever.delete(eid)
                with lock:
                    deleted_count += 1
                self.logger.debug(f"[{call_id}] Deleted entry: {eid}")
            elif action == "update":
                new_payload = dict(payload)
                new_payload["memory"] = updated_entry.get("new_memory")
                vector = entry.get("vector")
                with write_lock:
                    self.embedding_retriever.update(vector_id=eid, vector=vector, payload=new_payload)
                with lock:
                    updated_count += 1
                self.logger.debug(f"[{call_id}] Updated entry: {eid}")
        self.logger.info(f"[{call_id}] Starting parallel offline update with {max_workers} workers")
        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
            executor.map(update_entry, all_entries)
        with lock:
            self.token_stats["update_calls"] += update_token_stats["calls"]
            self.token_stats["update_prompt_tokens"] += update_token_stats["prompt_tokens"]
            self.token_stats["update_completion_tokens"] += update_token_stats["completion_tokens"]
            self.token_stats["update_total_tokens"] += update_token_stats["total_tokens"]    
        self.logger.info(f"[{call_id}] Offline update completed:")
        self.logger.info(f"[{call_id}]   - Processed: {processed_count} entries")
        self.logger.info(f"[{call_id}]   - Updated: {updated_count} entries")
        self.logger.info(f"[{call_id}]   - Deleted: {deleted_count} entries")
        self.logger.info(f"[{call_id}]   - Skipped (no candidates): {skipped_count} entries")
        self.logger.info(
            f"[{call_id}]   - Update API calls: {update_token_stats['calls']}, "
            f"Total tokens: {update_token_stats['total_tokens']}"
        )
        self.logger.info(f"========== END {call_id} ==========")
    
    def retrieve(self, query: str, limit: int = 10, filters: Optional[dict] = None) -> list[str]:
        """
        Retrieve relevant entries and return them as formatted strings.

        Args:
            query (str): The natural language query string.
            limit (int, optional): Number of results to return. Defaults to 10.
            filters (dict, optional): Optional filters to narrow down the search. Defaults to None.

        Returns:
            list[str]: A list of formatted strings containing time_stamp, weekday, and memory.
        """
        call_id = f"retrieve_{datetime.now().strftime('%Y%m%d_%H%M%S_%f')}"
        
        self.logger.info(f"========== START {call_id} ==========")
        self.logger.info(f"[{call_id}] Query: {query}")
        self.logger.info(f"[{call_id}] Parameters: limit={limit}, filters={filters}")
        self.logger.debug(f"[{call_id}] Generating embedding for query")
        query_vector = self.text_embedder.embed(query)
        self.logger.debug(f"[{call_id}] Query embedding dimension: {len(query_vector)}")
        self.logger.info(f"[{call_id}] Searching vector database")
        results = self.embedding_retriever.search(
            query_vector=query_vector,
            limit=limit,
            filters=filters,
            return_full=True,
        )
        self.logger.info(f"[{call_id}] Found {len(results)} results")
        formatted_results = []
        for r in results:
            payload = r.get("payload", {})
            time_stamp = payload.get("time_stamp", "")
            weekday = payload.get("weekday", "")
            memory = payload.get("memory", "")
            formatted_results.append(f"{time_stamp} {weekday} {memory}")
            
        result_string = "\n".join(formatted_results)
        self.logger.info(f"[{call_id}] Formatted {len(formatted_results)} results into output string")
        self.logger.debug(f"[{call_id}] Output string length: {len(result_string)} characters")
        self.logger.info(f"========== END {call_id} ==========")
        return result_string

    def get_token_statistics(self):
        embedder_stats = {"total_calls": 0, "total_tokens": None}
        if hasattr(self, 'text_embedder') and hasattr(self.text_embedder, 'get_stats'):
            embedder_stats = self.text_embedder.get_stats()
        
        stats = {
            "summary": {
                "total_llm_calls": self.token_stats["add_memory_calls"] + self.token_stats["update_calls"] + self.token_stats["summarize_calls"],
                "total_llm_tokens": self.token_stats["add_memory_total_tokens"] + self.token_stats["update_total_tokens"] + self.token_stats["summarize_total_tokens"],
                "total_embedding_calls": embedder_stats["total_calls"],
                "total_embedding_tokens": embedder_stats["total_tokens"],
            },
            "llm": {
                "add_memory": {
                    "calls": self.token_stats["add_memory_calls"],
                    "prompt_tokens": self.token_stats["add_memory_prompt_tokens"],
                    "completion_tokens": self.token_stats["add_memory_completion_tokens"],
                    "total_tokens": self.token_stats["add_memory_total_tokens"],
                },
                "update": {
                    "calls": self.token_stats["update_calls"],
                    "prompt_tokens": self.token_stats["update_prompt_tokens"],
                    "completion_tokens": self.token_stats["update_completion_tokens"],
                    "total_tokens": self.token_stats["update_total_tokens"],
                },
                "summarize": {
                "calls": self.token_stats["summarize_calls"],
                "prompt_tokens": self.token_stats["summarize_prompt_tokens"],
                "completion_tokens": self.token_stats["summarize_completion_tokens"],
                "total_tokens": self.token_stats["summarize_total_tokens"],
                },
            },
            "embedding": {
                "total_calls": embedder_stats["total_calls"],
                "total_tokens": embedder_stats["total_tokens"],
                "note": "Includes topic segmentation + memory indexing. Local models show None for tokens."
            }
        }
        
        return stats
    
    def summarize(
        self,
        SUMMARY_PROMPT: Optional[str] = None,
        *,
        time_window: int = 3600,
        process_all: bool = False,
        enable_cross_event: bool = True,
        retrieval_scope: Literal["global", "historical"] = "global",
        top_k_seeds: int = 15,
    ) -> Dict:
        from lightmem.memory.utils import (
            initialize_time_pointer,
            get_window_entries,
            mark_entries_and_get_next_time,
            check_has_more_entries,
            retrieve_supplementary_entries,
            format_entries_for_prompt,
            call_summary_llm,
            store_summary,
            build_summary_item,
            build_single_result,
            build_batch_result,
            build_empty_result
        )
        global GLOBAL_LAST_SUMMARY_TIME
        
        call_id = f"summarize_{'all' if process_all else 'once'}_{datetime.now().strftime('%Y%m%d_%H%M%S_%f')}"
        self.logger.info(f"========== START {call_id} ==========")
        if not self.summary_retriever:
            raise ValueError("Summarization not enabled. Set 'summary_collection_name' in config.")
        summaries = [] if process_all else None
        total_entries = 0 if process_all else None
        iteration = 0
        while True:
            iteration += 1
            self.logger.info(f"[{call_id}] Iteration {iteration}")
            if GLOBAL_LAST_SUMMARY_TIME is None:
                GLOBAL_LAST_SUMMARY_TIME = initialize_time_pointer(
                    retriever=self.embedding_retriever,
                    call_id=call_id,
                    logger=self.logger
                )
                if GLOBAL_LAST_SUMMARY_TIME is None:
                    return build_empty_result(process_all)
            Cbuf, has_more, new_time = get_window_entries(
                retriever=self.embedding_retriever,
                current_time=GLOBAL_LAST_SUMMARY_TIME,
                time_window=time_window,
                call_id=call_id,
                logger=self.logger
            )
            if Cbuf is None:
                if new_time is not None:
                    GLOBAL_LAST_SUMMARY_TIME = new_time
                if process_all:
                    if has_more:
                        continue
                    else:
                        break
                else:
                    return build_empty_result(process_all, has_more=has_more)
            self.logger.info(f"[{call_id}] Processing {len(Cbuf)} entries")
            Sk = []
            if enable_cross_event:
                retrieval_filters = None
                if retrieval_scope == "historical":
                    retrieval_filters = {
                        "float_time_stamp": {"lt": Cbuf[0]["payload"]["float_time_stamp"]}
                    }
                Sk = retrieve_supplementary_entries(
                    buffer_entries=Cbuf,
                    retriever=self.embedding_retriever,
                    text_embedder=self.text_embedder,
                    top_k=top_k_seeds,
                    retrieval_scope=retrieval_scope,
                    additional_filters=retrieval_filters,
                    logger=self.logger
                )
                self.logger.debug(f"[{call_id}] Retrieved {len(Sk)} seeds")
            has_entry_type = any(e["payload"].get("entry_type") for e in Cbuf)
            buffer_text = format_entries_for_prompt(Cbuf, include_type_tag=has_entry_type)
            supplementary_text = format_entries_for_prompt(Sk, include_type_tag=has_entry_type)
            time_range_str = f"{Cbuf[0]['payload']['time_stamp']} - {Cbuf[-1]['payload']['time_stamp']}"
            speakers = list(set(
                e["payload"].get("speaker_name") or e["payload"].get("speaker_id") or "?"
                for e in Cbuf
            ))
            summary_text = call_summary_llm(
                manager=self.manager,
                buffer_text=buffer_text,
                supplementary_text=supplementary_text,
                time_range=time_range_str,
                speakers=speakers,
                custom_prompt=SUMMARY_PROMPT,
                token_stats=self.token_stats,
                logger=self.logger
            )
            self.logger.debug(f"[{call_id}] Generated {len(summary_text)} chars")
            summary_id = store_summary(
                summary_text=summary_text,
                buffer_entries=Cbuf,
                seed_entries=Sk,
                summary_retriever=self.summary_retriever,
                text_embedder=self.text_embedder,
                logger=self.logger
            )
            GLOBAL_LAST_SUMMARY_TIME = mark_entries_and_get_next_time(
                retriever=self.embedding_retriever,
                entries=Cbuf,
                call_id=call_id,
                logger=self.logger
            )
            has_more = check_has_more_entries(
                retriever=self.embedding_retriever,
                current_time=GLOBAL_LAST_SUMMARY_TIME
            )
            if process_all:
                summaries.append(build_summary_item(summary_text, summary_id, Cbuf, Sk))
                total_entries += len(Cbuf)
                if not has_more:
                    break
            else:
                result = build_single_result(summary_text, summary_id, Cbuf, Sk, has_more)
                self.logger.info(f"========== END {call_id} ==========")
                return result
        result = build_batch_result(summaries, total_entries, call_id, self.logger)
        self.logger.info(f"========== END {call_id} ==========")
        return result