package project_module_version

import (
	"fmt"
	"github.com/tiptok/gocomm/common"
	"github.com/tiptok/gocomm/pkg/log"
	"gitlab.fjmaimaimai.com/mmm-go/godevp/pkg/application/factory"
	"gitlab.fjmaimaimai.com/mmm-go/godevp/pkg/domain"
	"gitlab.fjmaimaimai.com/mmm-go/godevp/pkg/infrastructure/dao"
	"gitlab.fjmaimaimai.com/mmm-go/godevp/pkg/infrastructure/utils"
	"gitlab.fjmaimaimai.com/mmm-go/godevp/pkg/protocol"
	protocolx "gitlab.fjmaimaimai.com/mmm-go/godevp/pkg/protocol/project_module_version"
	"strings"
	"time"
)

type ProjectModuleVersionService struct {
}

func (svr *ProjectModuleVersionService) CreateProjectModuleVersion(header *protocol.RequestHeader, request *protocolx.CreateProjectModuleVersionRequest) (rsp interface{}, err error) {
	var (
		transactionContext, _ = factory.CreateTransactionContext(nil)
	)
	rsp = &protocolx.CreateProjectModuleVersionResponse{}
	if err = request.ValidateCommand(); err != nil {
		err = protocol.NewCustomMessage(2, err.Error())
		return
	}
	if err = transactionContext.StartTransaction(); err != nil {
		log.Error(err)
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	newProjectModuleVersion := &domain.ProjectModuleVersion{
		Version:     strings.TrimSpace(request.Version),
		Description: request.Description,
		Status:      domain.StatusNormal,
		CreateTime:  time.Now(),
		UpdateTime:  time.Now(),
	}

	var ProjectModuleVersionRepository, _ = factory.CreateProjectModuleVersionRepository(transactionContext)
	var srcVersion, dstVersion *domain.ProjectModuleVersion
	var currentPMVersionId int64
	if srcVersion, err = ProjectModuleVersionRepository.FindOne(map[string]interface{}{"id": request.CurrentProjectModuleVersionId}); err != nil {
		err = protocol.NewCustomMessage(1, fmt.Sprintf("当前版本不存在,请重试"))
		return
	}
	newProjectModuleVersion.ProjectModuleId = srcVersion.ProjectModuleId

	if _, e := ProjectModuleVersionRepository.FindOne(map[string]interface{}{"projectModuleId": srcVersion.ProjectModuleId, "version": strings.TrimSpace(request.Version), "status": domain.StatusNormal}); e == nil {
		err = protocol.NewCustomMessage(1, fmt.Sprintf("当前版本已存在:"+request.Version))
		return
	}
	if dstVersion, err = ProjectModuleVersionRepository.Save(newProjectModuleVersion); err != nil {
		return
	} else {
		currentPMVersionId = dstVersion.Id
		rsp = dstVersion
	}

	var ProjectModuleDao, _ = dao.NewProjectModuleDao(transactionContext)
	if err = ProjectModuleDao.DuplicateVersion(srcVersion.ProjectModuleId, srcVersion.Id, currentPMVersionId); err != nil {
		return
	}
	if err = ProjectModuleDao.FixParentIdByPath(srcVersion.ProjectModuleId, currentPMVersionId); err != nil {
		return
	}
	err = transactionContext.CommitTransaction()
	return
}

func (svr *ProjectModuleVersionService) UpdateProjectModuleVersion(header *protocol.RequestHeader, request *protocolx.UpdateProjectModuleVersionRequest) (rsp interface{}, err error) {
	var (
		transactionContext, _ = factory.CreateTransactionContext(nil)
	)
	rsp = &protocolx.UpdateProjectModuleVersionResponse{}
	if err = request.ValidateCommand(); err != nil {
		err = protocol.NewCustomMessage(2, err.Error())
		return
	}
	if err = transactionContext.StartTransaction(); err != nil {
		log.Error(err)
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	var ProjectModuleVersionRepository, _ = factory.CreateProjectModuleVersionRepository(transactionContext)
	var projectModuleVersion *domain.ProjectModuleVersion
	if projectModuleVersion, err = ProjectModuleVersionRepository.FindOne(map[string]interface{}{"id": request.ProjectModuleVersionId}); err != nil {
		err = protocol.NewCustomMessage(1, "版本信息不存在")
		return
	}
	// 修改版本号
	if len(request.Version) > 0 && projectModuleVersion.Version != request.Version {
		if _, err = ProjectModuleVersionRepository.FindOne(map[string]interface{}{"projectModuleId": projectModuleVersion.ProjectModuleId, "version": request.Version}); err == nil {
			err = protocol.NewCustomMessage(1, "版本信息已存在:"+request.Version)
			return
		}
	}
	if err = projectModuleVersion.Update(common.ObjectToMap(request)); err != nil {
		return
	}
	if projectModuleVersion, err = ProjectModuleVersionRepository.Save(projectModuleVersion); err != nil {
		return
	}
	err = transactionContext.CommitTransaction()
	return
}

func (svr *ProjectModuleVersionService) GetProjectModuleVersion(header *protocol.RequestHeader, request *protocolx.GetProjectModuleVersionRequest) (rsp interface{}, err error) {
	var (
		transactionContext, _ = factory.CreateTransactionContext(nil)
	)
	rsp = &protocolx.GetProjectModuleVersionResponse{}
	if err = request.ValidateCommand(); err != nil {
		err = protocol.NewCustomMessage(2, err.Error())
		return
	}
	if err = transactionContext.StartTransaction(); err != nil {
		log.Error(err)
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	var ProjectModuleVersionRepository, _ = factory.CreateProjectModuleVersionRepository(transactionContext)
	var projectModuleVersion *domain.ProjectModuleVersion
	if projectModuleVersion, err = ProjectModuleVersionRepository.FindOne(common.ObjectToMap(request)); err != nil {
		err = protocol.NewCustomMessage(1, "版本信息不存在")
		return
	}
	rsp = projectModuleVersion
	err = transactionContext.CommitTransaction()
	return
}

func (svr *ProjectModuleVersionService) DeleteProjectModuleVersion(header *protocol.RequestHeader, request *protocolx.DeleteProjectModuleVersionRequest) (rsp interface{}, err error) {
	var (
		transactionContext, _ = factory.CreateTransactionContext(nil)
	)
	rsp = &protocolx.DeleteProjectModuleVersionResponse{}
	if err = request.ValidateCommand(); err != nil {
		err = protocol.NewCustomMessage(2, err.Error())
	}
	if err = transactionContext.StartTransaction(); err != nil {
		log.Error(err)
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	var ProjectModuleVersionRepository, _ = factory.CreateProjectModuleVersionRepository(transactionContext)
	var projectModuleVersion *domain.ProjectModuleVersion
	if projectModuleVersion, err = ProjectModuleVersionRepository.FindOne(common.ObjectToMap(request)); err != nil {
		err = protocol.NewCustomMessage(1, "版本信息不存在")
		return
	}
	if projectModuleVersion.Status == domain.StatusDelete {
		err = protocol.NewCustomMessage(1, "已删除")
		return
	}
	projectModuleVersion.SetStatusDelete()
	if projectModuleVersion, err = ProjectModuleVersionRepository.Save(projectModuleVersion); err != nil {
		return
	}
	rsp = projectModuleVersion
	err = transactionContext.CommitTransaction()
	return
}

func (svr *ProjectModuleVersionService) ListProjectModuleVersion(header *protocol.RequestHeader, request *protocolx.ListProjectModuleVersionRequest) (rsp interface{}, err error) {
	var (
		transactionContext, _ = factory.CreateTransactionContext(nil)
	)
	rsp = &protocolx.ListProjectModuleVersionResponse{}
	if err = request.ValidateCommand(); err != nil {
		err = protocol.NewCustomMessage(2, err.Error())
	}
	if err = transactionContext.StartTransaction(); err != nil {
		log.Error(err)
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	var ProjectModuleVersionRepository, _ = factory.CreateProjectModuleVersionRepository(transactionContext)
	var projectModuleVersion []*domain.ProjectModuleVersion
	var total int64
	if total, projectModuleVersion, err = ProjectModuleVersionRepository.Find(map[string]interface{}{"projectModuleId": request.ProjectModuleId, "status": domain.StatusNormal}); err != nil {
		return
	}
	rsp = map[string]interface{}{
		"totalRow": total,
		"list":     utils.LoadCustomField(projectModuleVersion, "Id", "ProjectModuleId", "Description", "Version", "Status"),
	}
	err = transactionContext.CommitTransaction()
	return
}

func NewProjectModuleVersionService(options map[string]interface{}) *ProjectModuleVersionService {
	svr := &ProjectModuleVersionService{}
	return svr
}