#!/usr/bin/env python3
"""
DeepCode - AI Research Engine Launcher

🧬 Next-Generation AI Research Automation Platform
⚡ Transform research papers into working code automatically

Cross-platform support: Windows, macOS, Linux
"""

import os
import sys
import subprocess
import signal
import platform
import socket
import time
from pathlib import Path


# Global process references for cleanup
_backend_process = None
_frontend_process = None


def get_platform():
 """Get current platform"""
 system = platform.system().lower()
 if system == "darwin":
 return "macos"
 elif system == "windows":
 return "windows"
 else:
 return "linux"


def check_dependencies():
 """Check if necessary dependencies are installed for new UI"""
 import importlib.util
 import shutil

 print("🔍 Checking dependencies...")

 missing_deps = []
 missing_system_deps = []

 # Check FastAPI availability (for backend)
 if importlib.util.find_spec("fastapi") is not None:
 print("✅ FastAPI is installed")
 else:
 missing_deps.append("fastapi>=0.104.0")

 # Check uvicorn availability (for backend server)
 if importlib.util.find_spec("uvicorn") is not None:
 print("✅ Uvicorn is installed")
 else:
 missing_deps.append("uvicorn>=0.24.0")

 # Check PyYAML availability
 if importlib.util.find_spec("yaml") is not None:
 print("✅ PyYAML is installed")
 else:
 missing_deps.append("pyyaml>=6.0")

 # Check pydantic-settings availability
 if importlib.util.find_spec("pydantic_settings") is not None:
 print("✅ Pydantic-settings is installed")
 else:
 missing_deps.append("pydantic-settings>=2.0.0")

 # Check Node.js availability (for frontend)
 node_cmd = "node.exe" if get_platform() == "windows" else "node"
 if shutil.which(node_cmd) or shutil.which("node"):
 try:
 result = subprocess.run(
 ["node", "--version"],
 capture_output=True,
 text=True,
 timeout=5,
 shell=(get_platform() == "windows"),
 )
 if result.returncode == 0:
 print(f"✅ Node.js is installed ({result.stdout.strip()})")
 except Exception:
 missing_system_deps.append("Node.js")
 else:
 missing_system_deps.append("Node.js")
 print("❌ Node.js not found (required for frontend)")

 # Check npm availability
 npm_cmd = "npm.cmd" if get_platform() == "windows" else "npm"
 if shutil.which(npm_cmd) or shutil.which("npm"):
 print("✅ npm is available")
 else:
 missing_system_deps.append("npm")
 print("❌ npm not found (required for frontend)")

 # Display missing dependencies
 if missing_deps or missing_system_deps:
 print("\n📋 Dependency Status:")

 if missing_deps:
 print("❌ Missing Python dependencies:")
 for dep in missing_deps:
 print(f" - {dep}")
 print(f"\nInstall with: pip install {' '.join(missing_deps)}")

 if missing_system_deps:
 print("\n❌ Missing system dependencies:")
 for dep in missing_system_deps:
 print(f" - {dep}")
 print("\nInstall Node.js:")
 print(" - Windows/macOS: https://nodejs.org/")
 print(" - macOS: brew install node")
 print(" - Ubuntu/Debian: sudo apt-get install nodejs npm")

 # Fail if critical dependencies are missing
 if missing_deps or missing_system_deps:
 return False
 else:
 print("✅ All dependencies satisfied")

 return True


def is_port_in_use(port: int) -> bool:
 """Check if a port is in use (cross-platform)"""
 with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
 return s.connect_ex(("localhost", port)) == 0


def kill_process_on_port(port: int):
 """Kill process using a specific port (cross-platform)"""
 current_platform = get_platform()

 try:
 if current_platform == "windows":
 # Windows: use netstat and taskkill
 result = subprocess.run(
 f"netstat -ano | findstr :{port}",
 capture_output=True,
 text=True,
 shell=True,
 )
 if result.stdout:
 for line in result.stdout.strip().split("\n"):
 parts = line.split()
 if len(parts) >= 5:
 pid = parts[-1]
 if pid.isdigit():
 subprocess.run(
 f"taskkill /F /PID {pid}",
 shell=True,
 capture_output=True,
 )
 print(f" ✓ Killed process on port {port} (PID: {pid})")
 else:
 # macOS/Linux: use lsof
 result = subprocess.run(
 f"lsof -ti :{port}", capture_output=True, text=True, shell=True
 )
 if result.stdout:
 pids = result.stdout.strip().split("\n")
 for pid in pids:
 if pid.isdigit():
 os.kill(int(pid), signal.SIGKILL)
 print(f" ✓ Killed process on port {port} (PID: {pid})")
 except Exception as e:
 print(f" ⚠️ Could not kill process on port {port}: {e}")


def cleanup_ports():
 """Clean up ports 8000 and 5173 if in use"""
 for port in [8000, 5173]:
 if is_port_in_use(port):
 print(f"⚠️ Port {port} is in use, cleaning up...")
 kill_process_on_port(port)
 time.sleep(1)


def install_backend_deps():
 """Install backend dependencies if needed"""
 import importlib.util

 if importlib.util.find_spec("fastapi") is None:
 print("📦 Installing backend dependencies...")
 deps = [
 "fastapi",
 "uvicorn",
 "pydantic-settings",
 "python-multipart",
 "aiofiles",
 "websockets",
 "pyyaml",
 ]
 subprocess.run(
 [sys.executable, "-m", "pip", "install", "-q"] + deps, check=True
 )
 print("✅ Backend dependencies installed")


def install_frontend_deps(frontend_dir: Path):
 """Install frontend dependencies if needed"""
 node_modules = frontend_dir / "node_modules"

 if not node_modules.exists():
 print("📦 Installing frontend dependencies (first run)...")
 npm_cmd = "npm.cmd" if get_platform() == "windows" else "npm"
 subprocess.run(
 [npm_cmd, "install"],
 cwd=frontend_dir,
 check=True,
 shell=(get_platform() == "windows"),
 )
 print("✅ Frontend dependencies installed")


def start_backend(backend_dir: Path):
 """Start the backend server"""
 global _backend_process

 print("🔧 Starting backend server...")

 # Use shell=True on Windows for proper command handling
 if get_platform() == "windows":
 _backend_process = subprocess.Popen(
 f'"{sys.executable}" -m uvicorn main:app --host 0.0.0.0 --port 8000 --reload',
 cwd=backend_dir,
 shell=True,
 creationflags=subprocess.CREATE_NEW_PROCESS_GROUP,
 )
 else:
 _backend_process = subprocess.Popen(
 [
 sys.executable,
 "-m",
 "uvicorn",
 "main:app",
 "--host",
 "0.0.0.0",
 "--port",
 "8000",
 "--reload",
 ],
 cwd=backend_dir,
 start_new_session=True, # Create new process group
 )

 # Wait for backend to start
 time.sleep(2)

 if _backend_process.poll() is None:
 print("✅ Backend started: http://localhost:8000")
 return True
 else:
 print("❌ Backend failed to start")
 return False


def start_frontend(frontend_dir: Path):
 """Start the frontend dev server"""
 global _frontend_process

 print("🎨 Starting frontend server...")

 npm_cmd = "npm.cmd" if get_platform() == "windows" else "npm"

 if get_platform() == "windows":
 _frontend_process = subprocess.Popen(
 f"{npm_cmd} run dev",
 cwd=frontend_dir,
 shell=True,
 creationflags=subprocess.CREATE_NEW_PROCESS_GROUP,
 )
 else:
 _frontend_process = subprocess.Popen(
 [npm_cmd, "run", "dev"],
 cwd=frontend_dir,
 start_new_session=True, # Create new process group
 )

 # Wait for frontend to start
 time.sleep(3)

 if _frontend_process.poll() is None:
 print("✅ Frontend started: http://localhost:5173")
 return True
 else:
 print("❌ Frontend failed to start")
 return False


def cleanup_processes():
 """Clean up running processes"""
 global _backend_process, _frontend_process

 print("\n🛑 Stopping services...")

 for name, proc in [("Backend", _backend_process), ("Frontend", _frontend_process)]:
 if proc and proc.poll() is None:
 try:
 if get_platform() == "windows":
 # Windows: use taskkill with /T to kill tree
 subprocess.run(
 f"taskkill /F /T /PID {proc.pid}",
 shell=True,
 capture_output=True,
 )
 else:
 # Unix: kill the process group
 try:
 os.killpg(os.getpgid(proc.pid), signal.SIGTERM)
 proc.wait(timeout=5)
 except Exception:
 os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
 print(f" ✓ {name} stopped")
 except Exception:
 # Fallback: try direct terminate
 try:
 proc.terminate()
 proc.wait(timeout=3)
 print(f" ✓ {name} stopped")
 except Exception:
 try:
 proc.kill()
 print(f" ✓ {name} killed")
 except Exception:
 print(f" ⚠️ Could not stop {name}")

 # Also clean up any orphaned processes on ports
 time.sleep(0.5)
 for port in [8000, 5173]:
 if is_port_in_use(port):
 kill_process_on_port(port)

 print("✅ All services stopped")


def cleanup_cache():
 """Clean up Python cache files"""
 try:
 print("🧹 Cleaning up cache files...")
 # Clean up __pycache__ directories
 os.system('find . -type d -name "__pycache__" -exec rm -r {} + 2>/dev/null')
 # Clean up .pyc files
 os.system('find . -name "*.pyc" -delete 2>/dev/null')
 print("✅ Cache cleanup completed")
 except Exception as e:
 print(f"⚠️ Cache cleanup failed: {e}")


def print_banner():
 """Display startup banner"""
 banner = """
╔══════════════════════════════════════════════════════════════╗
║ ║
║ 🧬 DeepCode - AI Research Engine ║
║ ║
║ ⚡ NEURAL • AUTONOMOUS • REVOLUTIONARY ⚡ ║
║ ║
║ Transform research papers into working code ║
║ Next-generation AI automation platform ║
║ ║
╚══════════════════════════════════════════════════════════════╝
"""
 print(banner)


def launch_classic_ui():
 """Launch classic Streamlit UI"""
 import importlib.util

 print("🌐 Launching Classic Streamlit UI...")

 # Check if Streamlit is installed
 if importlib.util.find_spec("streamlit") is None:
 print("❌ Streamlit is not installed.")
 print("Install with: pip install streamlit")
 sys.exit(1)

 current_dir = Path(__file__).parent
 streamlit_app_path = current_dir / "ui" / "streamlit_app.py"

 if not streamlit_app_path.exists():
 print(f"❌ Streamlit app not found: {streamlit_app_path}")
 sys.exit(1)

 print(f"📁 UI App: {streamlit_app_path}")
 print("🚀 Launching on http://localhost:8501")
 print("=" * 70)

 try:
 cmd = [
 sys.executable,
 "-m",
 "streamlit",
 "run",
 str(streamlit_app_path),
 "--server.port",
 "8501",
 "--server.address",
 "localhost",
 "--browser.gatherUsageStats",
 "false",
 ]
 subprocess.run(cmd, check=True)
 except KeyboardInterrupt:
 print("\n\n🛑 Streamlit server stopped by user")
 except Exception as e:
 print(f"\n❌ Error: {e}")
 sys.exit(1)


def _check_docker_prerequisites():
 """Check Docker prerequisites and config files. Returns (current_dir, compose_file, compose_args)."""
 import shutil

 current_dir = Path(__file__).parent
 compose_file = current_dir / "deepcode_docker" / "docker-compose.yml"

 if not compose_file.exists():
 print("❌ deepcode_docker/docker-compose.yml not found")
 print(" Make sure you are running from the DeepCode project root.")
 sys.exit(1)

 # Check Docker is installed
 if not shutil.which("docker"):
 print("❌ Docker not found. Please install Docker Desktop first.")
 print(" https://www.docker.com/products/docker-desktop")
 sys.exit(1)

 # Check Docker daemon is running
 result = subprocess.run(["docker", "info"], capture_output=True, text=True)
 if result.returncode != 0:
 print("❌ Docker is installed but not running.")
 print(" Please start Docker Desktop and try again.")
 sys.exit(1)

 # Check/create secrets file
 secrets_file = current_dir / "mcp_agent.secrets.yaml"
 if not secrets_file.exists():
 example = current_dir / "mcp_agent.secrets.yaml.example"
 if example.exists():
 print("⚠️ mcp_agent.secrets.yaml not found.")
 print(" Creating from template...")
 import shutil as sh

 sh.copy2(example, secrets_file)
 print(f" ✅ Created {secrets_file}")
 print("")
 print(" ⚠️ Please edit mcp_agent.secrets.yaml and fill in your API keys:")
 print(f" {secrets_file}")
 print("")
 print(
 " At least ONE LLM provider key is required (OpenAI/Anthropic/Google)."
 )
 print(" Then run 'deepcode' again.")
 sys.exit(0)
 else:
 print(
 "❌ mcp_agent.secrets.yaml not found. Please create it with your API keys."
 )
 sys.exit(1)

 # Check config file
 config_file = current_dir / "mcp_agent.config.yaml"
 if not config_file.exists():
 print("❌ mcp_agent.config.yaml not found.")
 print(" This file should be in the project root.")
 sys.exit(1)

 # Ensure data directories exist
 for d in ["deepcode_lab", "uploads", "logs"]:
 (current_dir / d).mkdir(exist_ok=True)

 os.chdir(current_dir)
 compose_args = ["docker", "compose", "-f", str(compose_file)]

 return current_dir, compose_file, compose_args


def launch_docker():
 """Launch DeepCode via Docker"""
 current_dir, compose_file, compose_args = _check_docker_prerequisites()

 print("🐳 Starting DeepCode with Docker...")
 print("=" * 50)

 try:
 # Check if image exists (auto-build on first run)
 result = subprocess.run(
 compose_args + ["images", "-q"], capture_output=True, text=True
 )
 if not result.stdout.strip():
 print(
 "📦 First run detected — building Docker image (may take a few minutes)..."
 )
 subprocess.run(compose_args + ["build"], check=True)

 # Start (if already running, docker compose will detect and skip)
 subprocess.run(compose_args + ["up", "-d"], check=True)

 print("")
 print("=" * 50)
 print("✅ DeepCode is running!")
 print("")
 print(" 🌐 Open: http://localhost:8000")
 print(" 📚 Docs: http://localhost:8000/docs")
 print("")
 print(" 📋 View logs: docker logs deepcode -f")
 print(
 " 🛑 Stop: docker compose -f deepcode_docker/docker-compose.yml down"
 )
 print("=" * 50)

 except subprocess.CalledProcessError as e:
 print(f"\n❌ Docker failed: {e}")
 sys.exit(1)
 except KeyboardInterrupt:
 print("\n🛑 Cancelled")


def launch_docker_cli():
 """Launch DeepCode CLI inside Docker container"""
 current_dir, compose_file, compose_args = _check_docker_prerequisites()

 print("🖥️ Starting DeepCode CLI in Docker...")
 print("=" * 50)

 try:
 # Check if image exists (auto-build on first run)
 result = subprocess.run(
 compose_args + ["images", "-q"], capture_output=True, text=True
 )
 if not result.stdout.strip():
 print(
 "📦 First run detected — building Docker image (may take a few minutes)..."
 )
 subprocess.run(compose_args + ["build"], check=True)

 # Run CLI interactively
 subprocess.run(
 compose_args + ["run", "--rm", "-it", "deepcode", "cli"], check=True
 )

 except subprocess.CalledProcessError as e:
 print(f"\n❌ Docker failed: {e}")
 sys.exit(1)
 except KeyboardInterrupt:
 print("\n🛑 Cancelled")


def launch_paper_test(paper_name: str, fast_mode: bool = False):
 """Launch paper testing mode"""
 try:
 print("\n🧪 Launching Paper Test Mode")
 print(f"📄 Paper: {paper_name}")
 print(f"⚡ Fast mode: {'enabled' if fast_mode else 'disabled'}")
 print("=" * 60)

 # Run the test setup
 setup_cmd = [sys.executable, "test_paper.py", paper_name]
 if fast_mode:
 setup_cmd.append("--fast")

 result = subprocess.run(setup_cmd, check=True)

 if result.returncode == 0:
 print("\n✅ Paper test setup completed successfully!")
 print("📁 Files are ready in deepcode_lab/papers/")
 print("\n💡 Next steps:")
 print(" 1. Install MCP dependencies: pip install -r requirements.txt")
 print(
 f" 2. Run full pipeline: python -m workflows.paper_test_engine --paper {paper_name}"
 + (" --fast" if fast_mode else "")
 )

 except subprocess.CalledProcessError as e:
 print(f"\n❌ Paper test setup failed: {e}")
 sys.exit(1)
 except Exception as e:
 print(f"\n❌ Unexpected error: {e}")
 sys.exit(1)


def main():
 """Main function"""
 # Parse command line arguments
 if len(sys.argv) > 1:
 if sys.argv[1] == "test" and len(sys.argv) >= 3:
 # Paper testing mode: python deepcode.py test rice [--fast]
 paper_name = sys.argv[2]
 fast_mode = "--fast" in sys.argv or "-f" in sys.argv

 print_banner()
 launch_paper_test(paper_name, fast_mode)
 return
 elif sys.argv[1] == "--local":
 # Launch locally (without Docker) — fall through to local launch below
 print_banner()
 pass
 elif sys.argv[1] == "--docker":
 # Explicit Docker launch (same as default)
 print_banner()
 launch_docker()
 return
 elif sys.argv[1] == "--cli":
 # Launch CLI inside Docker container
 print_banner()
 launch_docker_cli()
 return
 elif sys.argv[1] == "--classic":
 # Launch classic Streamlit UI
 print_banner()
 launch_classic_ui()
 return
 elif sys.argv[1] in ["--help", "-h", "help"]:
 print_banner()
 print("""
🔧 Usage:
 deepcode - Launch via Docker (default, recommended)
 deepcode --docker - Same as above (launch via Docker)
 deepcode --cli - Launch interactive CLI in Docker
 deepcode --local - Launch locally (requires Python + Node.js)
 deepcode test <paper> - Test paper reproduction
 deepcode test <paper> --fast - Test paper (fast mode)
 deepcode --classic - Launch classic Streamlit UI

📄 Examples:
 deepcode - Start with Docker (one command)
 deepcode --cli - Interactive CLI in Docker
 deepcode --local - Start the new UI locally
 deepcode test rice - Test RICE paper reproduction
 deepcode test rice --fast - Test RICE paper (fast mode)

🌐 New UI Features:
 • User-in-Loop interaction
 • Real-time progress tracking
 • Inline chat interaction
 • Modern React-based interface

📁 Available papers:""")

 # List available papers
 papers_dir = "papers"
 if os.path.exists(papers_dir):
 for item in os.listdir(papers_dir):
 item_path = os.path.join(papers_dir, item)
 if os.path.isdir(item_path):
 paper_md = os.path.join(item_path, "paper.md")
 addendum_md = os.path.join(item_path, "addendum.md")
 status = "✅" if os.path.exists(paper_md) else "❌"
 addendum_status = "📄" if os.path.exists(addendum_md) else "➖"
 print(f" {status}{item}{addendum_status}")
 print(
 "\n Legend: ✅ = paper.md exists, 📄 = addendum.md exists, ➖ = no addendum"
 )
 return
 else:
 # Unknown argument — show help hint
 print(f"Unknown option: {sys.argv[1]}")
 print("Run 'deepcode --help' for usage information.")
 sys.exit(1)
 else:
 # Default (no arguments) → Docker
 print_banner()
 launch_docker()
 return

 # --- Local launch (only reached via --local) ---

 # Show platform info
 current_platform = get_platform()
 print(f"🖥️ Platform: {current_platform.capitalize()}")

 # Check dependencies
 if not check_dependencies():
 print("\n🚨 Please install missing dependencies and try again.")
 sys.exit(1)

 # Get paths
 current_dir = Path(__file__).parent
 new_ui_dir = current_dir / "new_ui"
 backend_dir = new_ui_dir / "backend"
 frontend_dir = new_ui_dir / "frontend"

 # Check if new_ui directory exists
 if not new_ui_dir.exists():
 print(f"❌ New UI directory not found: {new_ui_dir}")
 sys.exit(1)

 print("\n🚀 Starting DeepCode New UI...")
 print("=" * 70)
 print("🎨 Frontend: http://localhost:5173")
 print("🔧 Backend: http://localhost:8000")
 print("📚 API Docs: http://localhost:8000/docs")
 print("=" * 70)
 print("💡 Tip: Keep this terminal open while using the application")
 print("🛑 Press Ctrl+C to stop all services")
 print("=" * 70)

 try:
 # Clean up ports if in use
 cleanup_ports()

 # Install dependencies if needed
 install_backend_deps()
 install_frontend_deps(frontend_dir)

 # Start services
 if not start_backend(backend_dir):
 print("❌ Failed to start backend")
 sys.exit(1)

 if not start_frontend(frontend_dir):
 print("❌ Failed to start frontend")
 cleanup_processes()
 sys.exit(1)

 print("\n" + "=" * 70)
 print("╔════════════════════════════════════════╗")
 print("║ 🎉 DeepCode New UI is running! ║")
 print("╠════════════════════════════════════════╣")
 print("║ ║")
 print("║ 🌐 Frontend: http://localhost:5173 ║")
 print("║ 🔧 Backend: http://localhost:8000 ║")
 print("║ 📚 API Docs: http://localhost:8000/docs║")
 print("║ ║")
 print("║ Press Ctrl+C to stop all services ║")
 print("╚════════════════════════════════════════╝")
 print("=" * 70 + "\n")

 # Wait for processes
 while True:
 # Check if processes are still running
 if _backend_process and _backend_process.poll() is not None:
 print("⚠️ Backend process exited unexpectedly")
 break
 if _frontend_process and _frontend_process.poll() is not None:
 print("⚠️ Frontend process exited unexpectedly")
 break
 time.sleep(1)

 except KeyboardInterrupt:
 print("\n")
 except Exception as e:
 print(f"\n❌ Unexpected error: {e}")
 finally:
 cleanup_processes()
 cleanup_cache()
 print("Thank you for using DeepCode! 🧬")


if __name__ == "__main__":
 main()