#!/usr/bin/env python3
"""
Test script for Proxmox documentation generation

Tests the end-to-end workflow:
1. Collect data from Proxmox (using mock data)
2. Generate documentation using template
3. Save sections to files and database
4. Optionally index for RAG
"""

import asyncio
import logging
import sys
from pathlib import Path

# Add src to path
sys.path.insert(0, str(Path(__file__).parent.parent / "src"))

from datacenter_docs.collectors.proxmox_collector import ProxmoxCollector
from datacenter_docs.generators.template_generator import TemplateBasedGenerator

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
)

logger = logging.getLogger(__name__)


async def test_proxmox_documentation() -> None:
    """Test complete Proxmox documentation generation workflow"""

    logger.info("=" * 80)
    logger.info("PROXMOX DOCUMENTATION GENERATION TEST")
    logger.info("=" * 80)

    # Step 1: Collect data from Proxmox
    logger.info("\n📊 STEP 1: Collecting data from Proxmox...")
    logger.info("-" * 80)

    collector = ProxmoxCollector()
    collect_result = await collector.run()

    if not collect_result["success"]:
        logger.error(f"❌ Data collection failed: {collect_result.get('error')}")
        return

    logger.info("✅ Data collection successful!")
    logger.info(f"   Collected at: {collect_result['data']['metadata']['collected_at']}")

    # Show statistics
    stats = collect_result["data"]["data"].get("statistics", {})
    logger.info("\n📈 Infrastructure Statistics:")
    logger.info(f"   Total VMs: {stats.get('total_vms', 0)}")
    logger.info(f"   Running VMs: {stats.get('running_vms', 0)}")
    logger.info(f"   Total Containers: {stats.get('total_containers', 0)}")
    logger.info(f"   Running Containers: {stats.get('running_containers', 0)}")
    logger.info(f"   Total Nodes: {stats.get('total_nodes', 0)}")
    logger.info(f"   Total CPU Cores: {stats.get('total_cpu_cores', 0)}")
    logger.info(f"   Total Memory: {stats.get('total_memory_gb', 0)} GB")
    logger.info(f"   Total Storage: {stats.get('total_storage_tb', 0)} TB")

    # Step 2: Generate documentation using template
    logger.info("\n📝 STEP 2: Generating documentation using template...")
    logger.info("-" * 80)

    template_path = "templates/documentation/proxmox.yaml"

    try:
        generator = TemplateBasedGenerator(template_path)
    except FileNotFoundError:
        logger.error(f"❌ Template not found: {template_path}")
        logger.info("   Creating template directory and file...")

        # Create template directory
        template_dir = Path(template_path).parent
        template_dir.mkdir(parents=True, exist_ok=True)

        logger.error(
            "   Please ensure the template file exists at: "
            f"{Path(template_path).absolute()}"
        )
        return

    logger.info(f"✅ Template loaded: {generator.template.name}")
    logger.info(f"   Sections to generate: {len(generator.template.sections)}")

    # List all sections
    for i, section in enumerate(generator.template.sections, 1):
        logger.info(f"   {i}. {section.get('title')} (ID: {section.get('id')})")

    # Step 3: Generate and save all sections
    logger.info("\n🔨 STEP 3: Generating documentation sections...")
    logger.info("-" * 80)

    sections_results = await generator.generate_and_save_sections(
        data=collect_result["data"], save_individually=True
    )

    # Show results
    sections_generated = sum(1 for r in sections_results if r.get("success"))
    sections_failed = sum(1 for r in sections_results if not r.get("success"))

    logger.info(f"\n✅ Generation completed!")
    logger.info(f"   Sections generated: {sections_generated}")
    logger.info(f"   Sections failed: {sections_failed}")

    # Show each section result
    logger.info("\n📋 Section Results:")
    for result in sections_results:
        if result.get("success"):
            logger.info(f"   ✅ {result.get('title')}")
            if "file_path" in result:
                logger.info(f"      File: {result.get('file_path')}")
        else:
            logger.info(f"   ❌ {result.get('section_id')}: {result.get('error')}")

    # Step 4: Summary
    logger.info("\n" + "=" * 80)
    logger.info("SUMMARY")
    logger.info("=" * 80)
    logger.info(f"✅ Data Collection: SUCCESS")
    logger.info(
        f"✅ Documentation Generation: {sections_generated}/{len(sections_results)} sections"
    )

    if sections_failed == 0:
        logger.info("\n🎉 All tests passed successfully!")
    else:
        logger.warning(f"\n⚠️  {sections_failed} section(s) failed to generate")

    # Show output directory
    output_dir = Path(generator.template.output_config.get("directory", "output"))
    if output_dir.exists():
        logger.info(f"\n📁 Generated files available in: {output_dir.absolute()}")
        md_files = list(output_dir.glob("**/*.md"))
        if md_files:
            logger.info(f"   Total markdown files: {len(md_files)}")
            for md_file in md_files[:10]:  # Show first 10
                logger.info(f"   - {md_file.relative_to(output_dir)}")
            if len(md_files) > 10:
                logger.info(f"   ... and {len(md_files) - 10} more")

    logger.info("\n" + "=" * 80)


def main() -> None:
    """Main entry point"""
    try:
        asyncio.run(test_proxmox_documentation())
    except KeyboardInterrupt:
        logger.info("\n\n⚠️  Test interrupted by user")
        sys.exit(1)
    except Exception as e:
        logger.error(f"\n\n❌ Test failed with error: {e}", exc_info=True)
        sys.exit(1)


if __name__ == "__main__":
    main()