#!/usr/bin/env python3
"""
accio_build_pipeline.py — Autonomous Build Pipeline for Accio Cluster
Kintegrity Labs × CodexΩ∞ × Sovereign Lattice
"""

import os
import sys
import json
import subprocess
import logging
import asyncio
import shutil
from datetime import datetime
from dataclasses import dataclass, field
from typing import Dict, List, Optional, Any
from enum import Enum
import hashlib

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s | %(levelname)s | %(name)s | %(message)s'
)
logger = logging.getLogger(__name__)


class BuildStage(Enum):
    PENDING = "pending"
    INITIALIZING = "initializing"
    FETCHING = "fetching"
    BUILDING = "building"
    TESTING = "testing"
    PACKAGING = "packaging"
    DEPLOYING = "deploying"
    COMPLETED = "completed"
    FAILED = "failed"


@dataclass
class BuildArtifact:
    """Build artifact"""
    name: str
    path: str
    type: str
    size: int
    checksum: str
    created_at: datetime = field(default_factory=datetime.now)


@dataclass
class BuildJob:
    """Build job"""
    id: str
    repository: str
    branch: str
    commit: str
    stages: List[BuildStage]
    current_stage: BuildStage = BuildStage.PENDING
    artifacts: List[BuildArtifact] = field(default_factory=list)
    logs: List[str] = field(default_factory=list)
    error: Optional[str] = None
    started_at: Optional[datetime] = None
    completed_at: Optional[datetime] = None
    phi5_signature: str = field(default_factory=lambda: f"Φ⁵_{hashlib.md5(str(time.time()).encode()).hexdigest()[:32]}")


class AccioBuildPipeline:
    """
    Autonomous Build Pipeline for Accio Cluster
    Handles building, testing, packaging, and deployment
    """
    
    def __init__(self, workspace: str = "./build_workspace"):
        self.workspace = workspace
        self.jobs: List[BuildJob] = []
        self.running = False
        self.workers = []
        
        # Create workspace
        os.makedirs(workspace, exist_ok=True)
        
        logger.info(f"🔧 Build Pipeline initialized: {workspace}")
    
    async def submit_job(self, repository: str, branch: str = "main", commit: str = "HEAD") -> BuildJob:
        """Submit a build job"""
        job = BuildJob(
            id=f"build_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{len(self.jobs)}",
            repository=repository,
            branch=branch,
            commit=commit,
            stages=[BuildStage.PENDING, BuildStage.INITIALIZING, BuildStage.FETCHING,
                    BuildStage.BUILDING, BuildStage.TESTING, BuildStage.PACKAGING,
                    BuildStage.DEPLOYING, BuildStage.COMPLETED]
        )
        self.jobs.append(job)
        logger.info(f"📋 Build job submitted: {job.id}")
        return job
    
    async def run_job(self, job: BuildJob) -> BuildJob:
        """Run a build job"""
        job.started_at = datetime.now()
        
        try:
            # Stage 1: Initialize
            job.current_stage = BuildStage.INITIALIZING
            logger.info(f"🔧 Initializing build: {job.id}")
            await self._stage_initialize(job)
            
            # Stage 2: Fetch
            job.current_stage = BuildStage.FETCHING
            logger.info(f"📦 Fetching repository: {job.repository}")
            await self._stage_fetch(job)
            
            # Stage 3: Build
            job.current_stage = BuildStage.BUILDING
            logger.info(f"🔨 Building: {job.id}")
            await self._stage_build(job)
            
            # Stage 4: Test
            job.current_stage = BuildStage.TESTING
            logger.info(f"🧪 Testing: {job.id}")
            await self._stage_test(job)
            
            # Stage 5: Package
            job.current_stage = BuildStage.PACKAGING
            logger.info(f"📦 Packaging: {job.id}")
            await self._stage_package(job)
            
            # Stage 6: Deploy
            job.current_stage = BuildStage.DEPLOYING
            logger.info(f"🚀 Deploying: {job.id}")
            await self._stage_deploy(job)
            
            job.current_stage = BuildStage.COMPLETED
            logger.info(f"✅ Build completed: {job.id}")
            
        except Exception as e:
            job.current_stage = BuildStage.FAILED
            job.error = str(e)
            logger.error(f"❌ Build failed: {job.id} — {e}")
        
        job.completed_at = datetime.now()
        return job
    
    async def _stage_initialize(self, job: BuildJob):
        """Initialize build environment"""
        job.logs.append(f"[INIT] Setting up build environment")
        
        # Create job workspace
        job_dir = os.path.join(self.workspace, job.id)
        os.makedirs(job_dir, exist_ok=True)
        
        # Create subdirectories
        for sub in ["src", "build", "dist", "test"]:
            os.makedirs(os.path.join(job_dir, sub), exist_ok=True)
        
        job.logs.append(f"[INIT] Workspace: {job_dir}")
    
    async def _stage_fetch(self, job: BuildJob):
        """Fetch repository"""
        job.logs.append(f"[FETCH] Cloning {job.repository}")
        
        job_dir = os.path.join(self.workspace, job.id, "src")
        
        # Clone repository
        try:
            result = subprocess.run(
                ["git", "clone", job.repository, job_dir],
                capture_output=True,
                text=True,
                timeout=120
            )
            if result.returncode != 0:
                raise Exception(f"Git clone failed: {result.stderr}")
            
            # Checkout branch
            subprocess.run(
                ["git", "checkout", job.branch],
                cwd=job_dir,
                capture_output=True,
                text=True
            )
            
            job.logs.append(f"[FETCH] Repository cloned to {job_dir}")
            
        except subprocess.TimeoutExpired:
            raise Exception("Git clone timeout")
    
    async def _stage_build(self, job: BuildJob):
        """Build the project"""
        job.logs.append(f"[BUILD] Building project")
        
        src_dir = os.path.join(self.workspace, job.id, "src")
        build_dir = os.path.join(self.workspace, job.id, "build")
        
        # Detect build system
        if os.path.exists(os.path.join(src_dir, "setup.py")):
            # Python project
            result = subprocess.run(
                [sys.executable, "setup.py", "build"],
                cwd=src_dir,
                capture_output=True,
                text=True,
                timeout=60
            )
            if result.returncode != 0:
                raise Exception(f"Build failed: {result.stderr}")
            job.logs.append("[BUILD] Python build completed")
            
        elif os.path.exists(os.path.join(src_dir, "package.json")):
            # Node.js project
            result = subprocess.run(
                ["npm", "install"],
                cwd=src_dir,
                capture_output=True,
                text=True,
                timeout=120
            )
            if result.returncode != 0:
                raise Exception(f"npm install failed: {result.stderr}")
            
            result = subprocess.run(
                ["npm", "run", "build"],
                cwd=src_dir,
                capture_output=True,
                text=True,
                timeout=120
            )
            if result.returncode != 0:
                raise Exception(f"npm build failed: {result.stderr}")
            
            job.logs.append("[BUILD] Node.js build completed")
            
        else:
            # Generic build - copy files
            shutil.copytree(src_dir, build_dir, dirs_exist_ok=True)
            job.logs.append("[BUILD] Generic build completed (files copied)")
    
    async def _stage_test(self, job: BuildJob):
        """Run tests"""
        job.logs.append(f"[TEST] Running tests")
        
        src_dir = os.path.join(self.workspace, job.id, "src")
        
        # Run tests
        if os.path.exists(os.path.join(src_dir, "tests")):
            result = subprocess.run(
                [sys.executable, "-m", "pytest", "tests"],
                cwd=src_dir,
                capture_output=True,
                text=True,
                timeout=60
            )
            job.logs.append(f"[TEST] Test result: {result.returncode}")
            if result.returncode != 0:
                job.logs.append(f"[TEST] Failed tests: {result.stdout}")
                # Don't fail build on test failure, just log it
        
        job.logs.append("[TEST] Tests completed")
    
    async def _stage_package(self, job: BuildJob):
        """Package the build"""
        job.logs.append(f"[PACKAGE] Packaging artifacts")
        
        src_dir = os.path.join(self.workspace, job.id, "src")
        dist_dir = os.path.join(self.workspace, job.id, "dist")
        
        # Create package
        package_path = os.path.join(dist_dir, f"{job.id}.tar.gz")
        
        import tarfile
        with tarfile.open(package_path, "w:gz") as tar:
            tar.add(src_dir, arcname="app")
        
        # Create artifact
        artifact = BuildArtifact(
            name=f"{job.id}.tar.gz",
            path=package_path,
            type="tar.gz",
            size=os.path.getsize(package_path),
            checksum=hashlib.md5(open(package_path, 'rb').read()).hexdigest()
        )
        job.artifacts.append(artifact)
        
        job.logs.append(f"[PACKAGE] Package created: {package_path}")
    
    async def _stage_deploy(self, job: BuildJob):
        """Deploy the build"""
        job.logs.append(f"[DEPLOY] Deploying artifacts")
        
        # Simulate deployment
        deploy_dir = os.path.join(self.workspace, job.id, "deploy")
        os.makedirs(deploy_dir, exist_ok=True)
        
        # Copy artifacts to deploy directory
        for artifact in job.artifacts:
            shutil.copy(artifact.path, deploy_dir)
        
        # Create deployment manifest
        manifest = {
            "job_id": job.id,
            "timestamp": datetime.now().isoformat(),
            "artifacts": [
                {
                    "name": a.name,
                    "size": a.size,
                    "checksum": a.checksum
                }
                for a in job.artifacts
            ],
            "phi5_signature": job.phi5_signature
        }
        
        manifest_path = os.path.join(deploy_dir, "manifest.json")
        with open(manifest_path, 'w') as f:
            json.dump(manifest, f, indent=2)
        
        job.logs.append(f"[DEPLOY] Deployment manifest: {manifest_path}")
    
    def get_job_status(self, job_id: str) -> Optional[Dict]:
        """Get job status"""
        for job in self.jobs:
            if job.id == job_id:
                return {
                    "id": job.id,
                    "repository": job.repository,
                    "branch": job.branch,
                    "current_stage": job.current_stage.value,
                    "artifacts": len(job.artifacts),
                    "logs": job.logs[-10:],  # Last 10 logs
                    "error": job.error,
                    "started_at": job.started_at.isoformat() if job.started_at else None,
                    "completed_at": job.completed_at.isoformat() if job.completed_at else None,
                    "phi5_signature": job.phi5_signature
                }
        return None


async def main():
    """Main entry point"""
    print("╔" + "="*78 + "╗")
    print("║" + " "*20 + "🔧 ACCIO BUILD PIPELINE v4.2" + " "*26 + "║")
    print("║" + " "*15 + "Kintegrity Labs × CodexΩ∞ × Sovereign Lattice" + " "*15 + "║")
    print("╚" + "="*78 + "╝")
    
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument("--repo", default=".", help="Repository URL or path")
    parser.add_argument("--branch", default="main", help="Branch to build")
    parser.add_argument("--status", help="Check status of a job")
    args = parser.parse_args()
    
    pipeline = AccioBuildPipeline()
    
    if args.status:
        status = pipeline.get_job_status(args.status)
        if status:
            print("\n📊 Job Status:")
            print(json.dumps(status, indent=2))
        else:
            print(f"❌ Job not found: {args.status}")
        return
    
    job = await pipeline.submit_job(args.repo, args.branch)
    await pipeline.run_job(job)
    
    print(f"\n📊 Build completed:")
    print(f"   Job ID: {job.id}")
    print(f"   Status: {job.current_stage.value}")
    print(f"   Artifacts: {len(job.artifacts)}")
    print(f"   Φ⁵: {job.phi5_signature[:50]}...")


if __name__ == "__main__":
    asyncio.run(main())