#!/usr/bin/env python3
"""
VM to LXC Migration Helper
Assists with migrating Docker-based VMs to LXC containers
"""

import sys
import os
import json
import argparse
from typing import Dict, List, Optional

sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from proxmox_client import ProxmoxClient


class VMLXCMigrator:
    """Helper class for VM to LXC migrations"""

    def __init__(self):
        self.client = ProxmoxClient()

    def analyze_vm(self, vmid: int) -> Dict:
        """
        Analyze a VM for migration suitability

        Args:
            vmid: VM ID to analyze

        Returns:
            Dictionary with VM info and migration recommendations
        """
        print(f"\n🔍 Analyzing VM {vmid}...")
        print("=" * 60)

        try:
            vm = self.client.get_vm(vmid)
            status = self.client.get_vm_status(vmid)
        except Exception as e:
            return {"error": f"Failed to get VM info: {e}"}

        analysis = {
            "vmid": vmid,
            "name": vm.get("name", "unknown"),
            "status": status.get("status", "unknown"),
            "memory_mb": vm.get("memory", 0),
            "cores": vm.get("cores", 0),
            "current_mem_usage_mb": status.get("mem", 0) / (1024**2) if status.get("mem") else 0,
            "current_mem_percent": (status.get("mem", 0) / status.get("maxmem", 1) * 100) if status.get("maxmem") else 0,
            "cpu_usage_percent": status.get("cpu", 0) * 100,
            "uptime_hours": status.get("uptime", 0) / 3600,
            "network_config": [],
            "disk_config": [],
            "migration_suitability": "unknown",
            "recommendations": [],
            "warnings": [],
            "estimated_lxc_memory_mb": 0,
            "estimated_savings_mb": 0
        }

        # Analyze network configuration
        for key, value in vm.items():
            if key.startswith("net"):
                analysis["network_config"].append({key: value})

        # Check migration suitability
        vm_name_lower = analysis["name"].lower()

        # High priority candidates
        if "docker" in vm_name_lower:
            analysis["migration_suitability"] = "excellent"
            analysis["recommendations"].append("✅ Docker host - excellent LXC candidate")
            analysis["recommendations"].append("✅ Docker-in-LXC works great with nesting enabled")

        elif "bot" in vm_name_lower or "discord" in vm_name_lower:
            analysis["migration_suitability"] = "excellent"
            analysis["recommendations"].append("✅ Bot/application server - excellent LXC candidate")
            analysis["recommendations"].append("✅ Lightweight workload perfect for containers")

        elif "database" in vm_name_lower or "db" in vm_name_lower:
            analysis["migration_suitability"] = "good"
            analysis["recommendations"].append("🟢 Database - good LXC candidate")
            analysis["recommendations"].append("✅ Better I/O performance in LXC")
            analysis["warnings"].append("⚠️  Backup database before migration!")

        elif "plex" in vm_name_lower:
            analysis["migration_suitability"] = "conditional"
            analysis["recommendations"].append("🟡 Plex - conditional LXC candidate")
            analysis["recommendations"].append("✅ If CPU transcoding: migrate to LXC")
            analysis["recommendations"].append("⚠️  If GPU transcoding: stay VM (easier GPU passthrough)")

        elif "tdarr" in vm_name_lower:
            analysis["migration_suitability"] = "poor"
            analysis["recommendations"].append("❌ Tdarr with GPU - keep as VM")
            analysis["recommendations"].append("❌ GPU passthrough much easier in VMs")
            analysis["warnings"].append("🛑 NOT recommended for LXC migration")

        elif "game" in vm_name_lower or "7d" in vm_name_lower:
            analysis["migration_suitability"] = "poor"
            analysis["recommendations"].append("❌ Game server - keep as VM")
            analysis["recommendations"].append("❌ Game engines often need full VM environment")
            analysis["warnings"].append("🛑 NOT recommended for LXC migration")

        elif "hass" in vm_name_lower or "home-assistant" in vm_name_lower:
            analysis["migration_suitability"] = "low"
            analysis["recommendations"].append("🟡 Home Assistant - low priority for migration")
            analysis["recommendations"].append("⚠️  VM is officially supported, works well")
            analysis["warnings"].append("⚠️  Consider keeping as VM unless resource constrained")

        elif "template" in vm_name_lower:
            analysis["migration_suitability"] = "n/a"
            analysis["recommendations"].append("📝 Template - create LXC equivalent")
            analysis["recommendations"].append("💡 Maintain both VM and LXC templates")

        else:
            analysis["migration_suitability"] = "unknown"
            analysis["recommendations"].append("🔍 Unknown workload - manual analysis needed")

        # Estimate LXC resource usage
        if analysis["current_mem_usage_mb"] > 0:
            # LXC typically uses 10-20% less memory (no guest kernel, bootloader, etc.)
            overhead_reduction = 0.15  # 15% average reduction
            analysis["estimated_lxc_memory_mb"] = int(analysis["current_mem_usage_mb"] * (1 - overhead_reduction))
            analysis["estimated_savings_mb"] = int(analysis["current_mem_usage_mb"] - analysis["estimated_lxc_memory_mb"])
        else:
            # VM is stopped, estimate based on allocation
            analysis["estimated_lxc_memory_mb"] = int(analysis["memory_mb"] * 0.85)
            analysis["estimated_savings_mb"] = int(analysis["memory_mb"] * 0.15)

        # Resource efficiency warnings
        if analysis["current_mem_percent"] > 80:
            analysis["warnings"].append(f"⚠️  High memory usage ({analysis['current_mem_percent']:.1f}%) - migration will help!")

        return analysis

    def print_analysis(self, analysis: Dict):
        """Print formatted analysis report"""
        if "error" in analysis:
            print(f"❌ {analysis['error']}")
            return

        print(f"\n📊 VM Analysis Report")
        print("=" * 60)
        print(f"VM ID: {analysis['vmid']}")
        print(f"Name: {analysis['name']}")
        print(f"Status: {analysis['status']}")
        print(f"\n💾 Current Resources:")
        print(f"  Allocated Memory: {analysis['memory_mb']}MB")
        print(f"  CPU Cores: {analysis['cores']}")
        if analysis['status'] == 'running':
            print(f"  Current Memory Usage: {analysis['current_mem_usage_mb']:.1f}MB ({analysis['current_mem_percent']:.1f}%)")
            print(f"  CPU Usage: {analysis['cpu_usage_percent']:.1f}%")
            print(f"  Uptime: {analysis['uptime_hours']:.1f} hours")

        print(f"\n📈 Estimated LXC Resources:")
        print(f"  Estimated Memory: {analysis['estimated_lxc_memory_mb']}MB")
        print(f"  Memory Savings: ~{analysis['estimated_savings_mb']}MB ({analysis['estimated_savings_mb']/analysis['memory_mb']*100:.1f}%)")

        print(f"\n🎯 Migration Suitability: {analysis['migration_suitability'].upper()}")

        if analysis['recommendations']:
            print(f"\n💡 Recommendations:")
            for rec in analysis['recommendations']:
                print(f"  {rec}")

        if analysis['warnings']:
            print(f"\n⚠️  Warnings:")
            for warn in analysis['warnings']:
                print(f"  {warn}")

        print("\n" + "=" * 60)

    def generate_migration_plan(self, vmid: int, new_ctid: int, static_ip: Optional[str] = None) -> Dict:
        """
        Generate a migration plan for a specific VM

        Args:
            vmid: Source VM ID
            new_ctid: Target container ID
            static_ip: Static IP for the LXC (optional)

        Returns:
            Dictionary with migration plan
        """
        analysis = self.analyze_vm(vmid)
        if "error" in analysis:
            return analysis

        vm = self.client.get_vm(vmid)

        # Extract network info
        network_config = "ip=dhcp"
        if static_ip:
            network_config = f"ip={static_ip}/24,gw=10.10.0.1"
        else:
            # Try to extract from VM config
            for key, value in vm.items():
                if key.startswith("net") and "ip=" in str(value):
                    # Parse existing IP config
                    pass  # TODO: parse VM network config

        plan = {
            "source_vm": {
                "vmid": vmid,
                "name": analysis["name"],
                "memory": analysis["memory_mb"],
                "cores": analysis["cores"]
            },
            "target_lxc": {
                "ctid": new_ctid,
                "hostname": f"{analysis['name']}-lxc",
                "memory": analysis["estimated_lxc_memory_mb"],
                "cores": analysis["cores"],
                "network": network_config,
                "features": "nesting=1,keyctl=1",  # Docker support
                "unprivileged": 0  # Privileged for Docker
            },
            "steps": [
                {
                    "step": 1,
                    "action": "Backup VM",
                    "command": f"# Create VM snapshot\npython3 -c \"from proxmox_client import ProxmoxClient; c=ProxmoxClient(); c.create_snapshot({vmid}, 'pre-migration', 'Before LXC migration')\""
                },
                {
                    "step": 2,
                    "action": "Export Docker Compose configurations",
                    "command": f"# SSH into VM and backup Docker configs\nssh cal@<vm-ip> 'cd ~ && tar czf docker-backup.tar.gz ~/docker ~/services ~/*/docker-compose.yml 2>/dev/null || true'\nscp cal@<vm-ip>:~/docker-backup.tar.gz ./vm-{vmid}-docker-backup.tar.gz"
                },
                {
                    "step": 3,
                    "action": "Document running containers",
                    "command": f"ssh cal@<vm-ip> 'docker ps -a --format \"table {{{{.Names}}}}\\t{{{{.Image}}}}\\t{{{{.Status}}}}\" > ~/container-list.txt'\nscp cal@<vm-ip>:~/container-list.txt ./vm-{vmid}-containers.txt"
                },
                {
                    "step": 4,
                    "action": "Stop VM (when ready)",
                    "command": f"# Graceful shutdown\npython3 -c \"from proxmox_client import ProxmoxClient; c=ProxmoxClient(); c.shutdown_vm({vmid}, timeout=120)\""
                },
                {
                    "step": 5,
                    "action": "Create LXC from template",
                    "command": f"# Clone Docker LXC template\npct clone 9001 {new_ctid} --hostname {analysis['name']}-lxc --full"
                },
                {
                    "step": 6,
                    "action": "Configure LXC resources",
                    "command": f"pct set {new_ctid} --memory {analysis['estimated_lxc_memory_mb']} --cores {analysis['cores']}"
                },
                {
                    "step": 7,
                    "action": "Configure LXC network",
                    "command": f"pct set {new_ctid} --net0 name=eth0,bridge=vmbr0,{network_config}"
                },
                {
                    "step": 8,
                    "action": "Start LXC",
                    "command": f"pct start {new_ctid}"
                },
                {
                    "step": 9,
                    "action": "Restore Docker configurations",
                    "command": f"# Copy configs to LXC\nscp ./vm-{vmid}-docker-backup.tar.gz root@<lxc-ip>:/root/\nssh root@<lxc-ip> 'cd / && tar xzf /root/docker-backup.tar.gz'"
                },
                {
                    "step": 10,
                    "action": "Start Docker containers",
                    "command": f"ssh root@<lxc-ip> 'cd ~/docker && docker-compose up -d'"
                },
                {
                    "step": 11,
                    "action": "Test and validate",
                    "command": "# Run migration validation checklist\n# See: migration_checklist.md"
                },
                {
                    "step": 12,
                    "action": "Monitor for 24-48 hours",
                    "command": f"# Monitor LXC performance\nwatch -n 60 'pct status {new_ctid} && pct config {new_ctid}'"
                }
            ],
            "rollback_plan": [
                f"1. Stop LXC: pct stop {new_ctid}",
                f"2. Start original VM: qm start {vmid}",
                f"3. Verify services are running",
                f"4. Delete LXC if no longer needed: pct destroy {new_ctid}"
            ]
        }

        return plan

    def print_migration_plan(self, plan: Dict):
        """Print formatted migration plan"""
        if "error" in plan:
            print(f"❌ {plan['error']}")
            return

        print("\n📋 Migration Plan")
        print("=" * 60)
        print(f"\n🔵 Source VM:")
        print(f"  ID: {plan['source_vm']['vmid']}")
        print(f"  Name: {plan['source_vm']['name']}")
        print(f"  Memory: {plan['source_vm']['memory']}MB")
        print(f"  Cores: {plan['source_vm']['cores']}")

        print(f"\n🟢 Target LXC:")
        print(f"  ID: {plan['target_lxc']['ctid']}")
        print(f"  Hostname: {plan['target_lxc']['hostname']}")
        print(f"  Memory: {plan['target_lxc']['memory']}MB (saving ~{plan['source_vm']['memory'] - plan['target_lxc']['memory']}MB)")
        print(f"  Cores: {plan['target_lxc']['cores']}")
        print(f"  Network: {plan['target_lxc']['network']}")

        print(f"\n📝 Migration Steps:")
        for step in plan['steps']:
            print(f"\n  Step {step['step']}: {step['action']}")
            if step['command']:
                print(f"  Command:")
                for line in step['command'].split('\n'):
                    if line.strip():
                        print(f"    {line}")

        print(f"\n🔄 Rollback Plan (if needed):")
        for item in plan['rollback_plan']:
            print(f"  {item}")

        print("\n" + "=" * 60)
        print("💡 Tips:")
        print("  - Take VM snapshot before starting")
        print("  - Schedule migration during low-traffic period")
        print("  - Keep VM stopped but don't delete for 1-2 weeks")
        print("  - Monitor LXC performance and stability")
        print("  - Have rollback plan ready")


def main():
    """Main CLI interface"""
    parser = argparse.ArgumentParser(description="VM to LXC Migration Helper")
    parser.add_argument("command", choices=["analyze", "plan", "batch-analyze"],
                       help="Command to run")
    parser.add_argument("--vmid", type=int, help="VM ID to analyze or migrate")
    parser.add_argument("--ctid", type=int, help="Target LXC container ID (for plan)")
    parser.add_argument("--ip", help="Static IP for LXC (e.g., 10.10.0.50)")
    parser.add_argument("--all", action="store_true", help="Analyze all VMs (for batch-analyze)")

    args = parser.parse_args()

    migrator = VMLXCMigrator()

    if args.command == "analyze":
        if not args.vmid:
            print("❌ Error: --vmid required for analyze command")
            sys.exit(1)

        analysis = migrator.analyze_vm(args.vmid)
        migrator.print_analysis(analysis)

    elif args.command == "plan":
        if not args.vmid or not args.ctid:
            print("❌ Error: --vmid and --ctid required for plan command")
            sys.exit(1)

        plan = migrator.generate_migration_plan(args.vmid, args.ctid, args.ip)
        migrator.print_migration_plan(plan)

        # Save plan to file
        filename = f"migration-plan-vm{args.vmid}-to-ct{args.ctid}.json"
        with open(filename, 'w') as f:
            json.dump(plan, f, indent=2)
        print(f"\n💾 Migration plan saved to: {filename}")

    elif args.command == "batch-analyze":
        client = ProxmoxClient()
        vms = client.list_vms()

        excellent_candidates = []
        good_candidates = []
        conditional_candidates = []
        poor_candidates = []

        print("\n🔍 Analyzing all VMs for migration suitability...")
        print("=" * 60)

        for vm in vms:
            analysis = migrator.analyze_vm(vm['vmid'])
            suitability = analysis.get('migration_suitability', 'unknown')

            if suitability == 'excellent':
                excellent_candidates.append(analysis)
            elif suitability == 'good':
                good_candidates.append(analysis)
            elif suitability == 'conditional':
                conditional_candidates.append(analysis)
            elif suitability == 'poor':
                poor_candidates.append(analysis)

        # Print summary
        print("\n📊 Migration Suitability Summary")
        print("=" * 60)

        print(f"\n✅ Excellent Candidates ({len(excellent_candidates)}):")
        total_savings = 0
        for analysis in excellent_candidates:
            print(f"  VM {analysis['vmid']}: {analysis['name']}")
            print(f"    Savings: ~{analysis['estimated_savings_mb']}MB")
            total_savings += analysis['estimated_savings_mb']

        print(f"\n🟢 Good Candidates ({len(good_candidates)}):")
        for analysis in good_candidates:
            print(f"  VM {analysis['vmid']}: {analysis['name']}")
            print(f"    Savings: ~{analysis['estimated_savings_mb']}MB")
            total_savings += analysis['estimated_savings_mb']

        print(f"\n🟡 Conditional Candidates ({len(conditional_candidates)}):")
        for analysis in conditional_candidates:
            print(f"  VM {analysis['vmid']}: {analysis['name']} - {analysis['recommendations'][0]}")

        print(f"\n❌ Poor Candidates (Keep as VM) ({len(poor_candidates)}):")
        for analysis in poor_candidates:
            print(f"  VM {analysis['vmid']}: {analysis['name']}")

        print(f"\n💰 Total Estimated Savings: ~{total_savings}MB (~{total_savings/1024:.1f}GB)")
        print("\n💡 Recommendation: Start with 'Excellent Candidates' for safest wins!")


if __name__ == "__main__":
    main()