package oa

import (
	"WiiCITMS/models/oa"
	"WiiCITMS/process/common"
	"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"
)

// WorkflowServiceImpl 工作流服务实现
type WorkflowServiceImpl struct{}

// 确保WorkflowServiceImpl实现了WorkflowService接口
var _ common.WorkflowService = (*WorkflowServiceImpl)(nil)

// 工作流模型适配器
type workflowModelAdapter struct {
	*oa.WorkflowModel
}

func (w *workflowModelAdapter) GetGuid() string {
	return w.RecordGuid.String()
}

// 工作流节点适配器
type workflowNodeModelAdapter struct {
	*oa.WorkflowNodeModel
}

func (n *workflowNodeModelAdapter) GetGuid() string {
	return n.RecordGuid.String()
}

func (n *workflowNodeModelAdapter) GetType() int16 {
	return n.NodeType
}

func (n *workflowNodeModelAdapter) GetApproverType() int16 {
	return n.ApproverType
}

func (n *workflowNodeModelAdapter) GetApproverValue() string {
	return n.ApproverValue
}

// 工作流实例适配器
type workflowInstanceModelAdapter struct {
	*oa.WorkflowInstanceModel
}

func (i *workflowInstanceModelAdapter) GetGuid() string {
	return i.RecordGuid.String()
}

func (i *workflowInstanceModelAdapter) GetWorkflowGuid() string {
	return i.WorkflowGuid.String()
}

func (i *workflowInstanceModelAdapter) GetCurrentNodeID() string {
	return i.CurrentNodeID.String()
}

func (i *workflowInstanceModelAdapter) GetInitiatorGuid() string {
	return i.InitiatorGuid.String()
}

func (i *workflowInstanceModelAdapter) GetStatus() int16 {
	return i.Status
}

func (i *workflowInstanceModelAdapter) GetCreateTime() time.Time {
	return i.CreateTime
}

func (i *workflowInstanceModelAdapter) GetUpdateTime() time.Time {
	return i.UpdateTime
}

func (i *workflowInstanceModelAdapter) GetCompletionTime() time.Time {
	return i.CompletionTime
}

// 审批记录适配器
type approvalRecordModelAdapter struct {
	*oa.ApprovalRecordModel
}

func (a *approvalRecordModelAdapter) GetGuid() string {
	return a.RecordGuid.String()
}

func (a *approvalRecordModelAdapter) GetStatus() int16 {
	return a.Status
}

func (a *approvalRecordModelAdapter) GetComment() string {
	return a.Comment
}

func (a *approvalRecordModelAdapter) GetApproverGuid() string {
	return a.ApproverGuid.String()
}

func (a *approvalRecordModelAdapter) GetCreateTime() time.Time {
	return a.CreateTime
}

func (a *approvalRecordModelAdapter) GetActionTime() time.Time {
	return a.ActionTime
}

// CreateWorkflow 创建工作流
func (svc *WorkflowServiceImpl) CreateWorkflow(params common.CreateWorkflowRequest) (common.WorkflowModel, *process.Process) {
	// 创建工作流
	workflow := oa.WorkflowInstance()
	workflow.WorkflowName = params.WorkflowName
	workflow.WorkflowType = int16(params.WorkflowType)
	workflow.Description = params.Description

	// 设置创建人
	if params.CreatorGuid != "" {
		creatorGuid, err := unique.FromString(params.CreatorGuid)
		if err == nil {
			workflow.Creator = creatorGuid
		}
	}

	// 保存工作流
	r := dblib.DBIns.DB.Create(workflow)
	if r.Error != nil {
		return nil, process.FailError(types.CreateWorkflowError, r.Error)
	}

	return &workflowModelAdapter{workflow}, process.Success(200)
}

// QueryWorkflows 查询工作流列表
func (svc *WorkflowServiceImpl) QueryWorkflows(params common.QueryWorkflowsRequest) ([]common.WorkflowModel, *process.Process) {
	result := make([]*oa.WorkflowModel, 0)
	db := dblib.DBIns.DB.Model(&oa.WorkflowModel{}).Where("(RecordStatus & 524288) = 0")

	// 按工作流名称筛选
	if params.WorkflowName != "" {
		db = db.Where("WorkflowName LIKE ?", "%"+params.WorkflowName+"%")
	}

	// 按工作流类型筛选
	if params.WorkflowType >= 0 {
		db = db.Where("WorkflowType = ?", params.WorkflowType)
	}

	// 按是否启用筛选
	if params.IsActive {
		db = db.Where("IsActive = 1")
	}

	// 分页查询
	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 nil, process.FailError(types.QueryWorkflowError, r.Error)
	}

	// 转换为接口类型
	models := make([]common.WorkflowModel, len(result))
	for i, w := range result {
		models[i] = &workflowModelAdapter{w}
	}

	return models, process.Success(200)
}

// CreateWorkflowNode 创建工作流节点
func (svc *WorkflowServiceImpl) CreateWorkflowNode(params common.CreateNodeRequest) (common.WorkflowNodeModel, *process.Process) {
	// 验证工作流是否存在
	workflowGuid, err := unique.FromString(params.WorkflowGuid)
	if err != nil {
		return nil, process.FailError(types.InvalidOACreateParamError, err)
	}

	workflow := &oa.WorkflowModel{}
	r := dblib.DBIns.DB.Where("RecordGuid = ? AND (RecordStatus & 524288) = 0", workflowGuid).First(workflow)
	if r.Error != nil {
		return nil, process.FailError(types.WorkflowNotFoundError, r.Error)
	}

	// 创建工作流节点
	node := oa.WorkflowNodeInstance()
	node.WorkflowGuid = workflowGuid
	node.NodeName = params.NodeName
	node.NodeType = int16(params.NodeType)
	node.NodeOrder = params.NodeOrder
	node.ApproverType = int16(params.ApproverType)
	node.ApproverValue = params.ApproverValue
	node.ConditionExp = params.ConditionExp
	node.Description = params.Description

	// 保存节点
	r = dblib.DBIns.DB.Create(node)
	if r.Error != nil {
		return nil, process.FailError(types.CreateWorkflowNodeError, r.Error)
	}

	return &workflowNodeModelAdapter{node}, process.Success(200)
}

// StartWorkflowInstance 启动工作流实例
func (svc *WorkflowServiceImpl) StartWorkflowInstance(params common.CreateInstanceRequest, checkPermission bool) (common.WorkflowInstanceModel, *process.Process) {
	// 使用事务确保操作的原子性
	tx := dblib.DBIns.DB.Begin()

	// 验证工作流是否存在并且处于激活状态
	workflowGuid, err := unique.FromString(params.WorkflowGuid)
	if err != nil {
		tx.Rollback()
		return nil, process.FailError(types.InvalidWorkflowInstanceParamError, err)
	}

	workflow := &oa.WorkflowModel{}
	r := tx.Where("RecordGuid = ? AND IsActive = 1 AND (RecordStatus & 524288) = 0", workflowGuid).First(workflow)
	if r.Error != nil {
		tx.Rollback()
		return nil, process.FailError(types.WorkflowNotFoundOrInactiveError, r.Error)
	}

	// 解析发起人ID
	initiatorGuid, err := unique.FromString(params.InitiatorGuid)
	if err != nil {
		tx.Rollback()
		return nil, process.FailError(types.InvalidWorkflowInstanceParamError, err)
	}

	// 创建工作流实例
	instance := oa.WorkflowInstanceInstance()
	instance.WorkflowGuid = workflowGuid
	instance.Title = params.Title
	instance.BusinessType = int16(params.BusinessType)
	instance.BusinessID = params.BusinessID
	instance.InitiatorGuid = initiatorGuid
	instance.Status = 0 // 进行中
	instance.FormData = params.FormData

	// 保存实例
	r = tx.Create(instance)
	if r.Error != nil {
		tx.Rollback()
		return nil, process.FailError(types.CreateWorkflowInstanceError, r.Error)
	}

	// 获取工作流的第一个节点
	firstNode := &oa.WorkflowNodeModel{}
	r = tx.Where("WorkflowGuid = ? AND NodeType = 1 AND (RecordStatus & 524288) = 0", workflowGuid).
		Order("NodeOrder ASC").First(firstNode)
	if r.Error != nil {
		tx.Rollback()
		return nil, process.FailError(types.WorkflowStartNodeNotFoundError, r.Error)
	}

	// 设置当前节点为第一个节点
	instance.CurrentNodeID = firstNode.RecordGuid
	r = tx.Save(instance)
	if r.Error != nil {
		tx.Rollback()
		return nil, process.FailError(types.UpdateWorkflowInstanceError, r.Error)
	}

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

	return &workflowInstanceModelAdapter{instance}, process.Success(200)
}

// QueryWorkflowInstances 查询工作流实例
func (svc *WorkflowServiceImpl) QueryWorkflowInstances(params common.QueryInstancesRequest) ([]common.WorkflowInstanceModel, *process.Process) {
	result := make([]*oa.WorkflowInstanceModel, 0)
	db := dblib.DBIns.DB.Model(&oa.WorkflowInstanceModel{}).Where("(RecordStatus & 524288) = 0")

	// 按工作流ID筛选
	if params.WorkflowGuid != "" {
		workflowGuid, err := unique.FromString(params.WorkflowGuid)
		if err == nil {
			db = db.Where("WorkflowGuid = ?", workflowGuid)
		}
	}

	// 按业务类型筛选
	if params.BusinessType >= 0 {
		db = db.Where("BusinessType = ?", params.BusinessType)
	}
	
	// 按业务ID筛选
	if params.BusinessID != "" {
		db = db.Where("BusinessID = ?", params.BusinessID)
	}

	// 按发起人筛选
	if params.InitiatorGuid != "" {
		initiatorGuid, err := unique.FromString(params.InitiatorGuid)
		if err == nil {
			db = db.Where("InitiatorGuid = ?", initiatorGuid)
		}
	}

	// 按状态筛选
	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 nil, process.FailError(types.QueryWorkflowInstanceError, r.Error)
	}

	// 转换为接口类型
	instances := make([]common.WorkflowInstanceModel, len(result))
	for i, instance := range result {
		instances[i] = &workflowInstanceModelAdapter{instance}
	}

	return instances, process.Success(200)
}

// QueryApprovalHistory 查询审批历史
func (svc *WorkflowServiceImpl) QueryApprovalHistory(instanceGuid string) ([]common.ApprovalRecordModel, *process.Process) {
	// 解析实例ID
	guid, err := unique.FromString(instanceGuid)
	if err != nil {
		return nil, process.FailError(types.InvalidWorkflowInstanceParamError, err)
	}

	// 查询审批记录
	records := make([]*oa.ApprovalRecordModel, 0)
	r := dblib.DBIns.DB.Where("InstanceGuid = ? AND (RecordStatus & 524288) = 0", guid).
		Order("CreateTime ASC").Find(&records)
	if r.Error != nil {
		return nil, process.FailError(types.QueryWorkflowError, r.Error)
	}

	// 转换为接口类型
	approvalRecords := make([]common.ApprovalRecordModel, len(records))
	for i, record := range records {
		approvalRecords[i] = &approvalRecordModelAdapter{record}
	}

	return approvalRecords, process.Success(200)
}

// CheckPermission 检查权限
func (svc *WorkflowServiceImpl) CheckPermission(staffGuid string, operation string, instanceGuid string) *process.Process {
	// 获取工作流实例
	instance, proc := GetWorkflowInstance(instanceGuid)
	if proc.IsError() {
		return proc
	}

	// 根据操作类型检查权限
	switch operation {
	case common.OperationView:
		// 检查是否是发起人
		if instance.InitiatorGuid.String() == staffGuid {
			return process.Success(200)
		}

		// 检查是否是审批人
		isApprover := false
		nodes, proc := GetWorkflowNodes(instance.WorkflowGuid.String())
		if proc.IsError() {
			return proc
		}

		for _, node := range nodes {
			if node.ApproverType == 1 && node.ApproverValue == staffGuid {
				isApprover = true
				break
			}
		}

		if isApprover {
			return process.Success(200)
		}

		// 如果既不是发起人又不是审批人，返回权限错误
		return process.FailError(types.NoPermissionError, errors.New("无权查看此工作流"))

	case common.OperationApprove:
		// 获取当前节点
		node, proc := GetWorkflowNode(instance.CurrentNodeID.String())
		if proc.IsError() {
			return proc
		}

		// 检查是否是审批节点
		if node.NodeType != common.NodeTypeApprove {
			return process.FailError(types.InvalidWorkflowStatusError, errors.New("当前节点不是审批节点"))
		}

		// 检查是否是指定审批人
		if node.ApproverType == 1 && node.ApproverValue == staffGuid {
			return process.Success(200)
		}

		// 如果不是指定审批人，返回权限错误
		return process.FailError(types.NoPermissionError, errors.New("无权限进行此审批操作"))

	default:
		return process.FailError(types.InvalidParamError, errors.New("不支持的操作类型"))
	}
}

// 初始化函数，注册工作流服务
func init() {
	common.WorkflowSvc = &WorkflowServiceImpl{}
}