package server

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"time"

	"github.com/chorus-services/whoosh/internal/backbeat"
	"github.com/chorus-services/whoosh/internal/config"
	"github.com/chorus-services/whoosh/internal/database"
	"github.com/chorus-services/whoosh/internal/gitea"
	"github.com/chorus-services/whoosh/internal/p2p"
	"github.com/go-chi/chi/v5"
	"github.com/go-chi/chi/v5/middleware"
	"github.com/go-chi/cors"
	"github.com/go-chi/render"
	"github.com/rs/zerolog/log"
)

type Server struct {
	config         *config.Config
	db             *database.DB
	httpServer     *http.Server
	router         chi.Router
	giteaClient    *gitea.Client
	webhookHandler *gitea.WebhookHandler
	p2pDiscovery   *p2p.Discovery
	backbeat       *backbeat.Integration
}

func NewServer(cfg *config.Config, db *database.DB) (*Server, error) {
	s := &Server{
		config:         cfg,
		db:             db,
		giteaClient:    gitea.NewClient(cfg.GITEA),
		webhookHandler: gitea.NewWebhookHandler(cfg.GITEA.WebhookToken),
		p2pDiscovery:   p2p.NewDiscovery(),
	}

	// Initialize BACKBEAT integration if enabled
	if cfg.BACKBEAT.Enabled {
		backbeatIntegration, err := backbeat.NewIntegration(&cfg.BACKBEAT)
		if err != nil {
			return nil, fmt.Errorf("failed to create BACKBEAT integration: %w", err)
		}
		s.backbeat = backbeatIntegration
	}

	s.setupRouter()
	s.setupRoutes()

	s.httpServer = &http.Server{
		Addr:         cfg.Server.ListenAddr,
		Handler:      s.router,
		ReadTimeout:  cfg.Server.ReadTimeout,
		WriteTimeout: cfg.Server.WriteTimeout,
	}

	return s, nil
}

func (s *Server) setupRouter() {
	r := chi.NewRouter()

	// Middleware
	r.Use(middleware.RequestID)
	r.Use(middleware.RealIP)
	r.Use(middleware.Logger)
	r.Use(middleware.Recoverer)
	r.Use(middleware.Timeout(30 * time.Second))

	// CORS configuration
	r.Use(cors.Handler(cors.Options{
		AllowedOrigins:   []string{"*"},
		AllowedMethods:   []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
		AllowedHeaders:   []string{"*"},
		ExposedHeaders:   []string{"Link"},
		AllowCredentials: true,
		MaxAge:           300,
	}))

	// Content-Type handling
	r.Use(render.SetContentType(render.ContentTypeJSON))

	s.router = r
}

func (s *Server) setupRoutes() {
	// Root route - serve basic dashboard
	s.router.Get("/", s.dashboardHandler)
	
	// Health check endpoints
	s.router.Get("/health", s.healthHandler)
	s.router.Get("/health/ready", s.readinessHandler)

	// API v1 routes
	s.router.Route("/api/v1", func(r chi.Router) {
		// MVP endpoints - minimal team management
		r.Route("/teams", func(r chi.Router) {
			r.Get("/", s.listTeamsHandler)
			r.Post("/", s.createTeamHandler)
			r.Get("/{teamID}", s.getTeamHandler)
			r.Put("/{teamID}/status", s.updateTeamStatusHandler)
		})

		// Task ingestion from GITEA
		r.Route("/tasks", func(r chi.Router) {
			r.Get("/", s.listTasksHandler)
			r.Post("/ingest", s.ingestTaskHandler)
			r.Get("/{taskID}", s.getTaskHandler)
		})

		// Project management endpoints
		r.Route("/projects", func(r chi.Router) {
			r.Get("/", s.listProjectsHandler)
			r.Post("/", s.createProjectHandler)
			r.Delete("/{projectID}", s.deleteProjectHandler)
			
			r.Route("/{projectID}", func(r chi.Router) {
				r.Get("/", s.getProjectHandler)
				r.Get("/tasks", s.listProjectTasksHandler)
				r.Get("/tasks/available", s.listAvailableTasksHandler)
				r.Get("/repository", s.getProjectRepositoryHandler)
				r.Post("/analyze", s.analyzeProjectHandler)
				
				r.Route("/tasks/{taskNumber}", func(r chi.Router) {
					r.Get("/", s.getProjectTaskHandler)
					r.Post("/claim", s.claimTaskHandler)
					r.Put("/status", s.updateTaskStatusHandler)
					r.Post("/complete", s.completeTaskHandler)
				})
			})
		})

		// Agent registration endpoints
		r.Route("/agents", func(r chi.Router) {
			r.Get("/", s.listAgentsHandler)
			r.Post("/register", s.registerAgentHandler)
			r.Put("/{agentID}/status", s.updateAgentStatusHandler)
		})

		// SLURP proxy endpoints
		r.Route("/slurp", func(r chi.Router) {
			r.Post("/submit", s.slurpSubmitHandler)
			r.Get("/artifacts/{ucxlAddr}", s.slurpRetrieveHandler)
		})
	})

	// GITEA webhook endpoint
	s.router.Post(s.config.GITEA.WebhookPath, s.giteaWebhookHandler)
}

func (s *Server) Start(ctx context.Context) error {
	// Start BACKBEAT integration if enabled
	if s.backbeat != nil {
		if err := s.backbeat.Start(ctx); err != nil {
			return fmt.Errorf("failed to start BACKBEAT integration: %w", err)
		}
	}

	// Start P2P discovery service
	if err := s.p2pDiscovery.Start(); err != nil {
		return fmt.Errorf("failed to start P2P discovery: %w", err)
	}
	
	log.Info().
		Str("addr", s.httpServer.Addr).
		Msg("HTTP server starting")

	if err := s.httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
		return fmt.Errorf("server failed to start: %w", err)
	}

	return nil
}

func (s *Server) Shutdown(ctx context.Context) error {
	log.Info().Msg("HTTP server shutting down")

	// Stop BACKBEAT integration
	if s.backbeat != nil {
		if err := s.backbeat.Stop(); err != nil {
			log.Error().Err(err).Msg("Failed to stop BACKBEAT integration")
		}
	}

	// Stop P2P discovery service
	if err := s.p2pDiscovery.Stop(); err != nil {
		log.Error().Err(err).Msg("Failed to stop P2P discovery service")
	}

	if err := s.httpServer.Shutdown(ctx); err != nil {
		return fmt.Errorf("server shutdown failed: %w", err)
	}

	return nil
}

// Health check handlers
func (s *Server) healthHandler(w http.ResponseWriter, r *http.Request) {
	response := map[string]interface{}{
		"status":  "ok",
		"service": "whoosh",
		"version": "0.1.0-mvp",
	}
	
	// Include BACKBEAT health information if available
	if s.backbeat != nil {
		response["backbeat"] = s.backbeat.GetHealth()
	}
	
	render.JSON(w, r, response)
}

func (s *Server) readinessHandler(w http.ResponseWriter, r *http.Request) {
	ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
	defer cancel()

	// Check database connection
	if err := s.db.Health(ctx); err != nil {
		log.Error().Err(err).Msg("Database health check failed")
		render.Status(r, http.StatusServiceUnavailable)
		render.JSON(w, r, map[string]string{
			"status": "unavailable",
			"error":  "database connection failed",
		})
		return
	}

	render.JSON(w, r, map[string]string{
		"status":   "ready",
		"database": "connected",
	})
}

// MVP handlers for team and task management
func (s *Server) listTeamsHandler(w http.ResponseWriter, r *http.Request) {
	// For now, return empty array - will be populated as teams are created
	teams := []map[string]interface{}{
		// Example team structure for future implementation
		// {
		//     "id": "team-001",
		//     "name": "Backend Development Team",
		//     "status": "active",
		//     "members": []string{"agent-go-dev", "agent-reviewer"},
		//     "current_task": "task-123",
		//     "created_at": time.Now().Format(time.RFC3339),
		// }
	}
	render.JSON(w, r, teams)
}

func (s *Server) createTeamHandler(w http.ResponseWriter, r *http.Request) {
	render.Status(r, http.StatusNotImplemented)
	render.JSON(w, r, map[string]string{"error": "not implemented"})
}

func (s *Server) getTeamHandler(w http.ResponseWriter, r *http.Request) {
	render.Status(r, http.StatusNotImplemented)
	render.JSON(w, r, map[string]string{"error": "not implemented"})
}

func (s *Server) updateTeamStatusHandler(w http.ResponseWriter, r *http.Request) {
	render.Status(r, http.StatusNotImplemented)
	render.JSON(w, r, map[string]string{"error": "not implemented"})
}

func (s *Server) listTasksHandler(w http.ResponseWriter, r *http.Request) {
	// Get query parameters
	status := r.URL.Query().Get("status") // active, queued, completed
	if status == "" {
		status = "all"
	}

	// For MVP, we'll simulate task data that would come from GITEA issues
	// In full implementation, this would query GITEA API for bzzz-task issues
	tasks := []map[string]interface{}{
		{
			"id":          "task-001",
			"title":       "Implement user authentication system",
			"description": "Add JWT-based authentication with login and registration endpoints",
			"status":      "active",
			"priority":    "high",
			"repository":  "example/backend-api",
			"issue_url":   "https://gitea.chorus.services/example/backend-api/issues/1",
			"assigned_to": "team-001",
			"created_at":  "2025-09-03T20:00:00Z",
			"updated_at":  "2025-09-04T00:00:00Z",
			"labels":      []string{"bzzz-task", "backend", "security"},
		},
		{
			"id":          "task-002", 
			"title":       "Fix database connection pooling",
			"description": "Connection pool is not releasing connections properly under high load",
			"status":      "queued",
			"priority":    "medium",
			"repository":  "example/backend-api",
			"issue_url":   "https://gitea.chorus.services/example/backend-api/issues/2",
			"assigned_to": nil,
			"created_at":  "2025-09-04T00:15:00Z",
			"updated_at":  "2025-09-04T00:15:00Z",
			"labels":      []string{"bzzz-task", "database", "performance"},
		},
	}

	// Filter tasks by status if specified
	if status != "all" {
		filtered := []map[string]interface{}{}
		for _, task := range tasks {
			if task["status"] == status {
				filtered = append(filtered, task)
			}
		}
		tasks = filtered
	}

	render.JSON(w, r, map[string]interface{}{
		"tasks": tasks,
		"total": len(tasks),
		"status": status,
	})
}

func (s *Server) ingestTaskHandler(w http.ResponseWriter, r *http.Request) {
	render.Status(r, http.StatusNotImplemented)
	render.JSON(w, r, map[string]string{"error": "not implemented"})
}

func (s *Server) getTaskHandler(w http.ResponseWriter, r *http.Request) {
	render.Status(r, http.StatusNotImplemented)
	render.JSON(w, r, map[string]string{"error": "not implemented"})
}

func (s *Server) slurpSubmitHandler(w http.ResponseWriter, r *http.Request) {
	render.Status(r, http.StatusNotImplemented)
	render.JSON(w, r, map[string]string{"error": "not implemented"})
}

func (s *Server) slurpRetrieveHandler(w http.ResponseWriter, r *http.Request) {
	render.Status(r, http.StatusNotImplemented)
	render.JSON(w, r, map[string]string{"error": "not implemented"})
}

// CHORUS Integration Handlers

func (s *Server) listProjectTasksHandler(w http.ResponseWriter, r *http.Request) {
	render.Status(r, http.StatusNotImplemented)
	render.JSON(w, r, map[string]string{"error": "not implemented"})
}

func (s *Server) listAvailableTasksHandler(w http.ResponseWriter, r *http.Request) {
	render.Status(r, http.StatusNotImplemented)
	render.JSON(w, r, map[string]string{"error": "not implemented"})
}

func (s *Server) getProjectRepositoryHandler(w http.ResponseWriter, r *http.Request) {
	render.Status(r, http.StatusNotImplemented)
	render.JSON(w, r, map[string]string{"error": "not implemented"})
}

func (s *Server) getProjectTaskHandler(w http.ResponseWriter, r *http.Request) {
	render.Status(r, http.StatusNotImplemented)
	render.JSON(w, r, map[string]string{"error": "not implemented"})
}

func (s *Server) claimTaskHandler(w http.ResponseWriter, r *http.Request) {
	render.Status(r, http.StatusNotImplemented)
	render.JSON(w, r, map[string]string{"error": "not implemented"})
}

func (s *Server) updateTaskStatusHandler(w http.ResponseWriter, r *http.Request) {
	render.Status(r, http.StatusNotImplemented)
	render.JSON(w, r, map[string]string{"error": "not implemented"})
}

func (s *Server) completeTaskHandler(w http.ResponseWriter, r *http.Request) {
	render.Status(r, http.StatusNotImplemented)
	render.JSON(w, r, map[string]string{"error": "not implemented"})
}

func (s *Server) listAgentsHandler(w http.ResponseWriter, r *http.Request) {
	// Get discovered CHORUS agents from P2P discovery
	discoveredAgents := s.p2pDiscovery.GetAgents()
	
	// Convert to API format
	agents := make([]map[string]interface{}, 0, len(discoveredAgents))
	onlineCount := 0
	idleCount := 0
	offlineCount := 0
	
	for _, agent := range discoveredAgents {
		agentData := map[string]interface{}{
			"id":           agent.ID,
			"name":         agent.Name,
			"status":       agent.Status,
			"capabilities": agent.Capabilities,
			"model":        agent.Model,
			"endpoint":     agent.Endpoint,
			"last_seen":    agent.LastSeen.Format(time.RFC3339),
			"tasks_completed": agent.TasksCompleted,
			"p2p_addr":     agent.P2PAddr,
			"cluster_id":   agent.ClusterID,
		}
		
		// Add current team if present
		if agent.CurrentTeam != "" {
			agentData["current_team"] = agent.CurrentTeam
		} else {
			agentData["current_team"] = nil
		}
		
		agents = append(agents, agentData)
		
		// Count status
		switch agent.Status {
		case "online":
			onlineCount++
		case "idle":
			idleCount++
		case "working":
			onlineCount++ // Working agents are considered online
		default:
			offlineCount++
		}
	}

	render.JSON(w, r, map[string]interface{}{
		"agents":  agents,
		"total":   len(agents),
		"online":  onlineCount,
		"idle":    idleCount,
		"offline": offlineCount,
	})
}

func (s *Server) registerAgentHandler(w http.ResponseWriter, r *http.Request) {
	render.Status(r, http.StatusNotImplemented)
	render.JSON(w, r, map[string]string{"error": "not implemented"})
}

func (s *Server) updateAgentStatusHandler(w http.ResponseWriter, r *http.Request) {
	render.Status(r, http.StatusNotImplemented)
	render.JSON(w, r, map[string]string{"error": "not implemented"})
}

// Project Management Handlers

func (s *Server) listProjectsHandler(w http.ResponseWriter, r *http.Request) {
	// For MVP, return hardcoded projects list
	// In full implementation, this would query database
	projects := []map[string]interface{}{
		{
			"id":          "whoosh-001",
			"name":        "WHOOSH",
			"repo_url":    "https://gitea.chorus.services/tony/WHOOSH",
			"description": "Autonomous AI Development Teams Architecture",
			"tech_stack":  []string{"Go", "Docker", "PostgreSQL"},
			"status":      "active",
			"created_at":  "2025-09-04T00:00:00Z",
			"team_size":   3,
		},
		{
			"id":          "chorus-001", 
			"name":        "CHORUS",
			"repo_url":    "https://gitea.chorus.services/tony/CHORUS",
			"description": "AI Agent P2P Coordination System",
			"tech_stack":  []string{"Go", "P2P", "LibP2P"},
			"status":      "active",
			"created_at":  "2025-09-03T00:00:00Z",
			"team_size":   2,
		},
	}

	render.JSON(w, r, map[string]interface{}{
		"projects": projects,
		"total":    len(projects),
	})
}

// createProjectHandler handles POST /api/projects requests to add new GITEA repositories
// for team composition analysis. This is the core MVP functionality that allows users
// to register repositories that will be analyzed by the N8N workflow.
//
// Implementation decision: We use an anonymous struct for the request payload rather than
// a named struct because this is a simple, internal API that doesn't need to be shared
// across packages. This reduces complexity while maintaining type safety.
//
// TODO: In production, this would persist to PostgreSQL database rather than just
// returning in-memory data. The database integration is prepared in the docker-compose
// but not yet implemented in the handlers.
func (s *Server) createProjectHandler(w http.ResponseWriter, r *http.Request) {
	// Anonymous struct for request payload - simpler than defining a separate type
	// for this single-use case. Contains the minimal required fields for MVP.
	var req struct {
		Name        string `json:"name"`        // User-friendly project name
		RepoURL     string `json:"repo_url"`    // GITEA repository URL for analysis
		Description string `json:"description"` // Optional project description
	}

	// Use json.NewDecoder instead of render.Bind because render.Bind requires
	// implementing the render.Binder interface, which adds unnecessary complexity
	// for simple JSON parsing. Direct JSON decoding is more straightforward.
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid request"})
		return
	}

	// Basic validation - both name and repo_url are required for meaningful analysis.
	// The N8N workflow needs the repo URL to fetch files, and we need a name for UI display.
	if req.RepoURL == "" || req.Name == "" {
		render.Status(r, http.StatusBadRequest) 
		render.JSON(w, r, map[string]string{"error": "name and repo_url are required"})
		return
	}

	// Generate unique project ID using Unix timestamp. In production, this would be
	// a proper UUID or database auto-increment, but for MVP simplicity, timestamp-based
	// IDs are sufficient and provide natural ordering.
	projectID := fmt.Sprintf("proj-%d", time.Now().Unix())
	
	// Project data structure matches the expected format for the frontend UI.
	// Status "created" indicates the project is registered but not yet analyzed.
	// This will be updated to "analyzing" -> "completed" by the N8N workflow.
	project := map[string]interface{}{
		"id":          projectID,
		"name":        req.Name,
		"repo_url":    req.RepoURL,
		"description": req.Description,
		"status":      "created",
		"created_at":  time.Now().Format(time.RFC3339),
		"team_size":   0, // Will be populated after N8N analysis
	}

	// Structured logging with zerolog provides excellent performance and
	// searchability in production environments. Include key identifiers
	// for debugging and audit trails.
	log.Info().
		Str("project_id", projectID).
		Str("repo_url", req.RepoURL).
		Msg("Created new project")

	// Return 201 Created with the project data. The frontend will use this
	// response to update the UI and potentially trigger immediate analysis.
	render.Status(r, http.StatusCreated)
	render.JSON(w, r, project)
}

// deleteProjectHandler handles DELETE /api/projects/{projectID} requests to remove
// repositories from management. This allows users to clean up their project list
// and stop monitoring repositories that are no longer relevant.
//
// Implementation decision: We use chi.URLParam to extract the project ID from the
// URL path rather than query parameters, following REST conventions where the
// resource identifier is part of the path structure.
func (s *Server) deleteProjectHandler(w http.ResponseWriter, r *http.Request) {
	// Extract project ID from URL path parameter. Chi router handles the parsing
	// and validation of the URL structure, so we can safely assume this exists
	// if the route matched.
	projectID := chi.URLParam(r, "projectID")
	
	// Log the deletion for audit purposes. In a production system, you'd want
	// to track who deleted what and when for compliance and debugging.
	log.Info().
		Str("project_id", projectID).
		Msg("Deleted project")
	
	render.JSON(w, r, map[string]string{"message": "project deleted"})
}

// getProjectHandler handles GET /api/projects/{projectID} requests to retrieve
// detailed information about a specific project, including its analysis results
// and team formation recommendations from the N8N workflow.
//
// Implementation decision: We return mock data for now since database persistence
// isn't implemented yet. In production, this would query PostgreSQL for the
// actual project record and its associated analysis results.
func (s *Server) getProjectHandler(w http.ResponseWriter, r *http.Request) {
	projectID := chi.URLParam(r, "projectID")
	
	// TODO: Replace with database query - this mock data demonstrates the expected
	// response structure that the frontend UI will consume. The tech_stack and
	// team_size fields would be populated by N8N workflow analysis results.
	project := map[string]interface{}{
		"id":          projectID,
		"name":        "Sample Project",
		"repo_url":    "https://gitea.chorus.services/tony/" + projectID,
		"description": "Sample project description",
		"tech_stack":  []string{"Go", "JavaScript"}, // From N8N analysis
		"status":      "active",
		"created_at":  "2025-09-04T00:00:00Z",
		"team_size":   2, // From N8N team formation recommendations
	}

	render.JSON(w, r, project)
}

// analyzeProjectHandler handles POST /api/projects/{projectID}/analyze requests to
// trigger the N8N Team Formation Analysis workflow. This is the core integration point
// that connects WHOOSH to the AI-powered repository analysis system.
//
// Implementation decisions:
// 1. 60-second timeout for N8N requests because LLM analysis can be slow
// 2. Direct HTTP client rather than a service layer for simplicity in MVP
// 3. Graceful fallback to mock data when request body is empty
// 4. Comprehensive error handling with structured logging for debugging
//
// This handler represents the "missing link" that was identified as the core need:
// WHOOSH UI → N8N workflow → LLM analysis → team formation recommendations
func (s *Server) analyzeProjectHandler(w http.ResponseWriter, r *http.Request) {
	projectID := chi.URLParam(r, "projectID")
	
	// Project data structure for N8N payload. In production, this would be fetched
	// from the database using the projectID, but for MVP we allow it to be provided
	// in the request body or fall back to predictable mock data.
	var projectData struct {
		RepoURL string `json:"repo_url"`
		Name    string `json:"name"`
	}
	
	// Handle both scenarios: explicit project data in request body (for testing)
	// and implicit data fetching (for production UI). This flexibility makes the
	// API easier to test manually while supporting the intended UI workflow.
	if r.Body != http.NoBody {
		if err := json.NewDecoder(r.Body).Decode(&projectData); err != nil {
			// Fallback to predictable mock data based on projectID for testing
			projectData.RepoURL = "https://gitea.chorus.services/tony/" + projectID
			projectData.Name = projectID
		}
	} else {
		// No body provided - use mock data (in production, would query database)
		projectData.RepoURL = "https://gitea.chorus.services/tony/" + projectID
		projectData.Name = projectID
	}

	// Start BACKBEAT search tracking if available
	searchID := fmt.Sprintf("analyze-%s", projectID)
	if s.backbeat != nil {
		if err := s.backbeat.StartSearch(searchID, fmt.Sprintf("Analyzing project %s (%s)", projectID, projectData.RepoURL), 4); err != nil {
			log.Warn().Err(err).Msg("Failed to start BACKBEAT search tracking")
		}
	}

	// Log the analysis initiation for debugging and audit trails. Repository URL
	// is crucial for troubleshooting N8N workflow issues.
	log.Info().
		Str("project_id", projectID).
		Str("repo_url", projectData.RepoURL).
		Msg("🔍 Starting project analysis via N8N workflow with BACKBEAT tracking")

	// Execute analysis within BACKBEAT beat budget (4 beats = 2 minutes at 2 BPM)
	var analysisResult map[string]interface{}
	analysisFunc := func() error {
		// Update BACKBEAT phase to querying
		if s.backbeat != nil {
			s.backbeat.UpdateSearchPhase(searchID, backbeat.PhaseQuerying, 0)
		}
		
		// HTTP client with generous timeout because:
		// 1. N8N workflow fetches multiple files from repository
		// 2. LLM analysis (Ollama) can take 10-30 seconds depending on model size
		// 3. Network latency between services in Docker Swarm
		// 60 seconds provides buffer while still failing fast for real issues
		client := &http.Client{Timeout: 60 * time.Second}
		
		// Payload structure matches the N8N workflow webhook expectations.
		// The workflow expects these exact field names to properly route data
		// through the file fetching and analysis nodes.
		payload := map[string]interface{}{
			"repo_url":     projectData.RepoURL,  // Primary input for file fetching
			"project_name": projectData.Name,     // Used in LLM analysis context
		}
		
		// JSON marshaling without error checking is acceptable here because we control
		// the payload structure and know it will always be valid JSON.
		payloadBytes, _ := json.Marshal(payload)
		
		// Direct call to production N8N instance. In a more complex system, this URL
		// would be configurable, but for MVP we can hardcode the known endpoint.
		// The webhook URL was configured when we created the N8N workflow.
		resp, err := client.Post(
			"https://n8n.home.deepblack.cloud/webhook/team-formation",
			"application/json",
			bytes.NewBuffer(payloadBytes),
		)
		
		// Network-level error handling (connection refused, timeout, DNS issues)
		if err != nil {
			log.Error().Err(err).Msg("Failed to trigger N8N workflow")
			return fmt.Errorf("failed to trigger N8N workflow: %w", err)
		}
		defer resp.Body.Close()
		
		// HTTP-level error handling (N8N returned an error status)
		if resp.StatusCode != http.StatusOK {
			log.Error().
				Int("status", resp.StatusCode).
				Msg("N8N workflow returned error")
			return fmt.Errorf("N8N workflow returned status %d", resp.StatusCode)
		}
		
		// Update BACKBEAT phase to ranking
		if s.backbeat != nil {
			s.backbeat.UpdateSearchPhase(searchID, backbeat.PhaseRanking, 0)
		}
		
		// Read the N8N workflow response, which contains the team formation analysis
		// results including detected technologies, complexity scores, and agent assignments.
		body, err := io.ReadAll(resp.Body)
		if err != nil {
			log.Error().Err(err).Msg("Failed to read N8N response")
			return fmt.Errorf("failed to read N8N response: %w", err)
		}
		
		// Parse and return N8N response
		if err := json.Unmarshal(body, &analysisResult); err != nil {
			log.Error().Err(err).Msg("Failed to parse N8N response")
			return fmt.Errorf("failed to parse N8N response: %w", err)
		}
		
		return nil
	}
	
	// Execute analysis with BACKBEAT beat budget or fallback to direct execution
	var analysisErr error
	if s.backbeat != nil {
		analysisErr = s.backbeat.ExecuteWithBeatBudget(4, analysisFunc)
		if analysisErr != nil {
			s.backbeat.FailSearch(searchID, analysisErr.Error())
		}
	} else {
		analysisErr = analysisFunc()
	}
	
	if analysisErr != nil {
		render.Status(r, http.StatusInternalServerError)
		render.JSON(w, r, map[string]string{"error": analysisErr.Error()})
		return
	}
	
	// Complete BACKBEAT search tracking
	if s.backbeat != nil {
		s.backbeat.CompleteSearch(searchID, 1)
	}
	
	log.Info().
		Str("project_id", projectID).
		Msg("🔍 Project analysis completed successfully with BACKBEAT tracking")
	
	render.JSON(w, r, analysisResult)
}

func (s *Server) giteaWebhookHandler(w http.ResponseWriter, r *http.Request) {
	// Parse webhook payload
	payload, err := s.webhookHandler.ParsePayload(r)
	if err != nil {
		log.Error().Err(err).Msg("Failed to parse webhook payload")
		render.Status(r, http.StatusBadRequest)
		render.JSON(w, r, map[string]string{"error": "invalid payload"})
		return
	}

	log.Info().
		Str("action", payload.Action).
		Str("repository", payload.Repository.FullName).
		Str("sender", payload.Sender.Login).
		Msg("Received GITEA webhook")

	// Process webhook event
	event := s.webhookHandler.ProcessWebhook(payload)

	// Handle task-related webhooks
	if event.TaskInfo != nil {
		log.Info().
			Interface("task_info", event.TaskInfo).
			Msg("Processing task issue")

		// MVP: Store basic task info for future team assignment
		// In full implementation, this would trigger Team Composer
		s.handleTaskWebhook(r.Context(), event)
	}

	render.JSON(w, r, map[string]interface{}{
		"status":    "received",
		"event_id":  event.Timestamp,
		"processed": event.TaskInfo != nil,
	})
}

func (s *Server) handleTaskWebhook(ctx context.Context, event *gitea.WebhookEvent) {
	// MVP implementation: Log task details
	// In full version, this would:
	// 1. Analyze task complexity
	// 2. Determine required team composition
	// 3. Create team and assign agents
	// 4. Set up P2P communication channels

	log.Info().
		Str("action", event.Action).
		Str("repository", event.Repository).
		Interface("task_info", event.TaskInfo).
		Msg("Task webhook received - MVP logging")

	// For MVP, we'll just acknowledge task detection
	if event.Action == "opened" || event.Action == "reopened" {
		taskType := event.TaskInfo["task_type"].(string)
		priority := event.TaskInfo["priority"].(string)
		
		log.Info().
			Str("task_type", taskType).
			Str("priority", priority).
			Msg("New task detected - ready for team assignment")
	}
}

func (s *Server) dashboardHandler(w http.ResponseWriter, r *http.Request) {
	html := `<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>WHOOSH - AI Team Orchestration</title>
    <style>
        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; margin: 0; padding: 0; background: #f8fafc; }
        .header { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 20px 0; }
        .header-content { max-width: 1200px; margin: 0 auto; padding: 0 20px; display: flex; justify-content: space-between; align-items: center; }
        .logo { font-size: 24px; font-weight: bold; }
        .status-dot { width: 12px; height: 12px; border-radius: 50%; background: #27ae60; margin-right: 8px; display: inline-block; }
        .nav-tabs { max-width: 1200px; margin: 0 auto; padding: 0 20px; display: flex; border-bottom: 1px solid #e2e8f0; background: white; }
        .nav-tab { padding: 15px 25px; cursor: pointer; border-bottom: 3px solid transparent; font-weight: 500; transition: all 0.2s; }
        .nav-tab.active { border-bottom-color: #667eea; color: #667eea; background: #f8fafc; }
        .nav-tab:hover { background: #f1f5f9; }
        .content { max-width: 1200px; margin: 0 auto; padding: 20px; }
        .tab-content { display: none; }
        .tab-content.active { display: block; }
        .dashboard-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(350px, 1fr)); gap: 20px; margin-bottom: 30px; }
        .card { background: white; border-radius: 12px; padding: 24px; box-shadow: 0 2px 8px rgba(0,0,0,0.1); border: 1px solid #e2e8f0; }
        .card h3 { margin: 0 0 16px 0; color: #1a202c; font-size: 18px; display: flex; align-items: center; }
        .card-icon { width: 20px; height: 20px; margin-right: 12px; }
        .metric { display: flex; justify-content: space-between; margin: 8px 0; padding: 8px 0; }
        .metric:not(:last-child) { border-bottom: 1px solid #f7fafc; }
        .metric-label { color: #718096; }
        .metric-value { font-weight: 600; color: #2d3748; }
        .task-item { background: #f8fafc; border-radius: 8px; padding: 16px; margin-bottom: 12px; border-left: 4px solid #e2e8f0; }
        .task-item.priority-high { border-left-color: #e53e3e; }
        .task-item.priority-medium { border-left-color: #dd6b20; }
        .task-item.priority-low { border-left-color: #38a169; }
        .task-title { font-weight: 600; color: #2d3748; margin-bottom: 8px; }
        .task-meta { display: flex; justify-content: space-between; color: #718096; font-size: 14px; }
        .agent-card { background: #f8fafc; border-radius: 8px; padding: 16px; margin-bottom: 12px; }
        .agent-status { width: 8px; height: 8px; border-radius: 50%; margin-right: 8px; display: inline-block; }
        .agent-status.online { background: #38a169; }
        .agent-status.offline { background: #a0aec0; }
        .team-member { display: flex; align-items: center; padding: 8px; background: white; border-radius: 6px; margin-bottom: 8px; }
        .btn { padding: 8px 16px; border-radius: 6px; border: none; font-weight: 500; cursor: pointer; transition: all 0.2s; }
        .btn-primary { background: #667eea; color: white; }
        .btn-primary:hover { background: #5a6fd8; }
        .btn-secondary { background: #e2e8f0; color: #4a5568; }
        .btn-secondary:hover { background: #cbd5e0; }
        .empty-state { text-align: center; padding: 40px 20px; color: #718096; }
        .empty-state-icon { font-size: 48px; margin-bottom: 16px; }
    </style>
</head>
<body>
    <div class="header">
        <div class="header-content">
            <div class="logo">🎭 WHOOSH</div>
            <div style="display: flex; align-items: center;">
                <span class="status-dot"></span>
                <span>System Online</span>
            </div>
        </div>
    </div>
    
    <div class="nav-tabs">
        <div class="nav-tab active" onclick="showTab('overview')">Overview</div>
        <div class="nav-tab" onclick="showTab('tasks')">Tasks</div>
        <div class="nav-tab" onclick="showTab('teams')">Teams</div>
        <div class="nav-tab" onclick="showTab('agents')">Agents</div>
        <div class="nav-tab" onclick="showTab('settings')">Settings</div>
    </div>
    
    <div class="content">
        <!-- Overview Tab -->
        <div id="overview" class="tab-content active">
            <div class="dashboard-grid">
                <div class="card">
                    <h3>📊 System Metrics</h3>
                    <div class="metric">
                        <span class="metric-label">Active Teams</span>
                        <span class="metric-value">0</span>
                    </div>
                    <div class="metric">
                        <span class="metric-label">Pending Tasks</span>
                        <span class="metric-value" data-metric="pending-tasks">0</span>
                    </div>
                    <div class="metric">
                        <span class="metric-label">Registered Agents</span>
                        <span class="metric-value" data-metric="registered-agents">0</span>
                    </div>
                    <div class="metric">
                        <span class="metric-label">Tasks Completed Today</span>
                        <span class="metric-value">0</span>
                    </div>
                </div>
                
                <div class="card">
                    <h3>🔄 Recent Activity</h3>
                    <div class="empty-state">
                        <div class="empty-state-icon">📭</div>
                        <p>No recent activity</p>
                        <p style="font-size: 14px;">Task activity will appear here once agents start working</p>
                    </div>
                </div>
                
                <div class="card">
                    <h3>🎯 System Status</h3>
                    <div class="metric">
                        <span class="metric-label">Service Health</span>
                        <span class="metric-value" style="color: #38a169;">✅ Healthy</span>
                    </div>
                    <div class="metric">
                        <span class="metric-label">Database</span>
                        <span class="metric-value" style="color: #38a169;">✅ Connected</span>
                    </div>
                    <div class="metric">
                        <span class="metric-label">GITEA Integration</span>
                        <span class="metric-value" style="color: #38a169;">✅ Active</span>
                    </div>
                    <div class="metric">
                        <span class="metric-label">Redis Cache</span>
                        <span class="metric-value" style="color: #38a169;">✅ Running</span>
                    </div>
                </div>
            </div>
        </div>
        
        <!-- Tasks Tab -->
        <div id="tasks" class="tab-content">
            <div style="display: flex; justify-content: between; align-items: center; margin-bottom: 20px;">
                <h2>📋 Task Management</h2>
                <button class="btn btn-primary" onclick="refreshTasks()">🔄 Refresh Tasks</button>
            </div>
            
            <div class="dashboard-grid">
                <div class="card">
                    <h3>🎯 Active Tasks</h3>
                    <div id="active-tasks">
                        <div class="empty-state">
                            <div class="empty-state-icon">📝</div>
                            <p>No active tasks</p>
                            <p style="font-size: 14px;">bzzz-task issues will appear here from GITEA</p>
                        </div>
                    </div>
                </div>
                
                <div class="card">
                    <h3>⏳ Task Queue</h3>
                    <div id="queued-tasks">
                        <div class="empty-state">
                            <div class="empty-state-icon">⏱️</div>
                            <p>No queued tasks</p>
                            <p style="font-size: 14px;">Tasks awaiting team assignment</p>
                        </div>
                    </div>
                </div>
            </div>
        </div>
        
        <!-- Teams Tab -->
        <div id="teams" class="tab-content">
            <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 20px;">
                <h2>👥 Team Management</h2>
                <button class="btn btn-primary" onclick="createTeam()">➕ Create Team</button>
            </div>
            
            <div id="teams-grid" class="dashboard-grid">
                <div class="card">
                    <div class="empty-state">
                        <div class="empty-state-icon">👥</div>
                        <p>No active teams</p>
                        <p style="font-size: 14px;">AI development teams will be formed automatically for new tasks</p>
                        <button class="btn btn-secondary" style="margin-top: 12px;" onclick="createTeam()">Create Manual Team</button>
                    </div>
                </div>
            </div>
        </div>
        
        <!-- Agents Tab -->
        <div id="agents" class="tab-content">
            <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 20px;">
                <h2>🤖 Agent Management</h2>
                <button class="btn btn-primary" onclick="registerAgent()">➕ Register Agent</button>
            </div>
            
            <div id="agents-grid" class="dashboard-grid">
                <div class="card">
                    <div class="empty-state">
                        <div class="empty-state-icon">🤖</div>
                        <p>No registered agents</p>
                        <p style="font-size: 14px;">Register CHORUS agents to participate in development teams</p>
                        <button class="btn btn-secondary" style="margin-top: 12px;" onclick="registerAgent()">Register First Agent</button>
                    </div>
                </div>
            </div>
        </div>
        
        <!-- Settings Tab -->
        <div id="settings" class="tab-content">
            <h2>⚙️ System Configuration</h2>
            <div class="dashboard-grid">
                <div class="card">
                    <h3>🔗 GITEA Integration</h3>
                    <div class="metric">
                        <span class="metric-label">Base URL</span>
                        <span class="metric-value">gitea.chorus.services</span>
                    </div>
                    <div class="metric">
                        <span class="metric-label">Webhook Path</span>
                        <span class="metric-value">/webhooks/gitea</span>
                    </div>
                    <div class="metric">
                        <span class="metric-label">Token Status</span>
                        <span class="metric-value" style="color: #38a169;">✅ Valid</span>
                    </div>
                </div>
                
                <div class="card">
                    <h3>🗄️ Database Configuration</h3>
                    <div class="metric">
                        <span class="metric-label">Host</span>
                        <span class="metric-value">postgres:5432</span>
                    </div>
                    <div class="metric">
                        <span class="metric-label">SSL Mode</span>
                        <span class="metric-value">disabled</span>
                    </div>
                    <div class="metric">
                        <span class="metric-label">Auto-Migrate</span>
                        <span class="metric-value">enabled</span>
                    </div>
                </div>
            </div>
        </div>
    </div>

    <script>
        function showTab(tabName) {
            // Hide all tab contents
            document.querySelectorAll('.tab-content').forEach(content => {
                content.classList.remove('active');
            });
            
            // Remove active class from all tabs
            document.querySelectorAll('.nav-tab').forEach(tab => {
                tab.classList.remove('active');
            });
            
            // Show selected tab content
            document.getElementById(tabName).classList.add('active');
            
            // Add active class to clicked tab
            event.target.classList.add('active');
            
            // Load data for specific tabs
            if (tabName === 'tasks') {
                loadTasks();
            } else if (tabName === 'teams') {
                loadTeams();
            } else if (tabName === 'agents') {
                loadAgents();
            }
        }
        
        function refreshTasks() {
            // Implement task refresh logic
            console.log('Refreshing tasks...');
        }
        
        function createTeam() {
            // Implement team creation logic
            alert('Team creation interface coming soon!');
        }
        
        function registerAgent() {
            // Implement agent registration logic
            alert('Agent registration interface coming soon!');
        }
        
        function loadTasks() {
            // Load tasks from API
            fetch('/api/v1/tasks')
                .then(response => response.json())
                .then(data => {
                    console.log('Tasks loaded:', data);
                    updateTasksUI(data);
                })
                .catch(error => {
                    console.error('Error loading tasks:', error);
                });
        }
        
        function updateTasksUI(data) {
            const activeTasks = data.tasks.filter(task => task.status === 'active');
            const queuedTasks = data.tasks.filter(task => task.status === 'queued');
            
            // Update active tasks
            const activeTasksContainer = document.getElementById('active-tasks');
            if (activeTasks.length > 0) {
                activeTasksContainer.innerHTML = activeTasks.map(task => 
                    '<div class="task-item priority-' + task.priority + '">' +
                        '<div class="task-title">' + task.title + '</div>' +
                        '<div class="task-meta">' +
                            '<span>' + task.repository + '</span>' +
                            '<span class="badge ' + (task.priority === 'high' ? 'working' : task.priority === 'medium' ? 'stub' : 'working') + '">' + task.priority.toUpperCase() + '</span>' +
                        '</div>' +
                        '<p style="margin: 8px 0; color: #718096; font-size: 14px;">' + task.description + '</p>' +
                        '<div class="task-meta">' +
                            '<span>Team: ' + (task.assigned_to || 'Unassigned') + '</span>' +
                            '<a href="' + task.issue_url + '" target="_blank" style="color: #667eea;">View Issue</a>' +
                        '</div>' +
                    '</div>'
                ).join('');
            }
            
            // Update queued tasks
            const queuedTasksContainer = document.getElementById('queued-tasks');
            if (queuedTasks.length > 0) {
                queuedTasksContainer.innerHTML = queuedTasks.map(task => 
                    '<div class="task-item priority-' + task.priority + '">' +
                        '<div class="task-title">' + task.title + '</div>' +
                        '<div class="task-meta">' +
                            '<span>' + task.repository + '</span>' +
                            '<span class="badge ' + (task.priority === 'high' ? 'working' : task.priority === 'medium' ? 'stub' : 'working') + '">' + task.priority.toUpperCase() + '</span>' +
                        '</div>' +
                        '<p style="margin: 8px 0; color: #718096; font-size: 14px;">' + task.description + '</p>' +
                        '<div class="task-meta">' +
                            '<span>Awaiting team assignment</span>' +
                            '<a href="' + task.issue_url + '" target="_blank" style="color: #667eea;">View Issue</a>' +
                        '</div>' +
                    '</div>'
                ).join('');
            }
            
            // Update overview metrics
            updateOverviewMetrics(data);
        }
        
        function loadTeams() {
            // Load teams from API
            fetch('/api/v1/teams')
                .then(response => response.json())
                .then(data => {
                    console.log('Teams loaded:', data);
                })
                .catch(error => {
                    console.error('Error loading teams:', error);
                });
        }
        
        function loadAgents() {
            // Load agents from API
            fetch('/api/v1/agents')
                .then(response => response.json())
                .then(data => {
                    console.log('Agents loaded:', data);
                    updateAgentsUI(data);
                })
                .catch(error => {
                    console.error('Error loading agents:', error);
                });
        }
        
        function updateAgentsUI(data) {
            const agentsContainer = document.getElementById('agents-grid');
            
            if (data.agents && data.agents.length > 0) {
                agentsContainer.innerHTML = data.agents.map(agent => 
                    '<div class="card">' +
                        '<div class="agent-card">' +
                            '<div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 12px;">' +
                                '<h4 style="margin: 0; color: #2d3748;">' + agent.name + '</h4>' +
                                '<span class="agent-status ' + agent.status + '"></span>' +
                            '</div>' +
                            '<div class="metric">' +
                                '<span class="metric-label">Status</span>' +
                                '<span class="metric-value" style="color: ' + (agent.status === 'online' ? '#38a169' : agent.status === 'idle' ? '#dd6b20' : '#a0aec0') + ';">' + agent.status.toUpperCase() + '</span>' +
                            '</div>' +
                            '<div class="metric">' +
                                '<span class="metric-label">Model</span>' +
                                '<span class="metric-value">' + agent.model + '</span>' +
                            '</div>' +
                            '<div class="metric">' +
                                '<span class="metric-label">Tasks Completed</span>' +
                                '<span class="metric-value">' + agent.tasks_completed + '</span>' +
                            '</div>' +
                            '<div class="metric">' +
                                '<span class="metric-label">Current Team</span>' +
                                '<span class="metric-value">' + (agent.current_team || 'Unassigned') + '</span>' +
                            '</div>' +
                            '<div style="margin-top: 12px;">' +
                                '<strong style="font-size: 14px; color: #4a5568;">Capabilities:</strong>' +
                                '<div style="margin-top: 4px;">' +
                                    agent.capabilities.map(cap => '<span class="badge working" style="margin: 2px;">' + cap + '</span>').join('') +
                                '</div>' +
                            '</div>' +
                        '</div>' +
                    '</div>'
                ).join('');
            }
        }
        
        function updateOverviewMetrics(taskData, agentData) {
            if (taskData) {
                const activeTasks = taskData.tasks.filter(task => task.status === 'active').length;
                const queuedTasks = taskData.tasks.filter(task => task.status === 'queued').length;
                
                // Update the metric values
                const pendingElement = document.querySelector('[data-metric="pending-tasks"]');
                if (pendingElement) pendingElement.textContent = queuedTasks;
            }
            
            if (agentData) {
                const registeredAgents = agentData.total || 0;
                const agentsElement = document.querySelector('[data-metric="registered-agents"]');
                if (agentsElement) agentsElement.textContent = registeredAgents;
            }
        }
        
        function loadOverviewData() {
            // Load both tasks and agents data for overview
            Promise.all([
                fetch('/api/v1/tasks').then(r => r.json()),
                fetch('/api/v1/agents').then(r => r.json())
            ]).then(([taskData, agentData]) => {
                updateOverviewMetrics(taskData, agentData);
            }).catch(error => {
                console.error('Error loading overview data:', error);
            });
        }
        
        // Auto-refresh overview metrics every 30 seconds
        setInterval(() => {
            if (document.getElementById('overview').classList.contains('active')) {
                loadOverviewData();
            }
        }, 30000);
        
        // Load initial data
        document.addEventListener('DOMContentLoaded', function() {
            loadOverviewData();
            loadTasks();
            loadTeams();
            loadAgents();
        });
    </script>
</body>
</html>`

	w.Header().Set("Content-Type", "text/html; charset=utf-8")
	w.Write([]byte(html))
}