package xjlab

import (
	"context"
	"time"

	jsoniter "github.com/json-iterator/go"
	"github.com/zeromicro/go-zero/core/logx"
	"gitlink.org.cn/JointCloud/pcm-coordinator/internal/svc"
	"gitlink.org.cn/JointCloud/pcm-coordinator/internal/types"
	"gitlink.org.cn/JointCloud/pcm-coordinator/pkg/constants"
	"gitlink.org.cn/JointCloud/pcm-coordinator/pkg/repository/result"
	"gitlink.org.cn/JointCloud/pcm-coordinator/pkg/utils/timeutils"
	"gorm.io/gorm"
)

type PageListTaskLogic struct {
	logx.Logger
	ctx    context.Context
	svcCtx *svc.ServiceContext
}

func NewPageListTaskLogic(ctx context.Context, svcCtx *svc.ServiceContext) *PageListTaskLogic {
	return &PageListTaskLogic{
		Logger: logx.WithContext(ctx),
		ctx:    ctx,
		svcCtx: svcCtx,
	}
}

type TaskResp struct {
	Id              int64  `json:"id,omitempty,string" db:"id"`            // id
	Name            string `json:"name,omitempty" db:"name"`               // 作业名称
	Description     string `json:"description,omitempty" db:"description"` // 作业描述
	Status          string `json:"status,omitempty" db:"status"`           // 作业状态
	Strategy        int64  `json:"strategy" db:"strategy"`                 // 策略
	SynergyStatus   int64  `json:"synergyStatus" db:"synergy_status"`      // 协同状态（0-未协同、1-已协同）
	CommitTime      string `json:"commitTime,omitempty" db:"commit_time"`  // 提交时间
	StartTime       string `json:"startTime,omitempty" db:"start_time"`    // 开始时间
	EndTime         string `json:"endTime,omitempty" db:"end_time"`        // 结束运行时间
	RunningTime     int64  `json:"runningTime" db:"running_time"`          // 已运行时间（单位秒）
	YamlString      string `json:"yamlString,omitempty" db:"yaml_string"`
	Result          string `json:"result,omitempty" db:"result"` // 作业结果
	DeletedAt       string `json:"deletedAt,omitempty" gorm:"index" db:"deleted_at"`
	NsID            string `json:"nsId,omitempty" db:"ns_id"`
	TenantId        string `json:"tenantId,omitempty" db:"tenant_id"`
	CreatedTime     string `json:"createdTime,omitempty" db:"created_time" gorm:"autoCreateTime"`
	UpdatedTime     string `json:"updatedTime,omitempty" db:"updated_time"`
	AdapterTypeDict string `json:"adapterTypeDict" db:"adapter_type_dict" gorm:"adapter_type_dict"` //适配器类型（对应字典表的值
	TaskTypeDict    string `json:"taskTypeDict" db:"task_type_dict" gorm:"task_type_dict"`          //任务类型（对应字典表的值
	UserId          int64  `json:"userId,omitempty" db:"user_id"`
	UserName        string `json:"userName,omitempty" db:"user_name"`

	ClusterId    string `json:"clusterId,omitempty" db:"cluster_id"`
	ClusterName  string `json:"clusterName,omitempty" db:"cluster_name"`
	ResourceSpec string `json:"resourceSpec,omitempty" db:"resource_spec"`
	Card         string `json:"card,omitempty" db:"card"`
}

// clusterInfo 集群信息结构体
type clusterInfo struct {
	ClusterId    string `json:"cluster_id"`
	ClusterName  string `json:"cluster_name"`
	ResourceSpec string `json:"resource_spec"`
	Card         string `json:"card"`
}

func (l *PageListTaskLogic) PageListTask(req *types.XJLABTaskReq) (*types.PageResult, error) {
	// 验证请求参数
	if err := l.validateRequest(req); err != nil {
		return nil, err
	}

	// 查询任务总数
	total, err := l.getTaskCount(req)
	if err != nil {
		return nil, err
	}

	// 查询任务列表
	tasks, err := l.getTaskList(req)
	if err != nil {
		return nil, err
	}

	// 异步更新任务状态
	l.updateTaskStatusAsync(tasks)

	// 处理任务响应数据
	taskResps := l.processTaskResponses(tasks)

	// 构建分页结果
	return &types.PageResult{
		List:     &taskResps,
		PageSize: req.PageSize,
		PageNum:  req.PageNum,
		Total:    total,
	}, nil
}

// validateRequest 验证请求参数
func (l *PageListTaskLogic) validateRequest(req *types.XJLABTaskReq) error {
	if req.PageSize <= 0 || req.PageNum <= 0 {
		return result.NewDefaultError("Invalid page size or page number")
	}
	return nil
}

// buildBaseQuery 构建基础查询条件
func (l *PageListTaskLogic) buildBaseQuery(req *types.XJLABTaskReq) *gorm.DB {
	db := l.svcCtx.DbEngin.Model(&types.TaskModel{}).Table("task").Where("deleted_at is null")

	// 用户权限过滤
	if req.UserName != "" && req.UserName != "admin" {
		db = db.Where("user_name = ?", req.UserName)
	}

	// 任务名称模糊查询
	if req.Name != "" {
		db = db.Where("name LIKE ?", "%"+req.Name+"%")
	}

	// 计算类型筛选
	if req.AdapterTypeDict != "" {
		db = db.Where("adapter_type_dict = ?", req.AdapterTypeDict)
	}

	// 任务状态筛选
	if req.Status != "" {
		db = db.Where("status = ?", req.Status)
	}

	// 时间范围筛选
	if req.StartTime != "" && req.EndTime != "" {
		db = db.Where("created_time BETWEEN ? AND ?", req.StartTime, req.EndTime)
	}

	return db
}

// getTaskCount 获取任务总数
func (l *PageListTaskLogic) getTaskCount(req *types.XJLABTaskReq) (int64, error) {
	var total int64
	db := l.buildBaseQuery(req)

	if err := db.Count(&total).Error; err != nil {
		return 0, result.NewDefaultError(err.Error())
	}

	return total, nil
}

// getTaskList 获取任务列表
func (l *PageListTaskLogic) getTaskList(req *types.XJLABTaskReq) ([]*types.TaskModel, error) {
	var list []*types.TaskModel

	limit := req.PageSize
	offset := req.PageSize * (req.PageNum - 1)

	db := l.buildBaseQuery(req)

	if err := db.Limit(limit).Offset(offset).Order("created_time desc").Find(&list).Error; err != nil {
		return nil, result.NewDefaultError(err.Error())
	}

	return list, nil
}

// updateTaskStatusAsync 异步更新任务状态
func (l *PageListTaskLogic) updateTaskStatusAsync(tasks []*types.TaskModel) {
	go l.svcCtx.Scheduler.AiService.St.UpdateTaskStatus(tasks)
	go l.svcCtx.Scheduler.AiService.St.UpdateAiTaskStatus(tasks)
}

// processTaskResponses 处理任务响应数据
func (l *PageListTaskLogic) processTaskResponses(tasks []*types.TaskModel) []*TaskResp {
	taskResps := make([]*TaskResp, 0, len(tasks))

	for _, model := range tasks {
		// 计算运行时间
		model.RunningTime = l.calculateRunningTime(model.StartTime, model.EndTime)

		// 转换为响应结构体
		taskResp, err := l.convertToTaskResp(model)
		if err != nil {
			l.Errorf("Failed to convert task model: %v", err)
			continue
		}

		// 丰富任务详情
		enrichedTask := l.enrichTaskDetails(taskResp)
		taskResps = append(taskResps, &enrichedTask)
	}

	return taskResps
}

// convertToTaskResp 将TaskModel转换为TaskResp
func (l *PageListTaskLogic) convertToTaskResp(model *types.TaskModel) (*TaskResp, error) {
	jsonData, err := jsoniter.Marshal(model)
	if err != nil {
		return nil, err
	}

	var taskResp TaskResp
	if err := jsoniter.Unmarshal(jsonData, &taskResp); err != nil {
		return nil, err
	}

	return &taskResp, nil
}

// calculateRunningTime 计算任务的运行时间
func (l *PageListTaskLogic) calculateRunningTime(startTimeStr, endTimeStr string) int64 {
	if startTimeStr == "" {
		return 0
	}

	startTime := timeutils.TimeStringToGoTime(startTimeStr)

	// 如果没有结束时间，计算到当前时间
	if endTimeStr == "" {
		return int64(time.Since(startTime).Seconds())
	}

	endTime := timeutils.TimeStringToGoTime(endTimeStr)
	return int64(endTime.Sub(startTime).Seconds())
}

// enrichTaskDetails 丰富任务详情
func (l *PageListTaskLogic) enrichTaskDetails(task *TaskResp) TaskResp {
	cluster := l.getClusterInfo(task.Id, task.AdapterTypeDict)

	task.ClusterId = cluster.ClusterId
	task.ClusterName = cluster.ClusterName
	task.ResourceSpec = cluster.ResourceSpec
	task.Card = cluster.Card

	return *task
}

// getClusterInfo 根据适配器类型获取集群信息
func (l *PageListTaskLogic) getClusterInfo(taskId int64, adapterType string) clusterInfo {
	var cluster clusterInfo

	switch adapterType {
	case constants.AdapterTypeCloud:
		// 云计算任务
		l.svcCtx.DbEngin.Table("task_cloud").
			Where("task_id = ?", taskId).
			Select("cluster_id,cluster_name,resource_spec").
			Find(&cluster)

	case constants.AdapterTypeAI:
		// AI计算任务
		l.svcCtx.DbEngin.Table("task_ai").
			Where("task_id = ?", taskId).
			Select("cluster_id,cluster_name,resource_spec,card").
			Find(&cluster)

		// AI任务特殊处理：如果没有resource_spec，使用card字段
		if cluster.ResourceSpec == "" {
			cluster.ResourceSpec = cluster.Card
		}

	case constants.AdapterTypeHPC:
		// 高性能计算任务
		l.svcCtx.DbEngin.Table("task_hpc").
			Where("task_id = ?", taskId).
			Select("cluster_id,cluster_name,resource_spec").
			Find(&cluster)
	}

	return cluster
}