// Package handler provides HTTP handlers for various endpoints.
package handler

import (
	"net/http"
	"strings"
	"time"

	"modelRT/database"
	"modelRT/logger"
	"modelRT/network"
	"modelRT/orm"
	_ "modelRT/task"

	"github.com/gin-gonic/gin"
	"github.com/gofrs/uuid"
	"gorm.io/gorm"
)

// AsyncTaskCreateHandler handles creation of asynchronous tasks
// @Summary 创建异步任务
// @Description 创建新的异步任务并返回任务ID，任务将被提交到队列等待处理
// @Tags AsyncTask
// @Accept json
// @Produce json
// @Param request body network.AsyncTaskCreateRequest true "任务创建请求"
// @Success 200 {object} network.SuccessResponse{payload=network.AsyncTaskCreateResponse} "任务创建成功"
// @Failure 400 {object} network.FailureResponse "请求参数错误"
// @Failure 500 {object} network.FailureResponse "服务器内部错误"
// @Router /task/async [post]
func AsyncTaskCreateHandler(c *gin.Context) {
	ctx := c.Request.Context()
	var request network.AsyncTaskCreateRequest

	if err := c.ShouldBindJSON(&request); err != nil {
		logger.Error(ctx, "failed to unmarshal async task create request", "error", err)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusBadRequest,
			Msg:  "invalid request parameters",
		})
		return
	}

	// Validate task type
	if !orm.IsValidAsyncTaskType(request.TaskType) {
		logger.Error(ctx, "invalid task type", "task_type", request.TaskType)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusBadRequest,
			Msg:  "invalid task type",
		})
		return
	}

	// Validate task parameters based on task type
	if !validateTaskParams(request.TaskType, request.Params) {
		logger.Error(ctx, "invalid task parameters", "task_type", request.TaskType, "params", request.Params)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusBadRequest,
			Msg:  "invalid task parameters",
		})
		return
	}

	// Get database connection from context or use default
	db := getDBFromContext(c)
	if db == nil {
		logger.Error(ctx, "database connection not found in context")
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusInternalServerError,
			Msg:  "database connection error",
		})
		return
	}

	// Create task in database
	taskType := orm.AsyncTaskType(request.TaskType)
	params := orm.JSONMap(request.Params)

	asyncTask, err := database.CreateAsyncTask(ctx, db, taskType, params)
	if err != nil {
		logger.Error(ctx, "failed to create async task in database", "error", err)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusInternalServerError,
			Msg:  "failed to create task",
		})
		return
	}

	// Create task queue message
	// taskQueueMsg := task.NewTaskQueueMessage(asyncTask.TaskID, task.TaskType(request.TaskType))

	// TODO: Send task to message queue (RabbitMQ/Redis)
	// This should be implemented when message queue integration is ready
	// For now, we'll just log the task creation
	logger.Info(ctx, "async task created successfully", "task_id", asyncTask.TaskID, "task_type", request.TaskType)

	// Return success response
	c.JSON(http.StatusOK, network.SuccessResponse{
		Code: 2000,
		Msg:  "task created successfully",
		Payload: network.AsyncTaskCreateResponse{
			TaskID: asyncTask.TaskID,
		},
	})
}

// AsyncTaskResultQueryHandler handles querying of asynchronous task results
// @Summary 查询异步任务结果
// @Description 根据任务ID列表查询异步任务的状态和结果
// @Tags AsyncTask
// @Accept json
// @Produce json
// @Param task_ids query string true "任务ID列表，用逗号分隔"
// @Success 200 {object} network.SuccessResponse{payload=network.AsyncTaskResultQueryResponse} "查询成功"
// @Failure 400 {object} network.FailureResponse "请求参数错误"
// @Failure 500 {object} network.FailureResponse "服务器内部错误"
// @Router /task/async/results [get]
func AsyncTaskResultQueryHandler(c *gin.Context) {
	ctx := c.Request.Context()

	// Parse task IDs from query parameter
	taskIDsParam := c.Query("task_ids")
	if taskIDsParam == "" {
		logger.Error(ctx, "task_ids parameter is required")
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusBadRequest,
			Msg:  "task_ids parameter is required",
		})
		return
	}

	// Parse comma-separated task IDs
	var taskIDs []uuid.UUID
	taskIDStrs := splitCommaSeparated(taskIDsParam)
	for _, taskIDStr := range taskIDStrs {
		taskID, err := uuid.FromString(taskIDStr)
		if err != nil {
			logger.Error(ctx, "invalid task ID format", "task_id", taskIDStr, "error", err)
			c.JSON(http.StatusOK, network.FailureResponse{
				Code: http.StatusBadRequest,
				Msg:  "invalid task ID format",
			})
			return
		}
		taskIDs = append(taskIDs, taskID)
	}

	if len(taskIDs) == 0 {
		logger.Error(ctx, "no valid task IDs provided")
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusBadRequest,
			Msg:  "no valid task IDs provided",
		})
		return
	}

	// Get database connection from context or use default
	db := getDBFromContext(c)
	if db == nil {
		logger.Error(ctx, "database connection not found in context")
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusInternalServerError,
			Msg:  "database connection error",
		})
		return
	}

	// Query tasks from database
	asyncTasks, err := database.GetAsyncTasksByIDs(ctx, db, taskIDs)
	if err != nil {
		logger.Error(ctx, "failed to query async tasks from database", "error", err)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusInternalServerError,
			Msg:  "failed to query tasks",
		})
		return
	}

	// Query task results from database
	taskResults, err := database.GetAsyncTaskResults(ctx, db, taskIDs)
	if err != nil {
		logger.Error(ctx, "failed to query async task results from database", "error", err)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusInternalServerError,
			Msg:  "failed to query task results",
		})
		return
	}

	// Create a map of task results for easy lookup
	taskResultMap := make(map[uuid.UUID]orm.AsyncTaskResult)
	for _, result := range taskResults {
		taskResultMap[result.TaskID] = result
	}

	// Convert to response format
	var responseTasks []network.AsyncTaskResult
	for _, asyncTask := range asyncTasks {
		taskResult := network.AsyncTaskResult{
			TaskID:     asyncTask.TaskID,
			TaskType:   string(asyncTask.TaskType),
			Status:     string(asyncTask.Status),
			CreatedAt:  asyncTask.CreatedAt,
			FinishedAt: asyncTask.FinishedAt,
			Progress:   asyncTask.Progress,
		}

		// Add result or error information if available
		if result, exists := taskResultMap[asyncTask.TaskID]; exists {
			if result.Result != nil {
				taskResult.Result = map[string]any(result.Result)
			}
			if result.ErrorCode != nil {
				taskResult.ErrorCode = result.ErrorCode
			}
			if result.ErrorMessage != nil {
				taskResult.ErrorMessage = result.ErrorMessage
			}
			if result.ErrorDetail != nil {
				taskResult.ErrorDetail = map[string]any(result.ErrorDetail)
			}
		}

		responseTasks = append(responseTasks, taskResult)
	}

	// Return success response
	c.JSON(http.StatusOK, network.SuccessResponse{
		Code: 2000,
		Msg:  "query completed",
		Payload: network.AsyncTaskResultQueryResponse{
			Total: len(responseTasks),
			Tasks: responseTasks,
		},
	})
}

// AsyncTaskProgressUpdateHandler handles updating task progress (internal use, not exposed via API)
func AsyncTaskProgressUpdateHandler(c *gin.Context) {
	ctx := c.Request.Context()
	var request network.AsyncTaskProgressUpdate

	if err := c.ShouldBindJSON(&request); err != nil {
		logger.Error(ctx, "failed to unmarshal async task progress update request", "error", err)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusBadRequest,
			Msg:  "invalid request parameters",
		})
		return
	}

	// Get database connection from context or use default
	db := getDBFromContext(c)
	if db == nil {
		logger.Error(ctx, "database connection not found in context")
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusInternalServerError,
			Msg:  "database connection error",
		})
		return
	}

	// Update task progress
	err := database.UpdateAsyncTaskProgress(ctx, db, request.TaskID, request.Progress)
	if err != nil {
		logger.Error(ctx, "failed to update async task progress", "task_id", request.TaskID, "error", err)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusInternalServerError,
			Msg:  "failed to update task progress",
		})
		return
	}

	c.JSON(http.StatusOK, network.SuccessResponse{
		Code:    2000,
		Msg:     "task progress updated successfully",
		Payload: nil,
	})
}

// AsyncTaskStatusUpdateHandler handles updating task status (internal use, not exposed via API)
func AsyncTaskStatusUpdateHandler(c *gin.Context) {
	ctx := c.Request.Context()
	var request network.AsyncTaskStatusUpdate

	if err := c.ShouldBindJSON(&request); err != nil {
		logger.Error(ctx, "failed to unmarshal async task status update request", "error", err)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusBadRequest,
			Msg:  "invalid request parameters",
		})
		return
	}

	// Validate status
	validStatus := map[string]bool{
		string(orm.AsyncTaskStatusSubmitted): true,
		string(orm.AsyncTaskStatusRunning):   true,
		string(orm.AsyncTaskStatusCompleted): true,
		string(orm.AsyncTaskStatusFailed):    true,
	}

	if !validStatus[request.Status] {
		logger.Error(ctx, "invalid task status", "status", request.Status)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusBadRequest,
			Msg:  "invalid task status",
		})
		return
	}

	// Get database connection from context or use default
	db := getDBFromContext(c)
	if db == nil {
		logger.Error(ctx, "database connection not found in context")
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusInternalServerError,
			Msg:  "database connection error",
		})
		return
	}

	// Update task status
	status := orm.AsyncTaskStatus(request.Status)
	err := database.UpdateAsyncTaskStatus(ctx, db, request.TaskID, status)
	if err != nil {
		logger.Error(ctx, "failed to update async task status", "task_id", request.TaskID, "status", request.Status, "error", err)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusInternalServerError,
			Msg:  "failed to update task status",
		})
		return
	}

	// If task is completed or failed, update finished_at timestamp
	if request.Status == string(orm.AsyncTaskStatusCompleted) {
		err = database.CompleteAsyncTask(ctx, db, request.TaskID, request.Timestamp)
	} else if request.Status == string(orm.AsyncTaskStatusFailed) {
		err = database.FailAsyncTask(ctx, db, request.TaskID, request.Timestamp)
	}

	if err != nil {
		logger.Error(ctx, "failed to update async task completion timestamp", "task_id", request.TaskID, "error", err)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusInternalServerError,
			Msg:  "failed to update task completion timestamp",
		})
		return
	}

	c.JSON(http.StatusOK, network.SuccessResponse{
		Code:    2000,
		Msg:     "task status updated successfully",
		Payload: nil,
	})
}

// Helper functions

func validateTaskParams(taskType string, params map[string]any) bool {
	switch taskType {
	case string(orm.AsyncTaskTypeTopologyAnalysis):
		return validateTopologyAnalysisParams(params)
	case string(orm.AsyncTaskTypePerformanceAnalysis):
		return validatePerformanceAnalysisParams(params)
	case string(orm.AsyncTaskTypeEventAnalysis):
		return validateEventAnalysisParams(params)
	case string(orm.AsyncTaskTypeBatchImport):
		return validateBatchImportParams(params)
	default:
		return false
	}
}

func validateTopologyAnalysisParams(params map[string]any) bool {
	// Check required parameters for topology analysis
	if startUUID, ok := params["start_uuid"]; !ok || startUUID == "" {
		return false
	}
	if endUUID, ok := params["end_uuid"]; !ok || endUUID == "" {
		return false
	}
	return true
}

func validatePerformanceAnalysisParams(params map[string]any) bool {
	// Check required parameters for performance analysis
	if componentIDs, ok := params["component_ids"]; !ok {
		return false
	} else if ids, isSlice := componentIDs.([]interface{}); !isSlice || len(ids) == 0 {
		return false
	}
	return true
}

func validateEventAnalysisParams(params map[string]any) bool {
	// Check required parameters for event analysis
	if eventType, ok := params["event_type"]; !ok || eventType == "" {
		return false
	}
	return true
}

func validateBatchImportParams(params map[string]any) bool {
	// Check required parameters for batch import
	if filePath, ok := params["file_path"]; !ok || filePath == "" {
		return false
	}
	return true
}

func splitCommaSeparated(s string) []string {
	var result []string
	var current strings.Builder
	inQuotes := false
	escape := false

	for _, ch := range s {
		if escape {
			current.WriteRune(ch)
			escape = false
			continue
		}

		switch ch {
		case '\\':
			escape = true
		case '"':
			inQuotes = !inQuotes
		case ',':
			if !inQuotes {
				result = append(result, strings.TrimSpace(current.String()))
				current.Reset()
			} else {
				current.WriteRune(ch)
			}
		default:
			current.WriteRune(ch)
		}
	}

	if current.Len() > 0 {
		result = append(result, strings.TrimSpace(current.String()))
	}

	return result
}

func getDBFromContext(c *gin.Context) *gorm.DB {
	// Try to get database connection from context
	// This should be set by middleware
	if db, exists := c.Get("db"); exists {
		if gormDB, ok := db.(*gorm.DB); ok {
			return gormDB
		}
	}

	// Fallback to global database connection
	// This should be implemented based on your application's database setup
	// For now, return nil - actual implementation should retrieve from application context
	return nil
}

// AsyncTaskResultDetailHandler handles detailed query of a single async task result
// @Summary 查询异步任务详情
// @Description 根据任务ID查询异步任务的详细状态和结果
// @Tags AsyncTask
// @Accept json
// @Produce json
// @Param task_id path string true "任务ID"
// @Success 200 {object} network.SuccessResponse{payload=network.AsyncTaskResult} "查询成功"
// @Failure 400 {object} network.FailureResponse "请求参数错误"
// @Failure 404 {object} network.FailureResponse "任务不存在"
// @Failure 500 {object} network.FailureResponse "服务器内部错误"
// @Router /task/async/{task_id} [get]
func AsyncTaskResultDetailHandler(c *gin.Context) {
	ctx := c.Request.Context()

	// Parse task ID from path parameter
	taskIDStr := c.Param("task_id")
	if taskIDStr == "" {
		logger.Error(ctx, "task_id parameter is required")
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusBadRequest,
			Msg:  "task_id parameter is required",
		})
		return
	}

	taskID, err := uuid.FromString(taskIDStr)
	if err != nil {
		logger.Error(ctx, "invalid task ID format", "task_id", taskIDStr, "error", err)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusBadRequest,
			Msg:  "invalid task ID format",
		})
		return
	}

	// Get database connection from context or use default
	db := getDBFromContext(c)
	if db == nil {
		logger.Error(ctx, "database connection not found in context")
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusInternalServerError,
			Msg:  "database connection error",
		})
		return
	}

	// Query task from database
	asyncTask, err := database.GetAsyncTaskByID(ctx, db, taskID)
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			logger.Error(ctx, "async task not found", "task_id", taskID)
			c.JSON(http.StatusOK, network.FailureResponse{
				Code: http.StatusNotFound,
				Msg:  "task not found",
			})
			return
		}
		logger.Error(ctx, "failed to query async task from database", "error", err)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusInternalServerError,
			Msg:  "failed to query task",
		})
		return
	}

	// Query task result from database
	taskResult, err := database.GetAsyncTaskResult(ctx, db, taskID)
	if err != nil {
		logger.Error(ctx, "failed to query async task result from database", "error", err)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusInternalServerError,
			Msg:  "failed to query task result",
		})
		return
	}

	// Convert to response format
	responseTask := network.AsyncTaskResult{
		TaskID:     asyncTask.TaskID,
		TaskType:   string(asyncTask.TaskType),
		Status:     string(asyncTask.Status),
		CreatedAt:  asyncTask.CreatedAt,
		FinishedAt: asyncTask.FinishedAt,
		Progress:   asyncTask.Progress,
	}

	// Add result or error information if available
	if taskResult != nil {
		if taskResult.Result != nil {
			responseTask.Result = map[string]any(taskResult.Result)
		}
		if taskResult.ErrorCode != nil {
			responseTask.ErrorCode = taskResult.ErrorCode
		}
		if taskResult.ErrorMessage != nil {
			responseTask.ErrorMessage = taskResult.ErrorMessage
		}
		if taskResult.ErrorDetail != nil {
			responseTask.ErrorDetail = map[string]any(taskResult.ErrorDetail)
		}
	}

	// Return success response
	c.JSON(http.StatusOK, network.SuccessResponse{
		Code:    2000,
		Msg:     "query completed",
		Payload: responseTask,
	})
}

// AsyncTaskCancelHandler handles cancellation of an async task
// @Summary 取消异步任务
// @Description 取消指定ID的异步任务（如果任务尚未开始执行）
// @Tags AsyncTask
// @Accept json
// @Produce json
// @Param task_id path string true "任务ID"
// @Success 200 {object} network.SuccessResponse "任务取消成功"
// @Failure 400 {object} network.FailureResponse "请求参数错误或任务无法取消"
// @Failure 404 {object} network.FailureResponse "任务不存在"
// @Failure 500 {object} network.FailureResponse "服务器内部错误"
// @Router /task/async/{task_id}/cancel [post]
func AsyncTaskCancelHandler(c *gin.Context) {
	ctx := c.Request.Context()

	// Parse task ID from path parameter
	taskIDStr := c.Param("task_id")
	if taskIDStr == "" {
		logger.Error(ctx, "task_id parameter is required")
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusBadRequest,
			Msg:  "task_id parameter is required",
		})
		return
	}

	taskID, err := uuid.FromString(taskIDStr)
	if err != nil {
		logger.Error(ctx, "invalid task ID format", "task_id", taskIDStr, "error", err)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusBadRequest,
			Msg:  "invalid task ID format",
		})
		return
	}

	// Get database connection from context or use default
	db := getDBFromContext(c)
	if db == nil {
		logger.Error(ctx, "database connection not found in context")
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusInternalServerError,
			Msg:  "database connection error",
		})
		return
	}

	// Query task from database
	asyncTask, err := database.GetAsyncTaskByID(ctx, db, taskID)
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			logger.Error(ctx, "async task not found", "task_id", taskID)
			c.JSON(http.StatusOK, network.FailureResponse{
				Code: http.StatusNotFound,
				Msg:  "task not found",
			})
			return
		}
		logger.Error(ctx, "failed to query async task from database", "error", err)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusInternalServerError,
			Msg:  "failed to query task",
		})
		return
	}

	// Check if task can be cancelled (only SUBMITTED tasks can be cancelled)
	if asyncTask.Status != orm.AsyncTaskStatusSubmitted {
		logger.Error(ctx, "task cannot be cancelled", "task_id", taskID, "status", asyncTask.Status)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusBadRequest,
			Msg:  "task cannot be cancelled (already running or completed)",
		})
		return
	}

	// Update task status to failed with cancellation reason
	timestamp := time.Now().Unix()
	err = database.FailAsyncTask(ctx, db, taskID, timestamp)
	if err != nil {
		logger.Error(ctx, "failed to cancel async task", "task_id", taskID, "error", err)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusInternalServerError,
			Msg:  "failed to cancel task",
		})
		return
	}

	// Update task result with cancellation error
	err = database.UpdateAsyncTaskResultWithError(ctx, db, taskID, 40003, "task cancelled by user", orm.JSONMap{
		"cancelled_at": timestamp,
		"cancelled_by": "user",
	})
	if err != nil {
		logger.Error(ctx, "failed to update task result with cancellation error", "task_id", taskID, "error", err)
		// Continue anyway since task is already marked as failed
	}

	c.JSON(http.StatusOK, network.SuccessResponse{
		Code: 2000,
		Msg:  "task cancelled successfully",
	})
}