package notify

import (
	"encoding/json"
	"fmt"
	"strconv"
	"time"

	"github.com/linmadan/egglib-go/core/application"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/factory"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/constant"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/infrastructure/dao"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/infrastructure/serviceGateway"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/log"
)

func messageTaskStageAnomaly(companyId int) ([]*domain.MessagePersonal, 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()
	}()
	taskDao := dao.NewTaskDao(map[string]interface{}{"transactionContext": transactionContext})
	userDao := dao.NewUserDao(map[string]interface{}{"transactionContext": transactionContext})
	taskData, err := taskDao.TaskStageAnomalyAll(companyId)
	if err != nil {
		return nil, fmt.Errorf("获取任务信息%s", err)
	}
	if len(taskData) == 0 {
		return nil, nil
	}
	var allMessage []*domain.MessagePersonal
	for _, val := range taskData {
		//获取我全上级
		userList, err := userDao.AllParentUser(val.LeaderId)
		if err != nil {
			return nil, fmt.Errorf("获取上级人员信息%s", err)
		}
		if len(userList) == 0 {
			continue
		}

		for _, val2 := range userList {
			content := ""
			if val2.Level == 1 {
				content = fmt.Sprintf("【您负责的项目【%s】里程碑未按时完成，请重点关注，积极寻找上级辅导。】", val.TaskName)
			} else if val2.Level == 2 {
				content = fmt.Sprintf("【您下级%s负责的项目【%s】里程碑未按时完成，请前往辅导。】", val.LeaderName, val.TaskName)
			} else if val2.Level == 3 {
				content = fmt.Sprintf("【您下级%s关注的项目【%s】里程碑未按时完成，请前往辅导。】", val.LeaderName, val.TaskName)
			}
			if content == "" {
				continue
			}
			payload := map[string]string{
				"task_id":    strconv.Itoa(val.TaskId),
				"task_alias": val.TaskAlias,
				"task_name":  val.TaskName,
			}
			payloadStr, _ := json.Marshal(payload)
			newMessage := domain.MessagePersonal{
				Id:           0,
				Types:        domain.MessageTypesTaskStageApp,
				TargetUserId: val2.Id,
				ReadFlag:     domain.MessageIsRead,
				Title:        content,
				Content:      content,
				CreatedAt:    time.Time{},
				UpdatedAt:    time.Time{},
				Payload:      string(payloadStr),
			}
			allMessage = append(allMessage, &newMessage)
		}
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, err
	}
	return allMessage, nil
}

func saveAllMessagePersonal(msgList []*domain.MessagePersonal) error {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return err
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return err
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	messageRepo := factory.CreateMessagePersonalRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	for _, val := range msgList {
		err = messageRepo.Save(val)
		if err != nil {
			return fmt.Errorf("保存MessagePersonal%s", err)
		}
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return err
	}
	return nil
}

func appMessageSend() error {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return err
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return err
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()

	taskDao := dao.NewTaskDao(map[string]interface{}{"transactionContext": transactionContext})
	//获取公司id
	companyIds, err := taskDao.TaskStageAnomalyForCompany()
	if err != nil {
		return fmt.Errorf("获取公司id%s", err)
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return err
	}
	var appMessage []*domain.MessagePersonal
	for _, val := range companyIds {
		messageList, err := messageTaskStageAnomaly(val)
		if err != nil {
			return fmt.Errorf("生成里程碑异常的消息通知失败%s", err)
		}
		appMessage = append(appMessage, messageList...)
	}

	openApi := serviceGateway.NewHttplibMmmOpenApiServiceGateway()
	for _, val := range appMessage {
		_, err := openApi.PushInfo(1, constant.APP_MESSAGE_KEY, []int64{int64(val.TargetUserId)}, val.Title, val.Content)
		if err != nil {
			log.Logger.Error("发送远端openApi关于里程碑异常的消息通知:" + err.Error())
		}
	}

	err = saveAllMessagePersonal(appMessage)
	if err != nil {
		return fmt.Errorf("保存里程碑异常的消息通知失败%s", err)
	}
	return nil
}

// 关于里程碑异常的消息通知;早上9点 开始检查，并确认发送的消息
func AppMessageRun() {
	nowTime := time.Now()
	y, m, d := nowTime.Date()
	t1 := time.Date(y, m, d, 9, 0, 0, 0, time.Local) //今天的9点
	interval := t1.Sub(nowTime)
	if interval < 0 {
		interval = (24 * time.Hour) + interval
	}
	timer := time.NewTimer(interval)
	for {
		<-timer.C
		err := appMessageSend()
		if err != nil {
			log.Logger.Error("发送关于里程碑异常的消息通知:" + err.Error())
		}
		timer.Reset(24 * time.Hour)
	}
}