"""Unified create command - single entry point for skill creation.

Auto-detects source type (web, GitHub, local, PDF, config) and routes
to appropriate scraper while maintaining full backward compatibility.
"""

import sys
import logging
import argparse
from typing import List, Optional

from skill_seekers.cli.source_detector import SourceDetector, SourceInfo
from skill_seekers.cli.arguments.create import (
    get_compatible_arguments,
    get_universal_argument_names,
)

logger = logging.getLogger(__name__)


class CreateCommand:
    """Unified create command implementation."""

    def __init__(self, args: argparse.Namespace):
        """Initialize create command.

        Args:
            args: Parsed command-line arguments
        """
        self.args = args
        self.source_info: Optional[SourceInfo] = None

    def execute(self) -> int:
        """Execute the create command.

        Returns:
            Exit code (0 for success, non-zero for error)
        """
        # 1. Detect source type
        try:
            self.source_info = SourceDetector.detect(self.args.source)
            logger.info(f"Detected source type: {self.source_info.type}")
            logger.debug(f"Parsed info: {self.source_info.parsed}")
        except ValueError as e:
            logger.error(str(e))
            return 1

        # 2. Validate source accessibility
        try:
            SourceDetector.validate_source(self.source_info)
        except ValueError as e:
            logger.error(f"Source validation failed: {e}")
            return 1

        # 3. Validate and warn about incompatible arguments
        self._validate_arguments()

        # 4. Route to appropriate scraper
        logger.info(f"Routing to {self.source_info.type} scraper...")
        return self._route_to_scraper()

    def _validate_arguments(self) -> None:
        """Validate arguments and warn about incompatible ones."""
        # Get compatible arguments for this source type
        compatible = set(get_compatible_arguments(self.source_info.type))
        universal = get_universal_argument_names()

        # Check all provided arguments
        for arg_name, arg_value in vars(self.args).items():
            # Skip if not explicitly set (has default value)
            if not self._is_explicitly_set(arg_name, arg_value):
                continue

            # Skip if compatible
            if arg_name in compatible:
                continue

            # Skip internal arguments
            if arg_name in ['source', 'func', 'subcommand']:
                continue

            # Warn about incompatible argument
            if arg_name not in universal:
                logger.warning(
                    f"--{arg_name.replace('_', '-')} is not applicable for "
                    f"{self.source_info.type} sources and will be ignored"
                )

    def _is_explicitly_set(self, arg_name: str, arg_value: any) -> bool:
        """Check if an argument was explicitly set by the user.

        Args:
            arg_name: Argument name
            arg_value: Argument value

        Returns:
            True if user explicitly set this argument
        """
        # Boolean flags - True means it was set
        if isinstance(arg_value, bool):
            return arg_value

        # None means not set
        if arg_value is None:
            return False

        # Check against common defaults
        defaults = {
            'max_issues': 100,
            'chunk_size': 512,
            'chunk_overlap': 50,
            'output': None,
        }

        if arg_name in defaults:
            return arg_value != defaults[arg_name]

        # Any other non-None value means it was set
        return True

    def _route_to_scraper(self) -> int:
        """Route to appropriate scraper based on source type.

        Returns:
            Exit code from scraper
        """
        if self.source_info.type == 'web':
            return self._route_web()
        elif self.source_info.type == 'github':
            return self._route_github()
        elif self.source_info.type == 'local':
            return self._route_local()
        elif self.source_info.type == 'pdf':
            return self._route_pdf()
        elif self.source_info.type == 'config':
            return self._route_config()
        else:
            logger.error(f"Unknown source type: {self.source_info.type}")
            return 1

    def _route_web(self) -> int:
        """Route to web documentation scraper (doc_scraper.py)."""
        from skill_seekers.cli import doc_scraper

        # Reconstruct argv for doc_scraper
        argv = ['doc_scraper']

        # Add URL
        url = self.source_info.parsed['url']
        argv.append(url)

        # Add universal arguments
        self._add_common_args(argv)

        # Add web-specific arguments
        if self.args.max_pages:
            argv.extend(['--max-pages', str(self.args.max_pages)])
        if getattr(self.args, 'skip_scrape', False):
            argv.append('--skip-scrape')
        if getattr(self.args, 'resume', False):
            argv.append('--resume')
        if getattr(self.args, 'fresh', False):
            argv.append('--fresh')
        if getattr(self.args, 'rate_limit', None):
            argv.extend(['--rate-limit', str(self.args.rate_limit)])
        if getattr(self.args, 'workers', None):
            argv.extend(['--workers', str(self.args.workers)])
        if getattr(self.args, 'async_mode', False):
            argv.append('--async')
        if getattr(self.args, 'no_rate_limit', False):
            argv.append('--no-rate-limit')

        # Call doc_scraper with modified argv
        logger.debug(f"Calling doc_scraper with argv: {argv}")
        original_argv = sys.argv
        try:
            sys.argv = argv
            return doc_scraper.main()
        finally:
            sys.argv = original_argv

    def _route_github(self) -> int:
        """Route to GitHub repository scraper (github_scraper.py)."""
        from skill_seekers.cli import github_scraper

        # Reconstruct argv for github_scraper
        argv = ['github_scraper']

        # Add repo
        repo = self.source_info.parsed['repo']
        argv.extend(['--repo', repo])

        # Add universal arguments
        self._add_common_args(argv)

        # Add GitHub-specific arguments
        if getattr(self.args, 'token', None):
            argv.extend(['--token', self.args.token])
        if getattr(self.args, 'profile', None):
            argv.extend(['--profile', self.args.profile])
        if getattr(self.args, 'non_interactive', False):
            argv.append('--non-interactive')
        if getattr(self.args, 'no_issues', False):
            argv.append('--no-issues')
        if getattr(self.args, 'no_changelog', False):
            argv.append('--no-changelog')
        if getattr(self.args, 'no_releases', False):
            argv.append('--no-releases')
        if getattr(self.args, 'max_issues', None) and self.args.max_issues != 100:
            argv.extend(['--max-issues', str(self.args.max_issues)])
        if getattr(self.args, 'scrape_only', False):
            argv.append('--scrape-only')

        # Call github_scraper with modified argv
        logger.debug(f"Calling github_scraper with argv: {argv}")
        original_argv = sys.argv
        try:
            sys.argv = argv
            return github_scraper.main()
        finally:
            sys.argv = original_argv

    def _route_local(self) -> int:
        """Route to local codebase analyzer (codebase_scraper.py)."""
        from skill_seekers.cli import codebase_scraper

        # Reconstruct argv for codebase_scraper
        argv = ['codebase_scraper']

        # Add directory
        directory = self.source_info.parsed['directory']
        argv.extend(['--directory', directory])

        # Add universal arguments
        self._add_common_args(argv)

        # Add local-specific arguments
        if getattr(self.args, 'languages', None):
            argv.extend(['--languages', self.args.languages])
        if getattr(self.args, 'file_patterns', None):
            argv.extend(['--file-patterns', self.args.file_patterns])
        if getattr(self.args, 'skip_patterns', False):
            argv.append('--skip-patterns')
        if getattr(self.args, 'skip_test_examples', False):
            argv.append('--skip-test-examples')
        if getattr(self.args, 'skip_how_to_guides', False):
            argv.append('--skip-how-to-guides')
        if getattr(self.args, 'skip_config', False):
            argv.append('--skip-config')
        if getattr(self.args, 'skip_docs', False):
            argv.append('--skip-docs')

        # Call codebase_scraper with modified argv
        logger.debug(f"Calling codebase_scraper with argv: {argv}")
        original_argv = sys.argv
        try:
            sys.argv = argv
            return codebase_scraper.main()
        finally:
            sys.argv = original_argv

    def _route_pdf(self) -> int:
        """Route to PDF scraper (pdf_scraper.py)."""
        from skill_seekers.cli import pdf_scraper

        # Reconstruct argv for pdf_scraper
        argv = ['pdf_scraper']

        # Add PDF file
        file_path = self.source_info.parsed['file_path']
        argv.extend(['--pdf', file_path])

        # Add universal arguments
        self._add_common_args(argv)

        # Add PDF-specific arguments
        if getattr(self.args, 'ocr', False):
            argv.append('--ocr')
        if getattr(self.args, 'pages', None):
            argv.extend(['--pages', self.args.pages])

        # Call pdf_scraper with modified argv
        logger.debug(f"Calling pdf_scraper with argv: {argv}")
        original_argv = sys.argv
        try:
            sys.argv = argv
            return pdf_scraper.main()
        finally:
            sys.argv = original_argv

    def _route_config(self) -> int:
        """Route to unified scraper for config files (unified_scraper.py)."""
        from skill_seekers.cli import unified_scraper

        # Reconstruct argv for unified_scraper
        argv = ['unified_scraper']

        # Add config file
        config_path = self.source_info.parsed['config_path']
        argv.extend(['--config', config_path])

        # Add universal arguments (unified scraper supports most)
        self._add_common_args(argv)

        # Call unified_scraper with modified argv
        logger.debug(f"Calling unified_scraper with argv: {argv}")
        original_argv = sys.argv
        try:
            sys.argv = argv
            return unified_scraper.main()
        finally:
            sys.argv = original_argv

    def _add_common_args(self, argv: List[str]) -> None:
        """Add common/universal arguments to argv list.

        Args:
            argv: Argument list to append to
        """
        # Identity arguments
        if self.args.name:
            argv.extend(['--name', self.args.name])
        elif hasattr(self, 'source_info') and self.source_info:
            # Use suggested name from source detection
            argv.extend(['--name', self.source_info.suggested_name])

        if self.args.description:
            argv.extend(['--description', self.args.description])
        if self.args.output:
            argv.extend(['--output', self.args.output])

        # Enhancement arguments (consolidated to --enhance-level only)
        if self.args.enhance_level > 0:
            argv.extend(['--enhance-level', str(self.args.enhance_level)])
        if self.args.api_key:
            argv.extend(['--api-key', self.args.api_key])

        # Behavior arguments
        if self.args.dry_run:
            argv.append('--dry-run')
        if self.args.verbose:
            argv.append('--verbose')
        if self.args.quiet:
            argv.append('--quiet')

        # RAG arguments (NEW - universal!)
        if getattr(self.args, 'chunk_for_rag', False):
            argv.append('--chunk-for-rag')
        if getattr(self.args, 'chunk_size', None) and self.args.chunk_size != 512:
            argv.extend(['--chunk-size', str(self.args.chunk_size)])
        if getattr(self.args, 'chunk_overlap', None) and self.args.chunk_overlap != 50:
            argv.extend(['--chunk-overlap', str(self.args.chunk_overlap)])

        # Preset argument
        if getattr(self.args, 'preset', None):
            argv.extend(['--preset', self.args.preset])

        # Config file
        if self.args.config:
            argv.extend(['--config', self.args.config])

        # Advanced arguments
        if getattr(self.args, 'no_preserve_code_blocks', False):
            argv.append('--no-preserve-code-blocks')
        if getattr(self.args, 'no_preserve_paragraphs', False):
            argv.append('--no-preserve-paragraphs')
        if getattr(self.args, 'interactive_enhancement', False):
            argv.append('--interactive-enhancement')


def main() -> int:
    """Entry point for create command.

    Returns:
        Exit code (0 for success, non-zero for error)
    """
    import textwrap
    from skill_seekers.cli.arguments.create import add_create_arguments

    # Parse arguments
    # Custom formatter to prevent line wrapping in epilog
    class NoWrapFormatter(argparse.RawDescriptionHelpFormatter):
        def _split_lines(self, text, width):
            return text.splitlines()

    parser = argparse.ArgumentParser(
        prog='skill-seekers create',
        description='Create skill from any source (auto-detects type)',
        formatter_class=NoWrapFormatter,
        epilog=textwrap.dedent("""\
Examples:
  Web:      skill-seekers create https://docs.react.dev/
  GitHub:   skill-seekers create facebook/react -p standard
  Local:    skill-seekers create ./my-project -p comprehensive
  PDF:      skill-seekers create tutorial.pdf --ocr
  Config:   skill-seekers create configs/react.json

Source Auto-Detection:
  • URLs/domains → web scraping
  • owner/repo → GitHub analysis
  • ./path → local codebase
  • file.pdf → PDF extraction
  • file.json → multi-source config

Progressive Help (13 → 120+ flags):
  --help-web       Web scraping options
  --help-github    GitHub repository options
  --help-local     Local codebase analysis
  --help-pdf       PDF extraction options
  --help-advanced  Rare/advanced options
  --help-all       All options + compatibility

Presets (NEW: Use -p shortcut):
  -p quick              Fast (1-2 min, basic features)
  -p standard           Balanced (5-10 min, recommended)
  -p comprehensive      Full (20-60 min, all features)

Common Workflows:
  skill-seekers create <source> -p quick
  skill-seekers create <source> -p standard --enhance-level 2
  skill-seekers create <source> --chunk-for-rag
        """)
    )

    # Add arguments in default mode (universal only)
    add_create_arguments(parser, mode='default')

    # Add hidden help mode flags (use underscore prefix to match CreateParser)
    parser.add_argument('--help-web', action='store_true', help=argparse.SUPPRESS, dest='_help_web')
    parser.add_argument('--help-github', action='store_true', help=argparse.SUPPRESS, dest='_help_github')
    parser.add_argument('--help-local', action='store_true', help=argparse.SUPPRESS, dest='_help_local')
    parser.add_argument('--help-pdf', action='store_true', help=argparse.SUPPRESS, dest='_help_pdf')
    parser.add_argument('--help-advanced', action='store_true', help=argparse.SUPPRESS, dest='_help_advanced')
    parser.add_argument('--help-all', action='store_true', help=argparse.SUPPRESS, dest='_help_all')

    # Parse arguments
    args = parser.parse_args()

    # Handle source-specific help modes
    if args._help_web:
        # Recreate parser with web-specific arguments
        parser_web = argparse.ArgumentParser(
            prog='skill-seekers create',
            description='Create skill from web documentation',
            formatter_class=argparse.RawDescriptionHelpFormatter
        )
        add_create_arguments(parser_web, mode='web')
        parser_web.print_help()
        return 0
    elif args._help_github:
        parser_github = argparse.ArgumentParser(
            prog='skill-seekers create',
            description='Create skill from GitHub repository',
            formatter_class=argparse.RawDescriptionHelpFormatter
        )
        add_create_arguments(parser_github, mode='github')
        parser_github.print_help()
        return 0
    elif args._help_local:
        parser_local = argparse.ArgumentParser(
            prog='skill-seekers create',
            description='Create skill from local codebase',
            formatter_class=argparse.RawDescriptionHelpFormatter
        )
        add_create_arguments(parser_local, mode='local')
        parser_local.print_help()
        return 0
    elif args._help_pdf:
        parser_pdf = argparse.ArgumentParser(
            prog='skill-seekers create',
            description='Create skill from PDF file',
            formatter_class=argparse.RawDescriptionHelpFormatter
        )
        add_create_arguments(parser_pdf, mode='pdf')
        parser_pdf.print_help()
        return 0
    elif args._help_advanced:
        parser_advanced = argparse.ArgumentParser(
            prog='skill-seekers create',
            description='Create skill - advanced options',
            formatter_class=argparse.RawDescriptionHelpFormatter
        )
        add_create_arguments(parser_advanced, mode='advanced')
        parser_advanced.print_help()
        return 0
    elif args._help_all:
        parser_all = argparse.ArgumentParser(
            prog='skill-seekers create',
            description='Create skill - all options',
            formatter_class=argparse.RawDescriptionHelpFormatter
        )
        add_create_arguments(parser_all, mode='all')
        parser_all.print_help()
        return 0

    # Setup logging
    log_level = logging.DEBUG if args.verbose else (
        logging.WARNING if args.quiet else logging.INFO
    )
    logging.basicConfig(
        level=log_level,
        format='%(levelname)s: %(message)s'
    )

    # Validate source provided
    if not args.source:
        parser.error("source is required")

    # Execute create command
    command = CreateCommand(args)
    return command.execute()


if __name__ == '__main__':
    sys.exit(main())