"""
Knowledge Base Extractor for Astrology Aspects
Extracts professional aspect interpretations from markdown knowledge base
"""

import re
from pathlib import Path
from typing import Dict, List, Optional

# Knowledge base directory (relative to this file)
KNOWLEDGE_BASE_DIR = Path(__file__).parent / "knowledge-base" / "aspects"

# Aspect type mapping
ASPECT_SYMBOLS = {
    "conjunction": "☌",
    "sextile": "⚹",
    "square": "□",
    "trine": "△",
    "opposition": "☍"
}

# Planet symbols
PLANET_SYMBOLS = {
    "Sun": "☉",
    "Moon": "☽",
    "Mercury": "☿",
    "Venus": "♀",
    "Mars": "♂",
    "Jupiter": "♃",
    "Saturn": "♄",
    "Uranus": "♅",
    "Neptune": "♆",
    "Pluto": "♇"
}


def normalize_aspect_name(planet1: str, planet2: str, aspect: str) -> str:
    """
    Normalize aspect name to match knowledge base format.

    Args:
        planet1: First planet name (e.g., "Sun")
        planet2: Second planet name (e.g., "Moon")
        aspect: Aspect type (e.g., "trine")

    Returns:
        Normalized aspect name (e.g., "Sun Trine Moon")
    """
    # Capitalize aspect type
    aspect_capitalized = aspect.capitalize()

    # Format: "Planet1 Aspect Planet2"
    return f"{planet1} {aspect_capitalized} {planet2}"


def get_aspect_filename(planet: str) -> str:
    """
    Get the knowledge base filename for a planet.

    Args:
        planet: Planet name (e.g., "Sun", "Moon")

    Returns:
        Filename (e.g., "sun-aspects.md")
    """
    return f"{planet.lower()}-aspects.md"


def extract_aspect_interpretation(planet1: str, planet2: str, aspect: str) -> Optional[str]:
    """
    Extract aspect interpretation from knowledge base.

    Args:
        planet1: First planet name
        planet2: Second planet name
        aspect: Aspect type

    Returns:
        Full aspect interpretation text, or None if not found
    """
    # Determine which file to read (aspects are stored by the first planet)
    # For aspects like Sun-Moon, we read sun-aspects.md
    # For aspects like Moon-Venus, we read moon-aspects.md

    knowledge_file = KNOWLEDGE_BASE_DIR / get_aspect_filename(planet1)

    if not knowledge_file.exists():
        print(f"Knowledge file not found: {knowledge_file}")
        return None

    # Read the knowledge base file
    try:
        with open(knowledge_file, 'r', encoding='utf-8') as f:
            content = f.read()
    except Exception as e:
        print(f"Error reading {knowledge_file}: {e}")
        return None

    # Create the aspect header to search for
    # Format in knowledge base: "## Sun Trine Moon ☉△☽"
    aspect_name = normalize_aspect_name(planet1, planet2, aspect)

    # Get symbols
    aspect_symbol = ASPECT_SYMBOLS.get(aspect.lower(), "")
    planet1_symbol = PLANET_SYMBOLS.get(planet1, "")
    planet2_symbol = PLANET_SYMBOLS.get(planet2, "")

    # Try to find the aspect section with symbols
    header_pattern = f"## {aspect_name} {planet1_symbol}{aspect_symbol}{planet2_symbol}"

    # Alternative: try without symbols
    if header_pattern not in content:
        header_pattern = f"## {aspect_name}"

    # Find the section
    if header_pattern not in content:
        print(f"Aspect not found in knowledge base: {aspect_name}")
        return None

    # Extract the section (from this header to the next ## or end of file)
    # Split by ## headers
    sections = re.split(r'\n## ', content)

    target_section = None
    for section in sections:
        if section.startswith(aspect_name):
            target_section = "## " + section
            break

    if target_section:
        # Remove the next section if it exists
        next_header = re.search(r'\n## ', target_section[4:])  # Skip first "## "
        if next_header:
            target_section = target_section[:next_header.start() + 4]

        return target_section.strip()

    return None


def extract_knowledge_for_aspects(aspects: List[Dict]) -> str:
    """
    Extract knowledge base context for multiple aspects.

    Args:
        aspects: List of aspect dictionaries from API
                 Example: [{"planet1": "Sun", "planet2": "Moon", "aspect": "trine", "orb": 2.5}, ...]

    Returns:
        Combined knowledge context string ready for AI prompt
    """
    knowledge_sections = []

    for aspect_data in aspects:
        planet1 = aspect_data.get("planet1")
        planet2 = aspect_data.get("planet2")
        aspect_type = aspect_data.get("aspect")
        orb = aspect_data.get("orb", 0)

        # Extract interpretation
        interpretation = extract_aspect_interpretation(planet1, planet2, aspect_type)

        if interpretation:
            # Add orb information
            aspect_with_orb = f"{interpretation}\n\n**Orb in your chart**: {orb:.1f}°"
            knowledge_sections.append(aspect_with_orb)
        else:
            # If not found, add a placeholder
            aspect_name = normalize_aspect_name(planet1, planet2, aspect_type)
            knowledge_sections.append(
                f"## {aspect_name}\n\n"
                f"*Knowledge base entry not yet available for this aspect.*\n"
                f"Orb: {orb:.1f}°"
            )

    # Combine all sections
    if knowledge_sections:
        header = "# Professional Aspect Interpretations\n\n"
        header += "The following interpretations are based on classical and modern Western astrology texts.\n\n"
        header += "---\n\n"

        return header + "\n\n---\n\n".join(knowledge_sections)

    return "No aspect interpretations available."


def get_aspect_summary(aspects: List[Dict], limit: int = 5) -> str:
    """
    Get a summary of the most important aspects (by smallest orb).

    Args:
        aspects: List of aspect dictionaries
        limit: Maximum number of aspects to include

    Returns:
        Summary string with top aspects
    """
    # Sort by orb (smallest = strongest)
    sorted_aspects = sorted(aspects, key=lambda x: abs(x.get("orb", 99)))

    # Take top N
    top_aspects = sorted_aspects[:limit]

    summary_lines = [f"**Top {len(top_aspects)} Strongest Aspects** (by orb):\n"]

    for i, aspect in enumerate(top_aspects, 1):
        planet1 = aspect.get("planet1")
        planet2 = aspect.get("planet2")
        aspect_type = aspect.get("aspect", "").capitalize()
        orb = aspect.get("orb", 0)

        summary_lines.append(
            f"{i}. **{planet1} {aspect_type} {planet2}** (orb: {orb:.1f}°)"
        )

    return "\n".join(summary_lines)


# Example usage and testing
if __name__ == "__main__":
    # Test with sample aspect data
    test_aspects = [
        {"planet1": "Sun", "planet2": "Moon", "aspect": "trine", "orb": 2.5},
        {"planet1": "Venus", "planet2": "Mars", "aspect": "square", "orb": 3.1},
        {"planet1": "Moon", "planet2": "Mercury", "aspect": "conjunction", "orb": 1.2}
    ]

    print("=" * 60)
    print("TESTING KNOWLEDGE EXTRACTOR")
    print("=" * 60)

    # Test single extraction
    print("\n1. Testing single aspect extraction:")
    print("-" * 60)
    result = extract_aspect_interpretation("Sun", "Moon", "trine")
    if result:
        print(f"Found! Length: {len(result)} characters")
        print(result[:200] + "...")
    else:
        print("Not found")

    # Test multiple aspects
    print("\n\n2. Testing multiple aspects extraction:")
    print("-" * 60)
    knowledge_context = extract_knowledge_for_aspects(test_aspects)
    print(f"Total context length: {len(knowledge_context)} characters")
    print("\nFirst 500 characters:")
    print(knowledge_context[:500] + "...")

    # Test summary
    print("\n\n3. Testing aspect summary:")
    print("-" * 60)
    summary = get_aspect_summary(test_aspects)
    print(summary)