#!/usr/bin/env python3
"""
Stacks Agent Skill - Search Engine
BM25 + regex hybrid search across knowledge databases with relationships and examples
"""

import argparse
import sys
from pathlib import Path

# Add parent directory to path for imports
sys.path.insert(0, str(Path(__file__).parent))

from core import search, DOMAINS


def format_snippet_result(result: dict, index: int) -> str:
    """Format a code snippet result for display"""
    lines = []
    lines.append(f"\n{'=' * 80}")
    lines.append(f"Result {index} - Score: {result.get('_score', 0):.3f} | Domain: {result.get('_domain', 'unknown')}")
    lines.append('=' * 80)

    for key, value in result.items():
        if not key.startswith('_'):
            lines.append(f"{key}: {value}")

    # Display relationships if available
    if '_relationships' in result:
        lines.append("\n📚 Related Entries:")
        for rel in result['_relationships']:
            lines.append(
                f"  [{rel['type']}] {rel['target_domain']}:{rel['target_id']} "
                f"(strength: {rel['strength']}) - {rel['context']}"
            )

    lines.append('=' * 80)
    return '\n'.join(lines)


def format_example_result(result: dict, index: int) -> str:
    """Format an example result for display"""
    lines = []
    lines.append(f"\n{'=' * 80}")
    lines.append(f"Example {index}: {result.get('scenario', 'Unknown')}")
    lines.append(f"Score: {result.get('_score', 0):.3f} | Domain: {result.get('domain', 'unknown')} | "
                f"Type: {result.get('example_type', 'unknown')} | Difficulty: {result.get('difficulty', 'unknown')}")
    lines.append('=' * 80)

    # Problem
    if result.get('problem'):
        lines.append(f"\n📝 Problem:\n{result['problem']}")

    # Solution
    if result.get('solution_code'):
        lines.append(f"\n💡 Solution:")
        lines.append(result['solution_code'])

    # Explanation
    if result.get('explanation'):
        lines.append(f"\n📖 Explanation:\n{result['explanation']}")

    # Test inputs/outputs
    if result.get('test_inputs'):
        lines.append(f"\n🧪 Test Inputs: {result['test_inputs']}")
    if result.get('expected_outputs'):
        lines.append(f"✅ Expected Outputs: {result['expected_outputs']}")

    # Pitfalls
    if result.get('pitfalls'):
        lines.append(f"\n⚠️  Common Pitfalls:\n{result['pitfalls']}")

    # Live example
    if result.get('live_example_url'):
        lines.append(f"\n🔗 Live Example: {result['live_example_url']}")

    # Related snippets
    if result.get('related_snippets'):
        lines.append(f"\n📚 Related Snippets: {result['related_snippets']}")

    # Tags
    if result.get('tags'):
        lines.append(f"\n🏷️  Tags: {result['tags']}")

    lines.append('=' * 80)
    return '\n'.join(lines)


def main():
    parser = argparse.ArgumentParser(
        description='Search Stacks Agent knowledge base'
    )
    parser.add_argument('query', nargs='?', help='Search query')
    parser.add_argument(
        '--domain', '-d',
        choices=list(DOMAINS.keys()) + ['auto'],
        default='auto',
        help='Domain to search (default: auto-detect)'
    )
    parser.add_argument(
        '--max-results', '-n',
        type=int,
        default=5,
        help='Maximum results to return (default: 5)'
    )
    parser.add_argument(
        '--format', '-f',
        choices=['text', 'json'],
        default='text',
        help='Output format (default: text)'
    )
    parser.add_argument(
        '--examples',
        action='store_true',
        help='Search examples instead of code snippets'
    )
    parser.add_argument(
        '--no-relationships',
        action='store_true',
        help='Disable relationship enrichment (faster search)'
    )
    parser.add_argument(
        '--example-type',
        choices=['quickstart', 'integration', 'debugging', 'best-practice', 'security'],
        help='Filter examples by type'
    )
    parser.add_argument(
        '--difficulty',
        choices=['beginner', 'intermediate', 'advanced'],
        help='Filter examples by difficulty'
    )
    parser.add_argument(
        '--validate',
        action='store_true',
        help='Validate examples.csv (runs validation instead of search)'
    )

    args = parser.parse_args()

    # Handle validation mode
    if args.validate:
        from validate_examples import print_validation_report
        success = print_validation_report()
        sys.exit(0 if success else 1)

    # Require query for search
    if not args.query:
        parser.error("Search query required (or use --validate)")

    # Search examples if requested
    if args.examples:
        from examples import search_examples
        results = search_examples(
            query=args.query,
            domain=args.domain if args.domain != 'auto' else None,
            max_results=args.max_results,
            example_type=args.example_type,
            difficulty=args.difficulty
        )
    else:
        # Normal snippet search
        results = search(
            query=args.query,
            domain=args.domain,
            max_results=args.max_results,
            include_relationships=not args.no_relationships
        )

    # Output results
    if args.format == 'json':
        import json
        print(json.dumps(results, indent=2))
    else:
        if not results:
            print(f"No results found for: {args.query}")
        else:
            result_type = "examples" if args.examples else "snippets"
            print(f"\nFound {len(results)} {result_type} for '{args.query}'")

            for i, result in enumerate(results, 1):
                if args.examples:
                    print(format_example_result(result, i))
                else:
                    print(format_snippet_result(result, i))


if __name__ == '__main__':
    main()