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() ([]*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()
	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
		}

		var leaderParentId int
		//通知负责人
		for _, val2 := range userList {
			content := ""
			if val2.Level == 1 {
				content = fmt.Sprintf("【您负责的项目【%s】里程碑未按时完成，请重点关注，积极寻找上级辅导。】", val.TaskName)
			} else if val2.Level == 2 {
				leaderParentId = val2.Id
				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{
				"taskId":    strconv.Itoa(val.TaskId),
				"taskAlias": val.TaskAlias,
				"taskName":  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)
		}
		//通知相关人员
		//【您关注的【%s】里程碑未按时完成，请知晓。】
		for _, val2 := range val.RelatedUser {
			if val2 == val.LeaderId {
				continue
			}
			if val2 == leaderParentId {
				continue
			}
			payload := map[string]string{
				"taskId":    strconv.Itoa(val.TaskId),
				"taskAlias": val.TaskAlias,
				"taskName":  val.TaskName,
			}
			payloadStr, _ := json.Marshal(payload)
			content := fmt.Sprintf("【您关注的【%s】里程碑未按时完成，请知晓。】", val.TaskAlias)
			newMessage := domain.MessagePersonal{
				Id:           0,
				Types:        domain.MessageTypesTaskStageApp,
				TargetUserId: val2,
				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
}

// messageTaskRecordAnomaly 反馈异常
func messageTaskRecordAnomaly() ([]*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.TaskRecordAnomalyAll()
	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 {
			payload := map[string]string{
				"taskId":    strconv.Itoa(val.TaskId),
				"taskAlias": val.TaskAlias,
				"taskName":  val.TaskName,
			}
			payloadStr, _ := json.Marshal(payload)
			newMessage := domain.MessagePersonal{
				Id:           0,
				Types:        domain.MessageTypesTaskRecordApp,
				TargetUserId: val2.Id,
				ReadFlag:     domain.MessageIsRead,
				Title:        "",
				Content:      "",
				CreatedAt:    time.Time{},
				UpdatedAt:    time.Time{},
				Payload:      string(payloadStr),
			}
			content := ""
			if val2.Level == 1 {
				content = fmt.Sprintf("【您负责的项目【%s】已超过%d日未反馈进度，请前往该战略任务进行反馈。】", val.TaskName, val.Anomaly)
				newMessage.Content = content
				newMessage.Title = content
				allMessage = append(allMessage, &newMessage)
			}
			if val2.Level == 2 && val.Anomaly > 3 {
				content = fmt.Sprintf("【您下级%s负责的项目【%s】已超过%d日未反馈进度，请前往辅导。】", val.LeaderName, val.TaskName, val.Anomaly)
				newMessage.Content = content
				newMessage.Title = content
				allMessage = append(allMessage, &newMessage)
			}
			if val2.Level == 3 && val.Anomaly > 5 {
				content = fmt.Sprintf("【您下级%s关注的项目【%s】已超过%d日未反馈进度，请前往辅导。】", val.LeaderName, val.TaskName, val.Anomaly)
				newMessage.Content = content
				newMessage.Title = content
				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 {
	var appMessage []*domain.MessagePersonal
	messageList, err := messageTaskStageAnomaly()
	if err != nil {
		return fmt.Errorf("生成里程碑异常的消息通知失败%s", err)
	}
	appMessage = append(appMessage, messageList...)
	messageList2, err := messageTaskRecordAnomaly()
	if err != nil {
		return fmt.Errorf("生成任务反馈异常的消息通知失败%s", err)
	}
	appMessage = append(appMessage, messageList2...)
	openApi := serviceGateway.NewHttplibMmmOpenApiServiceGateway()
	for _, val := range appMessage {
		_, err := openApi.PushInfo(0, 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
	}
	// interval := 10 * time.Second

	timer := time.NewTimer(interval)
	for {
		<-timer.C
		beginTime := time.Now()
		err := appMessageSend()
		if err != nil {
			log.Logger.Error("发送关于任务异常的消息通知:" + err.Error())
		}
		timer.Reset(24 * time.Hour)
		log.Logger.Info(fmt.Sprintf("发送关于任务异常的消息通知用时:%v", time.Since(beginTime).Seconds()))
	}
}