// Package api provides the HTTP REST API for agentctl control server
package api

import (
	"context"
	"encoding/json"
	"net/http"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/gorilla/websocket"
	"github.com/kandev/kandev/internal/agentctl/config"
	"github.com/kandev/kandev/internal/agentctl/instance"
	"github.com/kandev/kandev/internal/agentctl/process"
	"github.com/kandev/kandev/internal/common/logger"
	"go.uber.org/zap"
)

// ControlServer provides instance CRUD endpoints on the control port (9999).
// In single-instance mode, it also embeds the agent API routes directly.
type ControlServer struct {
	cfg     *config.MultiConfig
	instMgr *instance.Manager
	logger  *logger.Logger
	router  *gin.Engine

	// Single-instance mode: embedded process manager and config
	singleMode   bool
	singleCfg    *config.Config
	singleProcMgr *process.Manager
	upgrader     websocket.Upgrader
}

// NewControlServer creates a new ControlServer for multi-instance management.
func NewControlServer(cfg *config.MultiConfig, instMgr *instance.Manager, log *logger.Logger) *ControlServer {
	gin.SetMode(gin.ReleaseMode)

	cs := &ControlServer{
		cfg:     cfg,
		instMgr: instMgr,
		logger:  log.WithFields(zap.String("component", "control-server")),
		router:  gin.New(),
	}

	cs.setupRoutes()
	return cs
}

// NewSingleInstanceServer creates a ControlServer for single-instance (Docker) mode.
// It embeds the agent API routes directly on the control server.
func NewSingleInstanceServer(cfg *config.MultiConfig, singleCfg *config.Config, procMgr *process.Manager, log *logger.Logger) *ControlServer {
	gin.SetMode(gin.ReleaseMode)

	cs := &ControlServer{
		cfg:           cfg,
		logger:        log.WithFields(zap.String("component", "control-server")),
		router:        gin.New(),
		singleMode:    true,
		singleCfg:     singleCfg,
		singleProcMgr: procMgr,
		upgrader: websocket.Upgrader{
			CheckOrigin: func(r *http.Request) bool {
				return true // Allow all origins for container-local communication
			},
		},
	}

	cs.setupRoutes()
	return cs
}

// Router returns the HTTP handler for the control server.
func (m *ControlServer) Router() http.Handler {
	return m.router
}

func (m *ControlServer) setupRoutes() {
	// Health check
	m.router.GET("/health", m.handleHealth)

	api := m.router.Group("/api/v1")

	if m.singleMode {
		// Single-instance mode: mount agent API routes directly
		m.setupSingleInstanceRoutes(api)
	} else {
		// Multi-instance mode: instance management API
		api.POST("/instances", m.handleCreateInstance)
		api.GET("/instances", m.handleListInstances)
		api.GET("/instances/:id", m.handleGetInstance)
		api.DELETE("/instances/:id", m.handleDeleteInstance)
	}
}

// setupSingleInstanceRoutes adds the agent API routes for single-instance mode.
// These are the same routes that api.Server provides.
func (m *ControlServer) setupSingleInstanceRoutes(api *gin.RouterGroup) {
	// Status and info
	api.GET("/status", m.handleStatus)
	api.GET("/info", m.handleInfo)

	// Process control
	api.POST("/start", m.handleStart)
	api.POST("/stop", m.handleStop)

	// ACP high-level methods
	api.POST("/acp/initialize", m.handleACPInitialize)
	api.POST("/acp/session/new", m.handleACPNewSession)
	api.POST("/acp/prompt", m.handleACPPrompt)
	api.GET("/acp/stream", m.handleACPStreamWS)

	// Permission request handling
	api.GET("/acp/permissions", m.handleGetPendingPermissions)
	api.GET("/acp/permissions/stream", m.handlePermissionStreamWS)
	api.POST("/acp/permissions/respond", m.handlePermissionRespond)

	// Workspace monitoring (git status, files)
	api.GET("/workspace/git-status/stream", m.handleGitStatusStreamWS)
	api.GET("/workspace/files/stream", m.handleFilesStreamWS)
	api.GET("/workspace/file-changes/stream", m.handleFileChangesStreamWS)

	// Workspace file operations (simple HTTP)
	api.GET("/workspace/tree", m.handleFileTree)
	api.GET("/workspace/file/content", m.handleFileContent)
}

func (m *ControlServer) handleHealth(c *gin.Context) {
	c.JSON(http.StatusOK, gin.H{
		"status":    "ok",
		"timestamp": time.Now().UTC().Format(time.RFC3339),
		"mode":      m.cfg.Mode,
	})
}

func (m *ControlServer) handleCreateInstance(c *gin.Context) {
	var req instance.CreateRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		m.logger.Warn("invalid create instance request", zap.Error(err))
		c.JSON(http.StatusBadRequest, gin.H{
			"error": "invalid request body: " + err.Error(),
		})
		return
	}

	// Validate required fields
	if req.WorkspacePath == "" {
		c.JSON(http.StatusBadRequest, gin.H{
			"error": "workspace_path is required",
		})
		return
	}

	resp, err := m.instMgr.CreateInstance(c.Request.Context(), &req)
	if err != nil {
		m.logger.Error("failed to create instance", zap.Error(err))
		c.JSON(http.StatusInternalServerError, gin.H{
			"error": "failed to create instance: " + err.Error(),
		})
		return
	}

	c.JSON(http.StatusCreated, resp)
}

func (m *ControlServer) handleListInstances(c *gin.Context) {
	instances := m.instMgr.ListInstances()
	c.JSON(http.StatusOK, instances)
}

func (m *ControlServer) handleGetInstance(c *gin.Context) {
	id := c.Param("id")

	inst, found := m.instMgr.GetInstance(id)
	if !found {
		c.JSON(http.StatusNotFound, gin.H{
			"error": "instance not found",
		})
		return
	}

	c.JSON(http.StatusOK, inst.Info())
}

func (m *ControlServer) handleDeleteInstance(c *gin.Context) {
	id := c.Param("id")

	// First check if instance exists
	if _, found := m.instMgr.GetInstance(id); !found {
		c.JSON(http.StatusNotFound, gin.H{
			"error": "instance not found",
		})
		return
	}

	err := m.instMgr.StopInstance(c.Request.Context(), id)
	if err != nil {
		m.logger.Error("failed to stop instance", zap.String("id", id), zap.Error(err))
		c.JSON(http.StatusInternalServerError, gin.H{
			"error": "failed to stop instance: " + err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"message": "instance stopped successfully",
	})
}

// =============================================================================
// Single-instance mode handlers
// These mirror the handlers in server.go but use singleProcMgr
// =============================================================================

func (m *ControlServer) handleStatus(c *gin.Context) {
	c.JSON(http.StatusOK, StatusResponse{
		AgentStatus: string(m.singleProcMgr.Status()),
		ProcessInfo: m.singleProcMgr.GetProcessInfo(),
	})
}

func (m *ControlServer) handleInfo(c *gin.Context) {
	c.JSON(http.StatusOK, InfoResponse{
		Version:      "0.1.0",
		AgentCommand: m.singleCfg.AgentCommand,
		WorkDir:      m.singleCfg.WorkDir,
		Port:         m.singleCfg.Port,
	})
}

func (m *ControlServer) handleStart(c *gin.Context) {
	if err := m.singleProcMgr.Start(c.Request.Context()); err != nil {
		m.logger.Error("failed to start agent", zap.Error(err))
		c.JSON(http.StatusInternalServerError, StartResponse{
			Success: false,
			Error:   err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, StartResponse{
		Success: true,
		Message: "agent started",
	})
}

func (m *ControlServer) handleStop(c *gin.Context) {
	if err := m.singleProcMgr.Stop(c.Request.Context()); err != nil {
		m.logger.Error("failed to stop agent", zap.Error(err))
		c.JSON(http.StatusInternalServerError, StopResponse{
			Success: false,
			Error:   err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, StopResponse{
		Success: true,
		Message: "agent stopped",
	})
}


// ACP handlers for single-instance mode

func (m *ControlServer) handleACPInitialize(c *gin.Context) {
	var req InitializeRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, InitializeResponse{
			Success: false,
			Error:   "invalid request: " + err.Error(),
		})
		return
	}

	ctx, cancel := context.WithTimeout(c.Request.Context(), 30*time.Second)
	defer cancel()

	adapter := m.singleProcMgr.GetAdapter()
	if adapter == nil {
		c.JSON(http.StatusServiceUnavailable, InitializeResponse{
			Success: false,
			Error:   "agent not running",
		})
		return
	}

	err := adapter.Initialize(ctx)
	if err != nil {
		m.logger.Error("initialize failed", zap.Error(err))
		c.JSON(http.StatusInternalServerError, InitializeResponse{
			Success: false,
			Error:   err.Error(),
		})
		return
	}

	var agentInfoResp *AgentInfoResponse
	if info := adapter.GetAgentInfo(); info != nil {
		agentInfoResp = &AgentInfoResponse{
			Name:    info.Name,
			Version: info.Version,
		}
	}

	c.JSON(http.StatusOK, InitializeResponse{
		Success:   true,
		AgentInfo: agentInfoResp,
	})
}

func (m *ControlServer) handleACPNewSession(c *gin.Context) {
	var req NewSessionRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, NewSessionResponse{
			Success: false,
			Error:   "invalid request: " + err.Error(),
		})
		return
	}

	ctx, cancel := context.WithTimeout(c.Request.Context(), 30*time.Second)
	defer cancel()

	adapter := m.singleProcMgr.GetAdapter()
	if adapter == nil {
		c.JSON(http.StatusServiceUnavailable, NewSessionResponse{
			Success: false,
			Error:   "agent not running",
		})
		return
	}

	sessionID, err := adapter.NewSession(ctx)
	if err != nil {
		m.logger.Error("new session failed", zap.Error(err))
		c.JSON(http.StatusInternalServerError, NewSessionResponse{
			Success: false,
			Error:   err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, NewSessionResponse{
		Success:   true,
		SessionID: sessionID,
	})
}

func (m *ControlServer) handleACPPrompt(c *gin.Context) {
	var req PromptRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, PromptResponse{
			Success: false,
			Error:   "invalid request: " + err.Error(),
		})
		return
	}

	adapter := m.singleProcMgr.GetAdapter()
	if adapter == nil {
		c.JSON(http.StatusServiceUnavailable, PromptResponse{
			Success: false,
			Error:   "agent not running",
		})
		return
	}

	sessionID := m.singleProcMgr.GetSessionID()
	if sessionID == "" {
		c.JSON(http.StatusBadRequest, PromptResponse{
			Success: false,
			Error:   "no active session - call new_session first",
		})
		return
	}

	ctx, cancel := context.WithTimeout(c.Request.Context(), 10*time.Minute)
	defer cancel()

	err := adapter.Prompt(ctx, req.Text)
	if err != nil {
		m.logger.Error("prompt failed", zap.Error(err))
		c.JSON(http.StatusInternalServerError, PromptResponse{
			Success: false,
			Error:   err.Error(),
		})
		return
	}

	m.logger.Info("prompt completed")
	c.JSON(http.StatusOK, PromptResponse{
		Success: true,
	})
}


func (m *ControlServer) handleACPStreamWS(c *gin.Context) {
	conn, err := m.upgrader.Upgrade(c.Writer, c.Request, nil)
	if err != nil {
		m.logger.Error("WebSocket upgrade failed", zap.Error(err))
		return
	}
	defer func() {
		if err := conn.Close(); err != nil {
			m.logger.Debug("failed to close ACP stream websocket", zap.Error(err))
		}
	}()

	m.logger.Info("ACP stream WebSocket connected")

	updatesCh := m.singleProcMgr.GetUpdates()

	for notification := range updatesCh {
		data, err := json.Marshal(notification)
		if err != nil {
			m.logger.Error("failed to marshal notification", zap.Error(err))
			continue
		}

		if err := conn.WriteMessage(websocket.TextMessage, data); err != nil {
			return
		}
	}
}

func (m *ControlServer) handleGetPendingPermissions(c *gin.Context) {
	pending := m.singleProcMgr.GetPendingPermissions()

	result := make([]PendingPermissionResponse, 0, len(pending))
	for _, p := range pending {
		options := make([]PermissionOptionJSON, len(p.Request.Options))
		for i, opt := range p.Request.Options {
			options[i] = PermissionOptionJSON{
				OptionID: opt.OptionID,
				Name:     opt.Name,
				Kind:     opt.Kind,
			}
		}
		result = append(result, PendingPermissionResponse{
			PendingID:  p.ID,
			SessionID:  p.Request.SessionID,
			ToolCallID: p.Request.ToolCallID,
			Title:      p.Request.Title,
			Options:    options,
			CreatedAt:  p.CreatedAt.Format(time.RFC3339),
		})
	}

	c.JSON(http.StatusOK, result)
}

func (m *ControlServer) handlePermissionStreamWS(c *gin.Context) {
	conn, err := m.upgrader.Upgrade(c.Writer, c.Request, nil)
	if err != nil {
		m.logger.Error("WebSocket upgrade failed", zap.Error(err))
		return
	}
	defer func() {
		if err := conn.Close(); err != nil {
			m.logger.Debug("failed to close permission websocket", zap.Error(err))
		}
	}()

	m.logger.Info("Permission stream WebSocket connected")

	permissionCh := m.singleProcMgr.GetPermissionRequests()

	for notification := range permissionCh {
		data, err := json.Marshal(notification)
		if err != nil {
			m.logger.Error("failed to marshal permission notification", zap.Error(err))
			continue
		}

		if err := conn.WriteMessage(websocket.TextMessage, data); err != nil {
			m.logger.Debug("WebSocket write error", zap.Error(err))
			return
		}
	}
}

func (m *ControlServer) handlePermissionRespond(c *gin.Context) {
	var req PermissionRespondRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, PermissionRespondResponse{
			Success: false,
			Error:   "invalid request: " + err.Error(),
		})
		return
	}

	m.logger.Info("received permission response",
		zap.String("pending_id", req.PendingID),
		zap.String("option_id", req.OptionID),
		zap.Bool("cancelled", req.Cancelled))

	if err := m.singleProcMgr.RespondToPermission(req.PendingID, req.OptionID, req.Cancelled); err != nil {
		m.logger.Error("failed to respond to permission", zap.Error(err))
		c.JSON(http.StatusNotFound, PermissionRespondResponse{
			Success: false,
			Error:   err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, PermissionRespondResponse{
		Success: true,
	})
}


// Workspace handlers for single-instance mode

func (m *ControlServer) handleGitStatusStreamWS(c *gin.Context) {
	conn, err := m.upgrader.Upgrade(c.Writer, c.Request, nil)
	if err != nil {
		m.logger.Error("WebSocket upgrade failed", zap.Error(err))
		return
	}
	defer func() {
		if err := conn.Close(); err != nil {
			m.logger.Debug("failed to close git status websocket", zap.Error(err))
		}
	}()

	sub := m.singleProcMgr.GetWorkspaceTracker().SubscribeGitStatus()
	defer m.singleProcMgr.GetWorkspaceTracker().UnsubscribeGitStatus(sub)

	closeCh := make(chan struct{})
	go func() {
		for {
			_, _, err := conn.ReadMessage()
			if err != nil {
				close(closeCh)
				return
			}
		}
	}()

	for {
		select {
		case update, ok := <-sub:
			if !ok {
				return
			}
			data, err := json.Marshal(update)
			if err != nil {
				m.logger.Error("failed to marshal git status update", zap.Error(err))
				continue
			}
			if err := conn.WriteMessage(websocket.TextMessage, data); err != nil {
				return
			}
		case <-closeCh:
			return
		}
	}
}

func (m *ControlServer) handleFilesStreamWS(c *gin.Context) {
	conn, err := m.upgrader.Upgrade(c.Writer, c.Request, nil)
	if err != nil {
		m.logger.Error("WebSocket upgrade failed", zap.Error(err))
		return
	}
	defer func() {
		if err := conn.Close(); err != nil {
			m.logger.Debug("failed to close files websocket", zap.Error(err))
		}
	}()

	sub := m.singleProcMgr.GetWorkspaceTracker().SubscribeFiles()
	defer m.singleProcMgr.GetWorkspaceTracker().UnsubscribeFiles(sub)

	closeCh := make(chan struct{})
	go func() {
		for {
			_, _, err := conn.ReadMessage()
			if err != nil {
				close(closeCh)
				return
			}
		}
	}()

	for {
		select {
		case update, ok := <-sub:
			if !ok {
				return
			}
			data, err := json.Marshal(update)
			if err != nil {
				m.logger.Error("failed to marshal file update", zap.Error(err))
				continue
			}
			if err := conn.WriteMessage(websocket.TextMessage, data); err != nil {
				return
			}
		case <-closeCh:
			return
		}
	}
}

func (m *ControlServer) handleFileChangesStreamWS(c *gin.Context) {
	conn, err := m.upgrader.Upgrade(c.Writer, c.Request, nil)
	if err != nil {
		m.logger.Error("WebSocket upgrade failed", zap.Error(err))
		return
	}
	defer func() {
		if err := conn.Close(); err != nil {
			m.logger.Debug("failed to close file changes websocket", zap.Error(err))
		}
	}()

	sub := m.singleProcMgr.GetWorkspaceTracker().SubscribeFileChanges()
	defer m.singleProcMgr.GetWorkspaceTracker().UnsubscribeFileChanges(sub)

	closeCh := make(chan struct{})
	go func() {
		for {
			_, _, err := conn.ReadMessage()
			if err != nil {
				close(closeCh)
				return
			}
		}
	}()

	for {
		select {
		case notification, ok := <-sub:
			if !ok {
				return
			}
			data, err := json.Marshal(notification)
			if err != nil {
				m.logger.Error("failed to marshal file change notification", zap.Error(err))
				continue
			}
			if err := conn.WriteMessage(websocket.TextMessage, data); err != nil {
				return
			}
		case <-closeCh:
			return
		}
	}
}

func (m *ControlServer) handleFileTree(c *gin.Context) {
	path := c.Query("path")
	depth := 1
	if d := c.Query("depth"); d != "" {
		if _, err := json.Number(d).Int64(); err == nil {
			depth = int(mustParseInt(d))
		}
	}

	tree, err := m.singleProcMgr.GetWorkspaceTracker().GetFileTree(path, depth)
	if err != nil {
		c.JSON(400, process.FileTreeResponse{Error: err.Error()})
		return
	}

	c.JSON(200, process.FileTreeResponse{Root: tree})
}

func (m *ControlServer) handleFileContent(c *gin.Context) {
	path := c.Query("path")
	if path == "" {
		c.JSON(400, process.FileContentResponse{Error: "path is required"})
		return
	}

	content, size, err := m.singleProcMgr.GetWorkspaceTracker().GetFileContent(path)
	if err != nil {
		c.JSON(400, process.FileContentResponse{Path: path, Error: err.Error(), Size: size})
		return
	}

	c.JSON(200, process.FileContentResponse{Path: path, Content: content, Size: size})
}