"""Structured SPARQL parser and executor.

This module provides tools for parsing and executing structured SPARQL queries
with separate ADD, UPDATE, and REMOVE sections.
"""

import logging

from ontocast.onto.enum import SPARQLOperationType
from ontocast.onto.rdfgraph import RDFGraph
from ontocast.onto.sparql_models import (
    SPARQLOperationModel,
    StructuredSPARQLQueryModel,
)

logger = logging.getLogger(__name__)


class StructuredSPARQLParser:
    """Parser for structured SPARQL queries with ADD, UPDATE, REMOVE sections."""

    def __init__(self):
        self.logger = logging.getLogger(__name__)

    def parse_structured_query(self, query_text: str) -> StructuredSPARQLQueryModel:
        """Parse a structured SPARQL query from text.

        Args:
            query_text: The structured SPARQL query text

        Returns:
            StructuredSPARQLQueryModel: Parsed structured query
        """
        self.logger.info("Parsing structured SPARQL query")

        # Split into sections
        sections = self._split_into_sections(query_text)

        # Parse each section and combine all operations
        all_operations = []
        all_operations.extend(
            self._parse_section_operations(
                sections.get("ADD", ""), SPARQLOperationType.INSERT
            )
        )
        all_operations.extend(
            self._parse_section_operations(
                sections.get("UPDATE", ""), SPARQLOperationType.UPDATE
            )
        )
        all_operations.extend(
            self._parse_section_operations(
                sections.get("REMOVE", ""), SPARQLOperationType.DELETE
            )
        )

        # Extract namespaces
        namespaces = self._extract_namespaces(query_text)

        structured_query = StructuredSPARQLQueryModel(
            operations=all_operations,
            namespaces=namespaces,
        )

        self.logger.info(f"Parsed structured query: {structured_query.get_summary()}")
        return structured_query

    def _split_into_sections(self, query_text: str) -> dict[str, str]:
        """Split query text into ADD, UPDATE, REMOVE sections.

        Args:
            query_text: The query text to split

        Returns:
            dict[str, str]: Dictionary mapping section names to content
        """
        sections = {}
        current_section = None
        current_content = []

        lines = query_text.split("\n")

        for line in lines:
            line = line.strip()

            # Check for section headers
            if line.upper().startswith("-- ADD SECTION:") or line.upper().startswith(
                "ADD SECTION:"
            ):
                if current_section:
                    sections[current_section] = "\n".join(current_content)
                current_section = "ADD"
                current_content = []
            elif line.upper().startswith(
                "-- UPDATE SECTION:"
            ) or line.upper().startswith("UPDATE SECTION:"):
                if current_section:
                    sections[current_section] = "\n".join(current_content)
                current_section = "UPDATE"
                current_content = []
            elif line.upper().startswith(
                "-- REMOVE SECTION:"
            ) or line.upper().startswith("REMOVE SECTION:"):
                if current_section:
                    sections[current_section] = "\n".join(current_content)
                current_section = "REMOVE"
                current_content = []
            else:
                current_content.append(line)

        # Add the last section
        if current_section:
            sections[current_section] = "\n".join(current_content)

        return sections

    def _parse_section_operations(
        self, section_content: str, default_type: SPARQLOperationType
    ) -> list[SPARQLOperationModel]:
        """Parse operations from a section.

        Args:
            section_content: The section content
            default_type: Default operation type for the section

        Returns:
            list[SPARQLOperationModel]: List of parsed operations
        """
        operations = []

        if not section_content.strip():
            return operations

        # Split by PREFIX blocks and INSERT/UPDATE/DELETE blocks
        blocks = self._split_into_blocks(section_content)

        for block in blocks:
            if block.strip():
                operation = self._create_operation_from_block(block, default_type)
                if operation:
                    operations.append(operation)

        return operations

    def _split_into_blocks(self, content: str) -> list[str]:
        """Split content into SPARQL operation blocks.

        Args:
            content: The content to split

        Returns:
            list[str]: List of operation blocks
        """
        blocks = []
        current_block = []
        in_operation = False

        lines = content.split("\n")

        for line in lines:
            line = line.strip()

            if not line:
                continue

            # Check if this is the start of a new operation
            if (
                line.upper().startswith("INSERT")
                or line.upper().startswith("UPDATE")
                or line.upper().startswith("DELETE")
            ):
                # Save previous block if exists
                if current_block:
                    blocks.append("\n".join(current_block))

                # Start new block
                current_block = [line]
                in_operation = True
            elif in_operation:
                current_block.append(line)

                # Check if operation is complete
                if line == "}" and current_block:
                    blocks.append("\n".join(current_block))
                    current_block = []
                    in_operation = False

        # Add any remaining block
        if current_block:
            blocks.append("\n".join(current_block))

        return blocks

    def _create_operation_from_block(
        self, block: str, default_type: SPARQLOperationType
    ) -> SPARQLOperationModel | None:
        """Create a SPARQL operation from a block.

        Args:
            block: The operation block
            default_type: Default operation type

        Returns:
            SPARQLOperationModel | None: Created operation or None if invalid
        """
        if not block.strip():
            return None

        # Determine operation type
        if block.upper().startswith("INSERT"):
            operation_type = SPARQLOperationType.INSERT
        elif block.upper().startswith("UPDATE"):
            operation_type = SPARQLOperationType.UPDATE
        elif block.upper().startswith("DELETE"):
            operation_type = SPARQLOperationType.DELETE
        else:
            operation_type = default_type

        return SPARQLOperationModel(operation_type=operation_type, query=block.strip())

    def _extract_namespaces(self, query_text: str) -> dict[str, str]:
        """Extract namespace declarations from query text.

        Args:
            query_text: The query text

        Returns:
            dict[str, str]: Dictionary mapping prefixes to URIs
        """
        namespaces = {}

        lines = query_text.split("\n")
        for line in lines:
            line = line.strip()

            if line.upper().startswith("PREFIX "):
                # Parse PREFIX declaration
                parts = line.split()
                if len(parts) >= 3:
                    prefix = parts[1].rstrip(":")
                    uri = parts[2].strip("<>")
                    namespaces[prefix] = uri

        return namespaces


class StructuredSPARQLExecutor:
    """Executor for structured SPARQL queries."""

    def __init__(self, sparql_tool):
        """Initialize the executor.

        Args:
            sparql_tool: The SPARQL tool for executing operations
        """
        self.sparql_tool = sparql_tool
        self.logger = logging.getLogger(__name__)

    def execute_structured_query(
        self, structured_query: StructuredSPARQLQueryModel, graph: RDFGraph
    ) -> bool:
        """Execute a structured SPARQL query.

        Args:
            structured_query: The structured query to execute
            graph: The RDF graph to execute against

        Returns:
            bool: True if execution was successful
        """
        self.logger.info(
            f"Executing structured query: {structured_query.get_summary()}"
        )

        try:
            # Execute operations in order: ADD, UPDATE, REMOVE
            all_operations = structured_query.get_all_operations()

            for operation in all_operations:
                # Execute SPARQLOperationModel directly
                self.sparql_tool.execute_operation(operation)
                self.logger.debug(
                    f"Executed {operation.operation_type.value} operation"
                )

            self.logger.info("Structured query execution completed successfully")
            return True

        except Exception as e:
            self.logger.error(f"Failed to execute structured query: {e}")
            return False

    def execute_add_operations(
        self, structured_query: StructuredSPARQLQueryModel, graph: RDFGraph
    ) -> bool:
        """Execute only ADD operations from a structured query.

        Args:
            structured_query: The structured query
            graph: The RDF graph to execute against

        Returns:
            bool: True if execution was successful
        """
        return self._execute_operations(structured_query.get_add_operations(), "ADD")

    def execute_update_operations(
        self, structured_query: StructuredSPARQLQueryModel, graph: RDFGraph
    ) -> bool:
        """Execute only UPDATE operations from a structured query.

        Args:
            structured_query: The structured query
            graph: The RDF graph to execute against

        Returns:
            bool: True if execution was successful
        """
        return self._execute_operations(
            structured_query.get_update_operations(), "UPDATE"
        )

    def execute_remove_operations(
        self, structured_query: StructuredSPARQLQueryModel, graph: RDFGraph
    ) -> bool:
        """Execute only REMOVE operations from a structured query.

        Args:
            structured_query: The structured query
            graph: The RDF graph to execute against

        Returns:
            bool: True if execution was successful
        """
        return self._execute_operations(
            structured_query.get_remove_operations(), "REMOVE"
        )

    def _execute_operations(
        self, operations: list[SPARQLOperationModel], section_name: str
    ) -> bool:
        """Execute a list of operations.

        Args:
            operations: List of operations to execute
            section_name: Name of the section for logging

        Returns:
            bool: True if execution was successful
        """
        if not operations:
            self.logger.info(f"No {section_name} operations to execute")
            return True

        try:
            for operation in operations:
                # Execute SPARQLOperationModel directly
                self.sparql_tool.execute_operation(operation)
                self.logger.debug(
                    f"Executed {section_name} {operation.operation_type.value} operation"
                )

            self.logger.info(
                f"Executed {len(operations)} {section_name} operations successfully"
            )
            return True

        except Exception as e:
            self.logger.error(f"Failed to execute {section_name} operations: {e}")
            return False