package opsdev

import (
	"context"

	"dashoo.cn/common_definition/comm_def"
	"dashoo.cn/opms_libary/myerrors"
	opsdevmodel "dashoo.cn/opms_parent/app/model/opsdev"
	services "dashoo.cn/opms_parent/app/service/opsdev"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/util/gvalid"
)

// OpsEventTaskHandler 软件交付任务接口处理类
type OpsEventTaskHandler struct{}

// GetList 分页查询任务列表
func (h *OpsEventTaskHandler) GetList(ctx context.Context, req *opsdevmodel.OpsEventTaskSearchReq, rsp *comm_def.CommonMsg) error {
	s, err := services.NewOpsEventTaskService(ctx)
	if err != nil {
		return err
	}
	total, list, err := s.GetList(req)
	if err != nil {
		return err
	}
	rsp.Data = g.Map{"list": list, "total": total}
	return nil
}

// Create 新增任务
func (h *OpsEventTaskHandler) Create(ctx context.Context, req *opsdevmodel.OpsEventTaskAddReq, rsp *comm_def.CommonMsg) error {
	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
		return myerrors.ValidError(err.Error())
	}
	s, err := services.NewOpsEventTaskService(ctx)
	if err != nil {
		return err
	}
	if err := s.Create(req); err != nil {
		return err
	}
	rsp.Data = g.Map{"message": "新增成功"}
	return nil
}

// UpdateById 更新任务
func (h *OpsEventTaskHandler) UpdateById(ctx context.Context, req *opsdevmodel.OpsEventTaskUpdateReq, rsp *comm_def.CommonMsg) error {
	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
		return myerrors.ValidError(err.Error())
	}
	s, err := services.NewOpsEventTaskService(ctx)
	if err != nil {
		return err
	}
	if err := s.UpdateById(req); err != nil {
		return err
	}
	rsp.Data = g.Map{"message": "更新成功"}
	return nil
}

// DeleteByIds 删除
func (h *OpsEventTaskHandler) DeleteByIds(ctx context.Context, req *opsdevmodel.OpsEventTaskDeleteReq, rsp *comm_def.CommonMsg) error {
	if len(req.Ids) == 0 {
		return myerrors.ValidError("请选择需要删除的记录")
	}
	s, err := services.NewOpsEventTaskService(ctx)
	if err != nil {
		return err
	}
	if err := s.DeleteByIds(req.Ids); err != nil {
		return err
	}
	rsp.Data = g.Map{"message": "删除成功"}
	return nil
}

// GetById 根据ID获取
func (h *OpsEventTaskHandler) GetById(ctx context.Context, req *opsdevmodel.IdReq, rsp *comm_def.CommonMsg) error {
	if req.Id <= 0 {
		return myerrors.ValidError("ID不能为空")
	}
	s, err := services.NewOpsEventTaskService(ctx)
	if err != nil {
		return err
	}
	data, err := s.GetById(req.Id)
	if err != nil {
		return err
	}
	rsp.Data = g.Map{"data": data}
	return nil
}

// Schedule 调度
func (h *OpsEventTaskHandler) Schedule(ctx context.Context, req *opsdevmodel.OpsEventTaskScheduleReq, rsp *comm_def.CommonMsg) error {
	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
		return myerrors.ValidError(err.Error())
	}
	s, err := services.NewOpsEventTaskService(ctx)
	if err != nil {
		return err
	}
	if err := s.Schedule(req); err != nil {
		return err
	}
	rsp.Data = g.Map{"message": "排期成功"}
	return nil
}

// Start 开始
func (h *OpsEventTaskHandler) Start(ctx context.Context, req *opsdevmodel.OpsEventTaskStartReq, rsp *comm_def.CommonMsg) error {
	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
		return myerrors.ValidError(err.Error())
	}
	s, err := services.NewOpsEventTaskService(ctx)
	if err != nil {
		return err
	}
	if err := s.Start(req); err != nil {
		return err
	}
	rsp.Data = g.Map{"message": "任务已开始"}
	return nil
}

// Complete 完成
func (h *OpsEventTaskHandler) Complete(ctx context.Context, req *opsdevmodel.OpsEventTaskCompleteReq, rsp *comm_def.CommonMsg) error {
	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
		return myerrors.ValidError(err.Error())
	}
	s, err := services.NewOpsEventTaskService(ctx)
	if err != nil {
		return err
	}
	if err := s.Complete(req); err != nil {
		return err
	}
	rsp.Data = g.Map{"message": "任务已完成"}
	return nil
}

// Pause 暂停
func (h *OpsEventTaskHandler) Pause(ctx context.Context, req *opsdevmodel.OpsEventTaskPauseReq, rsp *comm_def.CommonMsg) error {
	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
		return myerrors.ValidError(err.Error())
	}
	s, err := services.NewOpsEventTaskService(ctx)
	if err != nil {
		return err
	}
	if err := s.Pause(req); err != nil {
		return err
	}
	rsp.Data = g.Map{"message": "任务已暂停"}
	return nil
}

// Block 阻塞
func (h *OpsEventTaskHandler) Block(ctx context.Context, req *opsdevmodel.OpsEventTaskBlockReq, rsp *comm_def.CommonMsg) error {
	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
		return myerrors.ValidError(err.Error())
	}
	s, err := services.NewOpsEventTaskService(ctx)
	if err != nil {
		return err
	}
	if err := s.Block(req); err != nil {
		return err
	}
	rsp.Data = g.Map{"message": "任务已阻塞"}
	return nil
}

// Cancel 作废
func (h *OpsEventTaskHandler) Cancel(ctx context.Context, req *opsdevmodel.OpsEventTaskCancelReq, rsp *comm_def.CommonMsg) error {
	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
		return myerrors.ValidError(err.Error())
	}
	s, err := services.NewOpsEventTaskService(ctx)
	if err != nil {
		return err
	}
	if err := s.Cancel(req); err != nil {
		return err
	}
	rsp.Data = g.Map{"message": "任务已作废"}
	return nil
}

// GetRecords 获取过程记录
func (h *OpsEventTaskHandler) GetRecords(ctx context.Context, req *opsdevmodel.OpsEventTaskRecordSearchReq, rsp *comm_def.CommonMsg) error {
	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
		return myerrors.ValidError(err.Error())
	}
	s, err := services.NewOpsEventTaskService(ctx)
	if err != nil {
		return err
	}
	list, err := s.GetRecords(req)
	if err != nil {
		return err
	}
	rsp.Data = g.Map{"list": list}
	return nil
}

// GetAttachments 获取附件列表
func (h *OpsEventTaskHandler) GetAttachments(ctx context.Context, req *opsdevmodel.IdReq, rsp *comm_def.CommonMsg) error {
	if req.Id <= 0 {
		return myerrors.ValidError("任务ID不能为空")
	}
	s, err := services.NewOpsEventTaskService(ctx)
	if err != nil {
		return err
	}
	list, err := s.GetAttachments(req.Id)
	if err != nil {
		return err
	}
	rsp.Data = g.Map{"list": list}
	return nil
}

// GetTaskReleaseList 获取发布版本关联的任务列表
func (h *OpsEventTaskHandler) GetTaskReleaseList(ctx context.Context, req *opsdevmodel.OpsEventTaskReleaseListReq, rsp *comm_def.CommonMsg) error {
	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
		return myerrors.ValidError(err.Error())
	}
	s, err := services.NewOpsEventTaskService(ctx)
	if err != nil {
		return err
	}
	list, err := s.GetTaskReleaseList(req)
	if err != nil {
		return err
	}
	rsp.Data = g.Map{"list": list}
	return nil
}

// AddRecord 添加任务过程记录
func (h *OpsEventTaskHandler) AddRecord(ctx context.Context, req *opsdevmodel.OpsEventTaskRecordAddReq, rsp *comm_def.CommonMsg) error {
	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
		return myerrors.ValidError(err.Error())
	}
	s, err := services.NewOpsEventTaskService(ctx)
	if err != nil {
		return err
	}
	if err := s.AddRecord(req); err != nil {
		return err
	}
	rsp.Data = g.Map{"message": "添加成功"}
	return nil
}

// AddWorkHour 添加工时登记
func (h *OpsEventTaskHandler) AddWorkHour(ctx context.Context, req *opsdevmodel.OpsEventTaskWorkHourAddReq, rsp *comm_def.CommonMsg) error {
	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
		return myerrors.ValidError(err.Error())
	}
	s, err := services.NewOpsEventTaskService(ctx)
	if err != nil {
		return err
	}
	if err := s.AddWorkHour(req); err != nil {
		return err
	}
	rsp.Data = g.Map{"message": "工时登记成功"}
	return nil
}

// GetWorkHourList 获取工时登记列表
func (h *OpsEventTaskHandler) GetWorkHourList(ctx context.Context, req *opsdevmodel.OpsEventTaskWorkHourListReq, rsp *comm_def.CommonMsg) error {
	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
		return myerrors.ValidError(err.Error())
	}
	s, err := services.NewOpsEventTaskService(ctx)
	if err != nil {
		return err
	}
	list, err := s.GetWorkHourList(req)
	if err != nil {
		return err
	}
	rsp.Data = g.Map{"list": list}
	return nil
}