package service

import (
	"fmt"
	"github.com/linmadan/egglib-go/core/application"
	"github.com/linmadan/egglib-go/utils/tool_funs"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/application/cooperationMode/command"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/application/cooperationMode/query"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/application/factory"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/domain/service"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/infrastructure/dao"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-cooperation/pkg/infrastructure/utils"
	"strconv"
	"time"
)

// CooperationModeService 共创模式服务
type CooperationModeService struct {
}

// CreateCooperationMode 创建共创模式服务
func (cooperationModeService *CooperationModeService) CreateCooperationMode(createCooperationModeCommand *command.CreateCooperationModeCommand) (interface{}, error) {
	if err := createCooperationModeCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()

	// 用户REST服务初始化
	var userService service.UserService
	if value, err := factory.CreateUserService(map[string]interface{}{}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		userService = value
	}

	// 获取操作人
	var operator *domain.User
	if data, err := userService.OperatorFrom(createCooperationModeCommand.CompanyId, createCooperationModeCommand.OrgId, createCooperationModeCommand.UserId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		operator = data
	}

	// 公司REST服务初始化
	var companyService service.CompanyService
	if value, err := factory.CreateCompanyService(map[string]interface{}{}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		companyService = value
	}

	// 获取公司信息
	var company *domain.Company
	if data, err := companyService.CompanyFrom(createCooperationModeCommand.CompanyId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		company = data
	}

	// 组织机构REST服务初始化
	var organizationService service.OrgService
	if value, err := factory.CreateOrganizationService(map[string]interface{}{}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		organizationService = value
	}

	// 获取组织机构信息
	var organization *domain.Org
	if data, err := organizationService.OrgFrom(createCooperationModeCommand.CompanyId, createCooperationModeCommand.OrgId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		organization = data
	}

	// 共创模式DAO初始化
	var cooperationModeDao *dao.CooperationModeDao
	if value, err := factory.CreateCooperationModeDao(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	} else {
		cooperationModeDao = value
	}
	// 校验共创模式编码唯一性
	numberAvailable, _ := cooperationModeDao.CheckModeNumberAvailable(map[string]interface{}{
		"companyId":             createCooperationModeCommand.CompanyId,
		"orgId":                 createCooperationModeCommand.OrgId,
		"cooperationModeNumber": createCooperationModeCommand.CooperationModeNumber,
	})
	if !numberAvailable {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "模式编码已存在")
	}
	// 校验共创模式名称唯一性
	nameAvailable, _ := cooperationModeDao.CheckModeNameAvailable(map[string]interface{}{
		"companyId":           createCooperationModeCommand.CompanyId,
		"orgId":               createCooperationModeCommand.OrgId,
		"cooperationModeName": createCooperationModeCommand.CooperationModeName,
	})
	if !nameAvailable {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "模式名称已存在")
	}

	newCooperationMode := &domain.CooperationMode{
		CooperationModeName:   createCooperationModeCommand.CooperationModeName,
		CooperationModeNumber: createCooperationModeCommand.CooperationModeNumber,
		Remarks:               createCooperationModeCommand.Remarks,
		Company:               company,
		Org:                   organization,
		Operator:              operator,
		OperateTime:           time.Now(),
		UpdatedAt:             time.Time{},
		DeletedAt:             time.Time{},
		CreatedAt:             time.Now(),
	}

	var cooperationModeRepository domain.CooperationModeRepository
	if value, err := factory.CreateCooperationModeRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationModeRepository = value
	}
	if cooperationMode, err := cooperationModeRepository.Save(newCooperationMode); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return cooperationMode, nil
	}
}

// GetCooperationMode 返回共创模式服务
func (cooperationModeService *CooperationModeService) GetCooperationMode(getCooperationModeQuery *query.GetCooperationModeQuery) (interface{}, error) {
	if err := getCooperationModeQuery.ValidateQuery(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	var cooperationModeRepository domain.CooperationModeRepository
	if value, err := factory.CreateCooperationModeRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationModeRepository = value
	}
	cooperationMode, err := cooperationModeRepository.FindOne(map[string]interface{}{"cooperationModeId": getCooperationModeQuery.CooperationModeId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if cooperationMode == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", strconv.FormatInt(getCooperationModeQuery.CooperationModeId, 10)))
	} else {
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return cooperationMode, nil
	}
}

// ListCooperationMode 返回共创模式服务列表
func (cooperationModeService *CooperationModeService) ListCooperationMode(listCooperationModeQuery *query.ListCooperationModeQuery) (interface{}, error) {
	if err := listCooperationModeQuery.ValidateQuery(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	var cooperationModeRepository domain.CooperationModeRepository
	if value, err := factory.CreateCooperationModeRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationModeRepository = value
	}
	if count, cooperationModes, err := cooperationModeRepository.Find(tool_funs.SimpleStructToMap(listCooperationModeQuery)); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return map[string]interface{}{
			"list":  cooperationModes,
			"total": count,
		}, nil
	}
}

// RemoveCooperationMode 移除共创模式服务
func (cooperationModeService *CooperationModeService) RemoveCooperationMode(removeCooperationModeCommand *command.RemoveCooperationModeCommand) (interface{}, error) {
	if err := removeCooperationModeCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	var cooperationModeRepository domain.CooperationModeRepository
	if value, err := factory.CreateCooperationModeRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationModeRepository = value
	}
	cooperationMode, err := cooperationModeRepository.FindOne(map[string]interface{}{"cooperationModeId": removeCooperationModeCommand.CooperationModeId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if cooperationMode == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", strconv.FormatInt(removeCooperationModeCommand.CooperationModeId, 10)))
	}
	if cooperationMode, err := cooperationModeRepository.Remove(cooperationMode); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return cooperationMode, nil
	}
}

// BatchRemoveCooperationMode 移除共创模式服务
func (cooperationModeService *CooperationModeService) BatchRemoveCooperationMode(batchRemoveCooperationModeCommand *command.BatchRemoveCooperationModeCommand) (interface{}, error) {
	if err := batchRemoveCooperationModeCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	var cooperationModeRepository domain.CooperationModeRepository
	if value, err := factory.CreateCooperationModeRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationModeRepository = value
	}
	cooperationModeIds, _ := utils.SliceAtoi(batchRemoveCooperationModeCommand.CooperationModeIds)
	if count, cooperationModes, err := cooperationModeRepository.Find(map[string]interface{}{
		"cooperationModeIds": cooperationModeIds,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if count > 0 {
			if cooperationMode, err := cooperationModeRepository.BatchRemove(cooperationModes); err != nil {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			} else {
				if err := transactionContext.CommitTransaction(); err != nil {
					return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
				}
				return cooperationMode, nil
			}
		}
	}
	return map[string]interface{}{}, nil
}

// SearchCooperationMode 查询共创模式
func (cooperationModeService *CooperationModeService) SearchCooperationMode(searchCooperationModeQuery *query.SearchCooperationModeQuery) (interface{}, error) {
	if err := searchCooperationModeQuery.ValidateQuery(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	var cooperationModeRepository domain.CooperationModeRepository
	if value, err := factory.CreateCooperationModeRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationModeRepository = value
	}
	if count, cooperationModes, err := cooperationModeRepository.Find(tool_funs.SimpleStructToMap(searchCooperationModeQuery)); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return map[string]interface{}{
			"list":  cooperationModes,
			"total": count,
		}, nil
	}
}

// UpdateCooperationMode 更新共创模式服务
func (cooperationModeService *CooperationModeService) UpdateCooperationMode(updateCooperationModeCommand *command.UpdateCooperationModeCommand) (interface{}, error) {
	if err := updateCooperationModeCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	var cooperationModeRepository domain.CooperationModeRepository
	if value, err := factory.CreateCooperationModeRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationModeRepository = value
	}
	// 共创模式DAO初始化
	var cooperationModeDao *dao.CooperationModeDao
	if value, err := factory.CreateCooperationModeDao(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	} else {
		cooperationModeDao = value
	}
	// 校验共创模式名称唯一性
	nameAvailable, _ := cooperationModeDao.CheckModeNameAvailable(map[string]interface{}{
		"companyId":           updateCooperationModeCommand.CompanyId,
		"orgId":               updateCooperationModeCommand.OrgId,
		"cooperationModeName": updateCooperationModeCommand.CooperationModeName,
	})
	if !nameAvailable {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "模式名称已存在")
	}

	cooperationMode, err := cooperationModeRepository.FindOne(map[string]interface{}{"cooperationModeId": updateCooperationModeCommand.CooperationModeId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if cooperationMode == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", strconv.FormatInt(updateCooperationModeCommand.CooperationModeId, 10)))
	}
	if err := cooperationMode.Update(tool_funs.SimpleStructToMap(updateCooperationModeCommand)); err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	if cooperationMode, err := cooperationModeRepository.Save(cooperationMode); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return cooperationMode, nil
	}
}

// OperateCooperationMode 更新共创模式服务
func (cooperationModeService *CooperationModeService) OperateCooperationMode(operateCooperationModeCommand *command.OperateCooperationModeCommand) (interface{}, error) {
	if err := operateCooperationModeCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	var cooperationModeRepository domain.CooperationModeRepository
	if value, err := factory.CreateCooperationModeRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		cooperationModeRepository = value
	}
	cooperationModeId, _ := strconv.ParseInt(operateCooperationModeCommand.CooperationModeId, 10, 64)
	cooperationMode, err := cooperationModeRepository.FindOne(map[string]interface{}{"cooperationModeId": cooperationModeId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if cooperationMode == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%s", strconv.FormatInt(cooperationModeId, 10)))
	}
	if err := cooperationMode.Update(tool_funs.SimpleStructToMap(operateCooperationModeCommand)); err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	if cooperationMode, err := cooperationModeRepository.Save(cooperationMode); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return cooperationMode, nil
	}
}

// BatchOperateCooperationMode 更新共创模式服务
func (cooperationModeService *CooperationModeService) BatchOperateCooperationMode(batchOperateCooperationModeCommand *command.BatchOperateCooperationModeCommand) (interface{}, error) {
	if err := batchOperateCooperationModeCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	// 共创模式DAO初始化
	var cooperationModeDao *dao.CooperationModeDao
	if value, err := factory.CreateCooperationModeDao(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	} else {
		cooperationModeDao = value
	}
	if len(batchOperateCooperationModeCommand.CooperationModeIds) <= 0 {
		return map[string]interface{}{}, nil
	}
	cooperationModeIds, err := utils.SliceAtoi(batchOperateCooperationModeCommand.CooperationModeIds)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "共创模式ID错误")
	}
	if cooperationModes, err := cooperationModeDao.UpdateCooperationModeSlice(cooperationModeIds, batchOperateCooperationModeCommand.Status); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	} else {
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return map[string]interface{}{
			"cooperationModes": cooperationModes,
		}, nil
	}
}

func NewCooperationModeService(options map[string]interface{}) *CooperationModeService {
	newCooperationModeService := &CooperationModeService{}
	return newCooperationModeService
}