package service

import (
	"fmt"
	"time"

	"github.com/linmadan/egglib-go/core/application"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-basic/pkg/application/factory"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-basic/pkg/application/noticeSetting/command"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-basic/pkg/application/noticeSetting/query"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-basic/pkg/domain"
)

// 编排消息通知内容
type NoticeSettingService struct {
}

// 返回编排消息通知内容
func (noticeSettingService *NoticeSettingService) GetNoticeSetting(getNoticeSettingQuery *query.GetNoticeSettingQuery) (interface{}, error) {
	if err := getNoticeSettingQuery.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 noticeSettingRepository domain.NoticeSettingRepository
	if value, err := factory.CreateNoticeSettingRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		noticeSettingRepository = value
	}
	noticeSetting, err := noticeSettingRepository.FindOne(map[string]interface{}{
		"noticeSettingId": getNoticeSettingQuery.NoticeSettingId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if noticeSetting == nil {
		return nil, application.ThrowError(application.RES_NO_FIND_ERROR, fmt.Sprintf("%d", getNoticeSettingQuery.NoticeSettingId))
	} else {
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return noticeSetting, nil
	}
}

// 返回编排消息通知内容列表
func (noticeSettingService *NoticeSettingService) ListNoticeSetting(listNoticeSettingQuery *query.ListNoticeSettingQuery) (int64, interface{}, error) {
	if err := listNoticeSettingQuery.ValidateQuery(); err != nil {
		return 0, nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return 0, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return 0, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	var noticeSettingRepository domain.NoticeSettingRepository
	if value, err := factory.CreateNoticeSettingRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return 0, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		noticeSettingRepository = value
	}

	queryOption := map[string]interface{}{
		"pageIndex": listNoticeSettingQuery.PageIndex,
		"pageSize":  listNoticeSettingQuery.PageSize,
		"companyId": listNoticeSettingQuery.CompanyId,
	}
	if listNoticeSettingQuery.OrgId > 0 {
		queryOption["orgId"] = listNoticeSettingQuery.OrgId
	}
	if count, noticeSettings, err := noticeSettingRepository.Find(queryOption); err != nil {
		return 0, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		if err := transactionContext.CommitTransaction(); err != nil {
			return 0, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return count,
			noticeSettings,
			nil
	}
}

// 更新编排消息通知内容
func (noticeSettingService *NoticeSettingService) UpdateNoticeSetting(updateNoticeSettingCommand *command.UpdateNoticeSettingCommand) (interface{}, error) {
	if err := updateNoticeSettingCommand.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 noticeSettingRepository domain.NoticeSettingRepository
	if value, err := factory.CreateNoticeSettingRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		noticeSettingRepository = value
	}
	var (
		noticeSettings []*domain.NoticeSetting
		noticeSetting  *domain.NoticeSetting
	)
	_, noticeSettings, err = noticeSettingRepository.Find(map[string]interface{}{
		"companyId":    updateNoticeSettingCommand.CompanyId,
		"orgId":        updateNoticeSettingCommand.OrgId,
		"moduleAction": updateNoticeSettingCommand.ModuleAction,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if len(noticeSettings) > 1 {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "配置信息重复")
	}
	if len(noticeSettings) > 0 {
		//存在旧的数据
		noticeSetting = noticeSettings[0]
		if noticeSetting.NoticeSettingId != updateNoticeSettingCommand.NoticeSettingId {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "配置信息已存在")
		}
	}
	noticeSetting, err = noticeSettingRepository.FindOne(map[string]interface{}{
		"noticeSettingId": updateNoticeSettingCommand.NoticeSettingId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	err = noticeSetting.Update(map[string]interface{}{
		"content":      updateNoticeSettingCommand.Content,
		"isPush":       updateNoticeSettingCommand.IsPush,
		"module":       updateNoticeSettingCommand.Module,
		"moduleAction": updateNoticeSettingCommand.ModuleAction,
		"updatedAt":    time.Now(),
	})
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	if noticeSetting, err := noticeSettingRepository.Save(noticeSetting); 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 noticeSetting, nil
	}
}

// 更新编排消息通知内容
func (noticeSettingService *NoticeSettingService) AddNoticeSetting(addNoticeSettingCommand *command.AddNoticeSettingCommand) (interface{}, error) {
	if err := addNoticeSettingCommand.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 noticeSettingRepository domain.NoticeSettingRepository
	if value, err := factory.CreateNoticeSettingRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		noticeSettingRepository = value
	}
	var (
		noticeSettings []*domain.NoticeSetting
		noticeSetting  *domain.NoticeSetting
	)
	_, noticeSettings, err = noticeSettingRepository.Find(map[string]interface{}{
		"companyId":    addNoticeSettingCommand.CompanyId,
		"orgId":        addNoticeSettingCommand.OrgId,
		"moduleAction": addNoticeSettingCommand.ModuleAction,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if len(noticeSettings) > 0 {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "该环节配置已存在")
	}
	noticeSetting = &domain.NoticeSetting{
		CompanyId:    addNoticeSettingCommand.CompanyId,
		Content:      addNoticeSettingCommand.Content,
		IsPush:       addNoticeSettingCommand.IsPush,
		Module:       addNoticeSettingCommand.Module,
		ModuleAction: addNoticeSettingCommand.ModuleAction,
		OrgId:        addNoticeSettingCommand.OrgId,
		CreatedAt:    time.Now(),
		UpdatedAt:    time.Now(),
	}
	if noticeSetting, err := noticeSettingRepository.Save(noticeSetting); 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 noticeSetting, nil
	}
}

// //InitNoticeSetting 为企业初始化消息列表，填充空白的消息模板
// func (noticeSettingService *NoticeSettingService) InitNoticeSetting(initCommand *command.InitNoticeSettingCommand) error {
// 	if err := initCommand.ValidateCommand(); err != nil {
// 		return application.ThrowError(application.ARG_ERROR, err.Error())
// 	}
// 	transactionContext, err := factory.CreateTransactionContext(nil)
// 	if err != nil {
// 		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
// 	}
// 	if err := transactionContext.StartTransaction(); err != nil {
// 		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
// 	}
// 	defer func() {
// 		transactionContext.RollbackTransaction()
// 	}()
// 	var noticeSettingRepository domain.NoticeSettingRepository
// 	if value, err := factory.CreateNoticeSettingRepository(map[string]interface{}{
// 		"transactionContext": transactionContext,
// 	}); err != nil {
// 		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
// 	} else {
// 		noticeSettingRepository = value
// 	}
// 	_, noticeSets, err := noticeSettingRepository.Find(map[string]interface{}{
// 		"companyId": initCommand.CompanyId,
// 		"orgId":     initCommand.OrgId,
// 	})
// 	if err != nil {
// 		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
// 	}
// 	notticeExist := make(map[string]int)
// 	for i := range noticeSets {
// 		notticeExist[noticeSets[i].ModuleAction] = 1
// 	}
// 	defaultModuleAction := domain.GetNoticeModuleActionList()
// 	newEmptySetting := []domain.NoticeSetting{}
// 	for _, act := range defaultModuleAction {
// 		if _, ok := notticeExist[act.ActionCode]; !ok {
// 			newEmptySetting = append(newEmptySetting, domain.NoticeSetting{
// 				CompanyId:    initCommand.CompanyId,
// 				OrgId:        initCommand.OrgId,
// 				Module:       act.ModuleCode,
// 				ModuleAction: act.ActionCode,
// 				CreatedAt:    time.Now(),
// 				UpdatedAt:    time.Now(),
// 				Content:      "",
// 				IsPush:       domain.NoticeSettingIsNotPush,
// 			})
// 		}
// 	}
// 	for i := range newEmptySetting {
// 		_, err = noticeSettingRepository.Save(&newEmptySetting[i])
// 		if err != nil {
// 			return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
// 		}
// 	}
// 	if err := transactionContext.CommitTransaction(); err != nil {
// 		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
// 	}
// 	return nil
// }

func NewNoticeSettingService(options map[string]interface{}) *NoticeSettingService {
	newNoticeSettingService := &NoticeSettingService{}
	return newNoticeSettingService
}