package oa

import (
	"WiiCITMS/models/oa"
	"WiiGenerates/WiiCITMS/generates/v1/go/types"
	"WiiGoLibrary/apply/middle/process/v1"
	"WiiGoLibrary/framework/db/v1/utils/mssql/unique"
	"WiiGoLibrary/framework/hub/v1/dblib"
	"errors"
	"time"
)

// QueryMyApprovalTasksRequest 查询我的审批任务请求参数
type QueryMyApprovalTasksRequest struct {
	ApproverGuid string `json:"approverGuid"` // 审批人ID
	Status       int    `json:"status"`       // 状态，-1表示所有状态
	Limit        int    `json:"limit"`        // 分页参数，每页数量
	Offset       int    `json:"offset"`       // 分页参数，偏移量
}

// ApprovalActionRequest 审批操作请求参数
type ApprovalActionRequest struct {
	RecordGuid string `json:"recordGuid"` // 审批记录ID
	Status     int    `json:"status"`     // 操作结果：1-同意，2-拒绝，3-转交，4-委托
	Comment    string `json:"comment"`    // 审批意见
	TargetGuid string `json:"targetGuid"` // 转交/委托目标人ID（如果是转交或委托操作）
}

// QueryApprovalHistory 查询流程审批历史
func QueryApprovalHistory(instanceGuid string) ([]*oa.ApprovalRecordModel, *process.Process) {
	result := make([]*oa.ApprovalRecordModel, 0)

	// 验证实例ID格式
	guid, err := unique.FromString(instanceGuid)
	if err != nil {
		return nil, process.FailError(types.InvalidApprovalParamError, err)
	}

	// 查询该实例的所有审批记录
	r := dblib.DBIns.DB.Where("InstanceGuid = ? AND (RecordStatus & 524288) = 0", guid).
		Order("CreateTime ASC").Find(&result)
	if r.Error != nil {
		return result, process.FailError(types.QueryApprovalHistoryError, r.Error)
	}

	return result, process.Success(200)
}

// QueryMyApprovalTasks 查询我的待审批任务
func QueryMyApprovalTasks(params QueryMyApprovalTasksRequest) ([]*oa.ApprovalRecordModel, *process.Process) {
	result := make([]*oa.ApprovalRecordModel, 0)

	// 验证审批人ID
	approverGuid, err := unique.FromString(params.ApproverGuid)
	if err != nil {
		return nil, process.FailError(types.InvalidApprovalParamError, err)
	}

	// 构建查询条件
	db := dblib.DBIns.DB.Model(&oa.ApprovalRecordModel{}).
		Where("ApproverGuid = ? AND (RecordStatus & 524288) = 0", approverGuid)

	// 按状态筛选
	if params.Status >= 0 {
		db = db.Where("Status = ?", params.Status)
	}

	// 分页查询
	limit := params.Limit
	if limit <= 0 {
		limit = 20 // 默认每页20条
	}
	offset := params.Offset
	if offset < 0 {
		offset = 0
	}

	r := db.Limit(limit).Offset(offset).Order("CreateTime DESC").Find(&result)
	if r.Error != nil {
		return result, process.FailError(types.QueryApprovalTasksError, r.Error)
	}

	return result, process.Success(200)
}

// ProcessApproval 处理审批
func ProcessApproval(params ApprovalActionRequest) (*oa.ApprovalRecordModel, *process.Process) {
	// 使用事务确保操作的原子性
	tx := dblib.DBIns.DB.Begin()

	// 获取审批记录
	recordGuid, err := unique.FromString(params.RecordGuid)
	if err != nil {
		tx.Rollback()
		return nil, process.FailError(types.InvalidApprovalParamError, err)
	}

	approvalRecord := &oa.ApprovalRecordModel{}
	r := tx.Where("RecordGuid = ? AND (RecordStatus & 524288) = 0", recordGuid).First(approvalRecord)
	if r.Error != nil {
		tx.Rollback()
		return nil, process.FailError(types.ApprovalRecordNotFoundError, r.Error)
	}

	// 只有待处理的审批才能处理
	if approvalRecord.Status != 0 {
		tx.Rollback()
		return nil, process.FailError(types.InvalidApprovalStatusError, errors.New("只有待处理的审批才能处理"))
	}

	// 更新审批记录
	approvalRecord.Status = int16(params.Status)
	approvalRecord.Comment = params.Comment
	approvalRecord.ActionTime = time.Now()

	// 处理转交或委托
	if params.Status == 3 || params.Status == 4 { // 转交或委托
		if params.TargetGuid == "" {
			tx.Rollback()
			return nil, process.FailError(types.InvalidApprovalParamError, errors.New("转交或委托操作需要指定目标人"))
		}

		targetGuid, err := unique.FromString(params.TargetGuid)
		if err != nil {
			tx.Rollback()
			return nil, process.FailError(types.InvalidApprovalParamError, err)
		}

		if params.Status == 3 { // 转交
			approvalRecord.HandoverTo = targetGuid
		}

		// 创建新的审批记录给目标人
		newApproval := oa.ApprovalRecordInstance()
		newApproval.InstanceGuid = approvalRecord.InstanceGuid
		newApproval.NodeGuid = approvalRecord.NodeGuid
		newApproval.ApproverGuid = targetGuid
		newApproval.Status = 0 // 待处理

		if params.Status == 4 { // 委托
			newApproval.DelegateFrom = approvalRecord.ApproverGuid
		}

		r = tx.Create(newApproval)
		if r.Error != nil {
			tx.Rollback()
			return nil, process.FailError(types.CreateApprovalRecordError, r.Error)
		}
	} else if params.Status == 1 || params.Status == 2 { // 同意或拒绝
		// 获取工作流实例
		instance := &oa.WorkflowInstanceModel{}
		r = tx.Where("RecordGuid = ? AND (RecordStatus & 524288) = 0", approvalRecord.InstanceGuid).First(instance)
		if r.Error != nil {
			tx.Rollback()
			return nil, process.FailError(types.WorkflowInstanceNotFoundError, r.Error)
		}

		// 获取当前节点
		currentNode := &oa.WorkflowNodeModel{}
		r = tx.Where("RecordGuid = ? AND (RecordStatus & 524288) = 0", approvalRecord.NodeGuid).First(currentNode)
		if r.Error != nil {
			tx.Rollback()
			return nil, process.FailError(types.WorkflowNodeNotFoundError, r.Error)
		}

		if params.Status == 2 { // 拒绝
			// 更新实例状态为已拒绝
			instance.Status = 2 // 已拒绝
			instance.CompletionTime = time.Now()
			r = tx.Save(instance)
			if r.Error != nil {
				tx.Rollback()
				return nil, process.FailError(types.UpdateWorkflowInstanceError, r.Error)
			}
		} else { // 同意
			// 查找下一个节点
			nextNode := &oa.WorkflowNodeModel{}
			r = tx.Where("WorkflowGuid = ? AND NodeOrder > ? AND (RecordStatus & 524288) = 0",
				currentNode.WorkflowGuid, currentNode.NodeOrder).
				Order("NodeOrder ASC").First(nextNode)

			if r.Error != nil { // 没有下一个节点，流程结束
				instance.Status = 1 // 已完成
				instance.CompletionTime = time.Now()
				r = tx.Save(instance)
				if r.Error != nil {
					tx.Rollback()
					return nil, process.FailError(types.UpdateWorkflowInstanceError, r.Error)
				}
			} else if nextNode.NodeType == 2 { // 下一个节点是审批节点
				// 解析审批人
				var nextApproverGuid unique.UUID
				if nextNode.ApproverType == 1 { // 指定人
					nextApproverGuid, err = unique.FromString(nextNode.ApproverValue)
					if err != nil {
						tx.Rollback()
						return nil, process.FailError(types.InvalidApproverError, err)
					}
				} else {
					// 其他类型的审批人逻辑（角色、部门负责人等）
					// 这里简化处理，实际项目中需要根据不同的审批人类型查询对应的审批人
					tx.Rollback()
					return nil, process.FailError(types.UnsupportedApproverTypeError, errors.New("暂不支持的审批人类型"))
				}

				// 创建下一个审批任务
				nextApproval := oa.ApprovalRecordInstance()
				nextApproval.InstanceGuid = instance.RecordGuid
				nextApproval.NodeGuid = nextNode.RecordGuid
				nextApproval.ApproverGuid = nextApproverGuid
				nextApproval.Status = 0 // 待处理

				r = tx.Create(nextApproval)
				if r.Error != nil {
					tx.Rollback()
					return nil, process.FailError(types.CreateApprovalRecordError, r.Error)
				}

				// 更新实例当前节点
				instance.CurrentNodeID = nextNode.RecordGuid
				r = tx.Save(instance)
				if r.Error != nil {
					tx.Rollback()
					return nil, process.FailError(types.UpdateWorkflowInstanceError, r.Error)
				}
			} else if nextNode.NodeType == 5 { // 结束节点
				instance.Status = 1 // 已完成
				instance.CompletionTime = time.Now()
				instance.CurrentNodeID = nextNode.RecordGuid
				r = tx.Save(instance)
				if r.Error != nil {
					tx.Rollback()
					return nil, process.FailError(types.UpdateWorkflowInstanceError, r.Error)
				}
			} else { // 其他类型节点，暂不支持
				tx.Rollback()
				return nil, process.FailError(types.UnsupportedNodeTypeError, errors.New("暂不支持的节点类型"))
			}
		}
	} else {
		tx.Rollback()
		return nil, process.FailError(types.InvalidApprovalParamError, errors.New("无效的操作类型"))
	}

	// 保存审批记录的更新
	r = tx.Save(approvalRecord)
	if r.Error != nil {
		tx.Rollback()
		return nil, process.FailError(types.UpdateApprovalRecordError, r.Error)
	}

	// 提交事务
	if err := tx.Commit().Error; err != nil {
		return nil, process.FailError(types.TransactionCommitError, err)
	}

	return approvalRecord, process.Success(200)
}