"""
Utility functions for grouping per-page results into document-level results.

This module provides common functionality for:
- Extracting page numbers from image filenames
- Converting page-level keys to document-level keys
- Grouping page-level elements into document-level structure

Usage:
    from doc_grouping import group_pages_to_documents

    # Group page-level results into document-level
    doc_results = group_pages_to_documents(
        page_results,
        file_ext_mapping={"jpg": "pdf"},
    )
"""

import re
from typing import Dict, List, Optional, Tuple


def extract_page_number(image_key: str) -> int:
    """
    Extract page number from image key.

    Supports formats like:
    - 'document_page0001.jpg' -> 1
    - 'document_page0042.pdf' -> 42

    Args:
        image_key: Image filename with page suffix

    Returns:
        Page number (1-based), or 1 if no page number found
    """
    match = re.search(r"_page(\d{4})\.", image_key)
    if match:
        return int(match.group(1))
    return 1


def to_doc_key(image_key: str) -> str:
    """
    Convert page image key to document key by removing the page suffix.

    Example:
        'mt_2020-06-25T04-07-00Z_s100j0q8_39-43_page0001.jpg'
        -> 'mt_2020-06-25T04-07-00Z_s100j0q8_39-43.jpg'

    Args:
        image_key: Page-level image filename

    Returns:
        Document-level filename (without page suffix)
    """
    return re.sub(r"_page\d{4}(?=\.)", "", image_key)


def replace_ext(filename: str, file_ext_mapping: Dict[str, str]) -> str:
    """
    Replace file extension according to mapping.

    Args:
        filename: Original filename
        file_ext_mapping: Dict mapping source extensions to destination extensions
                         e.g., {"jpg": "pdf", "jpeg": "pdf"}

    Returns:
        Filename with replaced extension
    """
    if not file_ext_mapping:
        return filename
    src_ext = filename.split(".")[-1]
    dst_ext = file_ext_mapping.get(src_ext, src_ext)
    return filename[: -(len(src_ext))] + dst_ext


def parse_ext_mapping(mapping_str: str) -> Dict[str, str]:
    """
    Parse file extension mapping from CLI string format.

    Supports two formats:
    - Colon format: "jpg:pdf" (single mapping)
    - Arrow format: "jpg->pdf,jpeg->pdf" (multiple mappings)

    Args:
        mapping_str: String in format "src:dst" or "src1->dst1,src2->dst2"

    Returns:
        Dict mapping source extensions to destination extensions

    Raises:
        ValueError: If mapping format is invalid
    """
    file_ext_mapping = {}
    if not mapping_str:
        return file_ext_mapping

    # Try colon format first (single mapping)
    if ":" in mapping_str and "->" not in mapping_str:
        parts = mapping_str.split(":")
        if len(parts) == 2:
            src, dst = parts[0].strip(), parts[1].strip()
            if src and dst:
                return {src: dst}

    # Try arrow format (multiple mappings)
    for pair in mapping_str.split(","):
        pair = pair.strip()
        if "->" in pair:
            src, dst = pair.split("->", 1)
            src = src.strip()
            dst = dst.strip()
            if src and dst:
                file_ext_mapping[src] = dst
        elif ":" in pair:
            src, dst = pair.split(":", 1)
            src = src.strip()
            dst = dst.strip()
            if src and dst:
                file_ext_mapping[src] = dst

    if not file_ext_mapping and mapping_str:
        raise ValueError(
            f"Invalid mapping format: '{mapping_str}'. "
            "Use 'src:dst' or 'src1->dst1,src2->dst2' format."
        )

    return file_ext_mapping


def group_pages_to_documents(
    page_data: Dict[str, Dict],
    file_ext_mapping: Optional[Dict[str, str]] = None,
    elements_key: str = "elements",
    include_merged_tables: bool = True,
) -> Dict[str, Dict]:
    """
    Group page-level results into document-level results.

    Takes a dictionary of page-level results (keyed by page image filename)
    and aggregates them into document-level results.

    Args:
        page_data: Dict mapping page filenames to their data.
                   Each page data should have an 'elements' list.
                   Example: {"doc_page0001.jpg": {"elements": [...]}, ...}
        file_ext_mapping: Optional dict mapping source extensions to destination.
                         e.g., {"jpg": "pdf"} to output "doc.pdf" instead of "doc.jpg"
        elements_key: Key name for the elements list in each page (default: "elements")
        include_merged_tables: Whether to include empty "merged_tables" list (default: True)

    Returns:
        Dict mapping document filenames to aggregated data.
        Example: {"doc.pdf": {"elements": [...], "merged_tables": []}}
    """
    if file_ext_mapping is None:
        file_ext_mapping = {}

    result: Dict[str, Dict] = {}
    id_counters: Dict[str, int] = {}

    for page_key, page_content in page_data.items():
        # Get document key and page number
        doc_key_raw = to_doc_key(page_key)
        doc_key = replace_ext(doc_key_raw, file_ext_mapping)
        page_number = extract_page_number(page_key)

        # Initialize document entry if not exists
        if doc_key not in result:
            result[doc_key] = {elements_key: []}
            if include_merged_tables:
                result[doc_key]["merged_tables"] = []
            id_counters[doc_key] = 0

        # Get elements from page data
        elements = page_content.get(elements_key, [])

        # Add each element with updated id and page number
        for elem in elements:
            # Create a copy to avoid modifying original
            new_elem = elem.copy()
            if "content" in elem:
                new_elem["content"] = elem["content"].copy()

            new_elem["id"] = id_counters[doc_key]
            new_elem["page"] = page_number

            result[doc_key][elements_key].append(new_elem)
            id_counters[doc_key] += 1

    return result


def is_multi_page_dataset(page_keys: List[str]) -> bool:
    """
    Check if the dataset contains multi-page documents.

    Looks for page suffixes like '_page0001' in the filenames.

    Args:
        page_keys: List of page-level filenames

    Returns:
        True if any filename has a page suffix
    """
    page_pattern = re.compile(r"_page\d{4}\.")
    return any(page_pattern.search(key) for key in page_keys)