package service

import (
	"github.com/linmadan/egglib-go/core/application"
	"github.com/linmadan/egglib-go/utils/tool_funs"
	"gitlab.fjmaimaimai.com/linmadan/mmm-worth/pkg/application/factory"
	"gitlab.fjmaimaimai.com/linmadan/mmm-worth/pkg/application/notification/command"
	"gitlab.fjmaimaimai.com/linmadan/mmm-worth/pkg/application/notification/query"
	"gitlab.fjmaimaimai.com/linmadan/mmm-worth/pkg/domain"
	"gitlab.fjmaimaimai.com/linmadan/mmm-worth/pkg/domain/service"
	"gitlab.fjmaimaimai.com/linmadan/mmm-worth/pkg/infrastructure/dao"
	"time"
)

// 通知服务
type NotificationService struct {
}

//系统通知快到计划完成时间的任务的对应领取人
func (notificationService *NotificationService) SystemNotificationNearThePlannedCompletionTimeTaskReceiver() (interface{}, 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 notificationRepository domain.NotificationRepository
	if value, err := factory.CreateNotificationRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		notificationRepository = value
	}
	var sentNotificationRepository domain.SentNotificationRepository
	if value, err := factory.CreateSentNotificationRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		sentNotificationRepository = value
	}
	var taskDao *dao.TaskDao
	if value, err := factory.CreateTaskDao(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	} else {
		taskDao = value
	}
	if tasks, err := taskDao.ListNearThePlannedCompletionTimeTask(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		for _, task := range tasks {
			notification := &domain.Notification{
				NotificationType:     domain.NOTIFICATION_TYPE_SYSTEM,
				NotificationTitle:    "任务快到计划完成时间，尽快完成哦",
				NotificationContent:  task.TaskName,
				NotificationTime:     time.Now(),
				ExternalResourceType: domain.EXTERNAL_RESOURCE_TYPE_TASK,
				ExternalResource:     task.Id,
			}
			if notification, err := notificationRepository.Save(notification); err != nil {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			} else {
				var receiver *domain.EmployeeInfo
				if task.TaskType == domain.TASK_TYPE_ROB {
					receiver = task.RobInfo.Receiver
				}
				if task.TaskType == domain.TASK_TYPE_BID {
					receiver = task.BidInfo.SuccessfulBidder
				}
				if task.TaskType == domain.TASK_TYPE_DESIGNATE {
					receiver = task.AssignedPerson
				}
				sentNotification := &domain.SentNotification{
					Notification: notification,
					Receiver:     receiver,
					IsRead:       false,
					ReadTime:     time.Time{},
				}
				if _, err := sentNotificationRepository.Save(sentNotification); err != nil {
					return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
				}
			}
		}
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		} else {
			return true, nil
		}
	}
}

//系统通知快到竞标截止时间的任务的对应发布人
func (notificationService *NotificationService) SystemNotificationNearBidEndTimeTaskSponsor() (interface{}, 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 notificationRepository domain.NotificationRepository
	if value, err := factory.CreateNotificationRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		notificationRepository = value
	}
	var sentNotificationRepository domain.SentNotificationRepository
	if value, err := factory.CreateSentNotificationRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		sentNotificationRepository = value
	}
	var taskDao *dao.TaskDao
	if value, err := factory.CreateTaskDao(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	} else {
		taskDao = value
	}
	if tasks, err := taskDao.ListNearThePlannedCompletionTimeTask(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		for _, task := range tasks {
			notification := &domain.Notification{
				NotificationType:     domain.NOTIFICATION_TYPE_SYSTEM,
				NotificationTitle:    "竞标任务截止时间就差一天就结束了",
				NotificationContent:  task.TaskName,
				NotificationTime:     time.Now(),
				ExternalResourceType: domain.EXTERNAL_RESOURCE_TYPE_TASK,
				ExternalResource:     task.Id,
			}
			if notification, err := notificationRepository.Save(notification); err != nil {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			} else {
				sentNotification := &domain.SentNotification{
					Notification: notification,
					Receiver:     task.Sponsor,
					IsRead:       false,
					ReadTime:     time.Time{},
				}
				if _, err := sentNotificationRepository.Save(sentNotification); err != nil {
					return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
				}
			}
		}
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		} else {
			return true, nil
		}
	}
}

// 读取发送出的通知
func (notificationService *NotificationService) ReadSentNotification(readSentNotificationCommand *command.ReadSentNotificationCommand) (interface{}, error) {
	if err := readSentNotificationCommand.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 readSentNotificationService service.ReadSentNotificationService
	if value, err := factory.CreateReadSentNotificationService(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		readSentNotificationService = value
	}
	if sentNotification, err := readSentNotificationService.Read(readSentNotificationCommand.SentNotificationId); 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 sentNotification, nil
	}
}

// 读取全部未读取的发送出的通知
func (notificationService *NotificationService) ReadAllUnReadSentNotification(readAllUnReadSentNotificationCommand *command.ReadAllUnReadSentNotificationCommand) (interface{}, error) {
	if err := readAllUnReadSentNotificationCommand.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 readAllUnReadSentNotificationService service.ReadAllUnReadSentNotificationService
	if value, err := factory.CreateReadAllUnReadSentNotificationService(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		readAllUnReadSentNotificationService = value
	}
	if readCount, err := readAllUnReadSentNotificationService.ReadAll(readAllUnReadSentNotificationCommand.ReceiverId); 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 readCount, nil
	}
}

// 返回发送出的通知列表
func (notificationService *NotificationService) ListSentNotification(listSentNotificationQuery *query.ListSentNotificationQuery) (interface{}, error) {
	if err := listSentNotificationQuery.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 sentNotificationRepository domain.SentNotificationRepository
	if value, err := factory.CreateSentNotificationRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	}); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	} else {
		sentNotificationRepository = value
	}
	if count, sentNotifications, err := sentNotificationRepository.Find(tool_funs.SimpleStructToMap(listSentNotificationQuery)); 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{}{
			"count":             count,
			"sentNotifications": sentNotifications,
		}, nil
	}
}

func NewNotificationService(options map[string]interface{}) *NotificationService {
	newNotificationService := &NotificationService{}
	return newNotificationService
}