package service

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

	"github.com/linmadan/egglib-go/core/application"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/factory"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/notify/adapter"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/notify/command"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/infrastructure/dao"
)

// 个人信息提示

type MessagePersonalService struct {
}

func NewMessagePersonalService() *MessagePersonalService {
	newService := &MessagePersonalService{}
	return newService
}

// 获取今天的周期综合自评消息提示
func (srv *MessagePersonalService) TodayMessageSummaryEvaluationSelf(param *command.GetUserMessageCommand) (map[string]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()
	}()

	nowTime := time.Now()
	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	_, evaluationList, err := evaluationRepo.Find(map[string]interface{}{
		"targetUserId": param.UserId,
		"types":        domain.EvaluationSelf,
		"beginTime":    nowTime,
		"endTime":      nowTime,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "周期综合自评"+err.Error())
	}
	resp := map[string]interface{}{
		"needNotify": false,
		"content":    "",
	}
	if len(evaluationList) == 0 {
		return resp, nil
	}

	messageRepo := factory.CreateMessagePersonalRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	newMessageList := []domain.MessagePersonal{}
	for _, val := range evaluationList {
		payload := map[string]string{
			"id": strconv.Itoa(val.Id),
		}
		payloadStr, _ := json.Marshal(payload)
		cnt, _, err := messageRepo.Find(map[string]interface{}{
			"types":        domain.MessageTypesOther,
			"targetUserId": param.UserId,
			"payload":      string(payloadStr),
			"limit":        1,
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "检查自评消息记录"+err.Error())
		}
		if cnt == 0 {
			newMessageList = append(newMessageList, domain.MessagePersonal{
				Id:           0,
				Types:        domain.MessageTypesOther,
				TargetUserId: val.TargetUser.UserId,
				ReadFlag:     domain.MessageIsRead,
				Title:        fmt.Sprintf("%s综合自评已开启,请前往进行评估.", val.CycleName),
				Content:      fmt.Sprintf("%s综合自评已开启,请前往进行评估.", val.CycleName),
				CreatedAt:    time.Time{},
				UpdatedAt:    time.Time{},
				Payload:      string(payloadStr),
			})
			resp["needNotify"] = true
			resp["content"] = fmt.Sprintf("%s综合自评已开启,请前往进行评估.", val.CycleName)
			break
		}
	}
	for i := range newMessageList {
		err = messageRepo.Save(&newMessageList[i])
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "保存自评消息记录"+err.Error())
		}
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return resp, nil
}

// 获取关于任务反馈碑异常的消息
// 每日一次
func (srv *MessagePersonalService) TodayMessageTaskRecordAnomaly(param *command.GetUserMessageCommand) (map[string]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()
	}()

	messageRepo := factory.CreateMessagePersonalRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	nowDay := time.Now().Format("2006-01-02")
	cnt, _, err := messageRepo.Find(map[string]interface{}{
		"types":        domain.MessageTypesTaskRecord,
		"targetUserId": param.UserId,
		"createdAtDay": nowDay,
		"limit":        1,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "检查任务里程碑异常的消息"+err.Error())
	}
	if cnt > 0 {
		resp := map[string]interface{}{
			"needNotify": false,
			"list":       []adapter.MessageListAdapter{},
		}
		return resp, nil
	}
	userDao := dao.NewUserDao(map[string]interface{}{"transactionContext": transactionContext})

	taskDao := dao.NewTaskDao(map[string]interface{}{"transactionContext": transactionContext})
	// 我作为任务负责人
	leaderIds := []string{strconv.Itoa(param.UserId)}
	taskStageList, err := taskDao.TaskAnomalyByLeader(leaderIds, 1)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "检查任务里程碑异常的消息"+err.Error())
	}
	//获取员工全部子集
	childUser, err := userDao.AllChildUser(param.UserId)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取下级员工"+err.Error())
	}
	childUserId := []string{}
	for _, val := range childUser {
		if val.Level == 2 {
			childUserId = append(childUserId, strconv.Itoa(val.Id))
		}
	}
	//我作为上级， 获取我的下一级的异常任务
	var taskStageList2 []dao.TaskData2
	if len(childUserId) > 0 {
		taskStageList2, err = taskDao.TaskAnomalyByLeader(childUserId, 3)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "检查任务里程碑异常的消息"+err.Error())
		}
	}
	childUserId2 := []string{}
	for _, val := range childUser {
		if val.Level >= 3 {
			childUserId2 = append(childUserId2, strconv.Itoa(val.Id))
		}
	}
	// 我作为上级，获取我的下下级的异常任务
	var taskStageList3 []dao.TaskData2
	if len(childUserId2) > 0 {
		taskStageList3, err = taskDao.TaskAnomalyByLeader(childUserId2, 5)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "检查任务里程碑异常的消息"+err.Error())
		}
	}

	msgList := []adapter.MessageListAdapter{}
	for _, val := range taskStageList {
		s := fmt.Sprintf("【您负责的项目【%s】已超过%s日未反馈进度，请前往该战略任务进行反馈。】", val.Name, val.Anomaly)
		msgList = append(msgList, adapter.MessageListAdapter{
			Content: s,
		})
		payload := map[string]string{
			"id":         strconv.Itoa(val.Id),
			"taskName":   val.Name,
			"taskAlias":  val.Alias,
			"leaderName": val.LeaderName,
		}
		payloadStr, _ := json.Marshal(payload)
		newMessage := domain.MessagePersonal{
			Id:           0,
			Types:        domain.MessageTypesTaskRecord,
			TargetUserId: param.UserId,
			ReadFlag:     domain.MessageIsRead,
			Title:        s,
			Content:      s,
			CreatedAt:    time.Time{},
			UpdatedAt:    time.Time{},
			Payload:      string(payloadStr),
		}
		err = messageRepo.Save(&newMessage)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	}
	for _, val := range taskStageList2 {
		s := fmt.Sprintf("【您下级%s负责的项目【%s】已超过%s日未反馈进度，请前往辅导。】", val.LeaderName, val.Name, val.Anomaly)
		msgList = append(msgList, adapter.MessageListAdapter{
			Content: s,
		})
		payload := map[string]string{
			"id":         strconv.Itoa(val.Id),
			"taskName":   val.Name,
			"taskAlias":  val.Alias,
			"leaderName": val.LeaderName,
		}
		payloadStr, _ := json.Marshal(payload)
		newMessage := domain.MessagePersonal{
			Id:           0,
			Types:        domain.MessageTypesTaskRecord,
			TargetUserId: param.UserId,
			ReadFlag:     domain.MessageIsRead,
			Title:        s,
			Content:      s,
			CreatedAt:    time.Time{},
			UpdatedAt:    time.Time{},
			Payload:      string(payloadStr),
		}
		err = messageRepo.Save(&newMessage)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	}
	for _, val := range taskStageList3 {
		s := fmt.Sprintf("【您下级%s关注的项目【%s】已超过%s日未反馈进度，请前往辅导。】", val.LeaderName, val.Name, val.Anomaly)
		msgList = append(msgList, adapter.MessageListAdapter{
			Content: s,
		})
		payload := map[string]string{
			"id":         strconv.Itoa(val.Id),
			"taskName":   val.Name,
			"taskAlias":  val.Alias,
			"leaderName": val.LeaderName,
		}
		payloadStr, _ := json.Marshal(payload)
		newMessage := domain.MessagePersonal{
			Id:           0,
			Types:        domain.MessageTypesTaskRecord,
			TargetUserId: param.UserId,
			ReadFlag:     domain.MessageIsRead,
			Title:        s,
			Content:      s,
			CreatedAt:    time.Time{},
			UpdatedAt:    time.Time{},
			Payload:      string(payloadStr),
		}
		err = messageRepo.Save(&newMessage)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	resp := map[string]interface{}{
		"needNotify": true,
		"list":       msgList,
	}
	if len(msgList) == 0 {
		resp["needNotify"] = false
	}
	return resp, nil
}

// TodayMessage 任务里程碑变更通知
func (srv *MessagePersonalService) TodayMessageTaskStageModify(param *command.GetUserMessageCommand) (map[string]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()
	}()

	messageRepo := factory.CreateMessagePersonalRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	_, messageList, err := messageRepo.Find(map[string]interface{}{
		"types":        domain.MessageTypesTaskModify,
		"targetUserId": param.UserId,
		"readFlag":     domain.MessageUnread,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "检查个人消息的消息"+err.Error())
	}
	for _, val := range messageList {
		val.ReadFlag = domain.MessageIsRead
		err = messageRepo.Save(val)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "检查个人消息的消息"+err.Error())
		}
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	msgList := []adapter.MessageListAdapter{}
	for _, val := range messageList {
		msgList = append(msgList, adapter.MessageListAdapter{
			Content: val.Content,
		})
	}
	resp := map[string]interface{}{
		"needNotify": true,
		"list":       msgList,
	}
	if len(msgList) == 0 {
		resp["needNotify"] = false
	}
	return resp, nil
}

// 任务里程碑异常的消息弹窗通知,不再使用
func (srv *MessagePersonalService) TodayMessageTaskStageAnomalyV2(param *command.GetUserMessageCommand) (map[string]interface{}, error) {
	resp := map[string]interface{}{
		"needNotify": false,
		"list":       []adapter.MessageListAdapter{},
	}
	return resp, nil
}

// 任务反馈碑异常的消息弹窗内容,不再使用
func (srv *MessagePersonalService) TodayMessageTaskRecordAnomalyV2(param *command.GetUserMessageCommand) (map[string]interface{}, error) {
	resp := map[string]interface{}{
		"needNotify": false,
		"list":       []adapter.MessageListAdapter{},
	}
	return resp, nil
}

// 任务里程碑变更通知,不再使用
func (srv *MessagePersonalService) TodayMessageTaskStageModifyV2(param *command.GetUserMessageCommand) (map[string]interface{}, error) {
	resp := map[string]interface{}{
		"needNotify": false,
		"list":       []adapter.MessageListAdapter{},
	}
	return resp, nil
}

// 里程碑异常的消息弹窗通知
func (srv *MessagePersonalService) TodayMessageTaskAnomaly(param *command.GetUserMessageCommand) (map[string]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()
	}()

	messageRepo := factory.CreateMessagePersonalRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	nowDay := time.Now().Format("2006-01-02")
	cnt, _, err := messageRepo.Find(map[string]interface{}{
		"types":        domain.MessageTypesTaskRecord,
		"targetUserId": param.UserId,
		"createdAtDay": nowDay,
		"limit":        1,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "检查任务里程碑异常的消息"+err.Error())
	}
	if cnt > 0 {
		resp := map[string]interface{}{
			"needNotify": false,
			"list":       []adapter.MessageListAdapter{},
		}
		return resp, nil
	}
	userDao := dao.NewUserDao(map[string]interface{}{"transactionContext": transactionContext})
	// 获取员工全部子集
	childUser, err := userDao.AllChildUser(param.UserId)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取下级员工"+err.Error())
	}
	taskDao := dao.NewTaskDao(map[string]interface{}{"transactionContext": transactionContext})
	//获取异常任务数据
	childUserId := []string{}
	for _, val := range childUser {
		if val.Level == 2 || val.Level == 1 {
			childUserId = append(childUserId, strconv.Itoa(val.Id))
		}
	}
	taskList, err := taskDao.TaskIsAnomalyForNotice(param.CompanyId, childUserId, param.UserId)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "检查任务里异常的消息"+err.Error())
	}
	myUserId := strconv.Itoa(param.UserId)

	var num1, num2, num3 int //我负责的任务，我的下级任务，我相关的任务
	var todayMessage []domain.MessagePersonal
	var msg string
	for _, val := range taskList {
		payload := map[string]string{
			"id":         strconv.Itoa(val.TaskId),
			"taskName":   val.TaskName,
			"taskAlias":  val.TaskAlias,
			"leaderName": val.LeaderName,
		}
		payloadStr, _ := json.Marshal(payload)
		newMessage := domain.MessagePersonal{
			Id:           0,
			Types:        domain.MessageTypesTaskRecord,
			TargetUserId: param.UserId,
			ReadFlag:     domain.MessageIsRead,
			Title:        "",
			Content:      "",
			CreatedAt:    time.Time{},
			UpdatedAt:    time.Time{},
			Payload:      string(payloadStr),
		}
		if val.LeaderId == myUserId {
			//是我负责的项目

			t := 0
			if val.WarnFlag > 0 {
				t += 1
				msg = fmt.Sprintf("您负责的任务【%s】里程碑发生异常，请前往处理。", val.TaskAlias)
			}
			if val.Anomaly > 1 {
				t += 1
				msg = fmt.Sprintf("您负责的任务【%s】已超过%d天没反馈，有异常风险，请前往处理。", val.TaskAlias, val.Anomaly)
			}
			if t > 1 {
				msg = fmt.Sprintf("您负责的任务【%s】里程碑异常、反馈异常，请前往处理。", val.TaskAlias)
			}
			newMessage.Title = msg
			newMessage.Content = msg
			if t > 0 {
				num1 += 1
				todayMessage = append(todayMessage, newMessage)
			}
			continue
		}
		var inChild bool
		for _, val2 := range childUserId {
			//我的下级负责的任务
			if val2 != val.LeaderId {
				continue
			}
			inChild = true
			t := 0
			t2 := []string{}
			if val.WarnFlag > 0 {
				t += 1
				msg = fmt.Sprintf("您下级负责的任务【%s】里程碑发生异常，请前往处理。", val.TaskAlias)
				t2 = append(t2, "里程碑异常")
			}
			if val.Anomaly > 1 {
				t += 1
				msg = fmt.Sprintf("您下级负责的任务【%s】已超过%d天没反馈，有异常风险，请前往处理。", val.TaskAlias, val.Anomaly)
				t2 = append(t2, "反馈异常")
			}
			if val.AssistFlag > val.AssistFlagMax {
				t += 1
				msg = fmt.Sprintf("您需辅导的任务【%s】发生异常，请前往处理", val.TaskAlias)
				t2 = append(t2, "辅导异常")
			}
			if t > 1 {
				msg = fmt.Sprintf("您下级负责的任务【%s】%s，请前往处理。", val.TaskAlias, strings.Join(t2, "、"))
			}
			newMessage.Title = msg
			newMessage.Content = msg
			if t > 0 {
				num2 += 1
				todayMessage = append(todayMessage, newMessage)
			}
			break
		}
		if inChild {
			continue
		}

		// 与我相关的任务
		t := 0
		if val.WarnFlag > 0 {
			t += 1
			msg = fmt.Sprintf("与您相关的任务【%s】里程碑发生异常，请知晓。", val.TaskAlias)
		}
		if val.Anomaly > 1 {
			t += 1
			msg = fmt.Sprintf("与您相关的任务【%s】已超过%d天没反馈，有异常风险，请知晓。", val.TaskAlias, val.Anomaly)
		}
		if t > 1 {
			msg = fmt.Sprintf("与您相关的任务【%s】里程碑异常、反馈异常，请知晓。", val.TaskAlias)
		}
		newMessage.Title = msg
		newMessage.Content = msg
		if t > 0 {
			num3 += 1
			todayMessage = append(todayMessage, newMessage)
		}
	}

	if len(todayMessage) > 0 {
		for i := range todayMessage {
			err = messageRepo.Save(&todayMessage[i])
			if err != nil {
				resp := map[string]interface{}{
					"needNotify": false,
					"list":       []adapter.MessageListAdapter{{Content: err.Error()}},
				}
				return resp, nil
			}
		}
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	resp := map[string]interface{}{
		"needNotify": false,
		"pageSkip":   "1",
	}
	if (num1 + num2 + num3) == 1 {
		resp["needNotify"] = true
		resp["list"] = []adapter.MessageListAdapter{{Content: msg}}
		if num1 > 0 {
			//跳我负责的任务
			resp["pageSkip"] = "1"
		}
		if num2 > 0 {
			//跳我的下级任务
			resp["pageSkip"] = "2"
		}
		if num3 > 0 {
			//跳我的相关的任务
			resp["pageSkip"] = "3"
		}

	} else if (num1 + num2 + num3) > 1 {
		resp["needNotify"] = true
		str := []string{}
		if num1 > 0 {
			str = append(str, fmt.Sprintf("您负责的任务%d个任务", num1))
		}
		if num2 > 0 {
			str = append(str, fmt.Sprintf("下级负责的%d个任务", num2))
		}
		if num3 > 0 {
			str = append(str, fmt.Sprintf("与您有关的%d个任务发生异常", num3))
		}
		resp["list"] = []adapter.MessageListAdapter{{Content: strings.Join(str, "、") + "发生异常，请前往处理。"}}
	}
	return resp, nil
}

// 提醒人员去确认周期评估的成绩
// func (srv *MessagePersonalService) SummaartEvaluationScore(userId int) (msg map[string]interface{}, err error) {
// 	msg = map[string]interface{}{
// 		"needNotify":     false,
// 		"cycleId":        "0",
// 		"cycleName":      "",
// 		"targetUserId":   "0",
// 		"targetUserName": "",
// 	}
// 	transactionContext, err := factory.CreateTransactionContext(nil)
// 	if err != nil {
// 		return msg, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
// 	}
// 	if err := transactionContext.StartTransaction(); err != nil {
// 		return msg, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
// 	}
// 	defer func() {
// 		_ = transactionContext.RollbackTransaction()
// 	}()

// 	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{
// 		"transactionContext": transactionContext,
// 	})

// 	_, evaluationList, err := evaluationRepo.Find(map[string]interface{}{
// 		"targetUserId": userId,
// 		"checkResult":  domain.EvaluationCheckUncompleted,
// 		"types":        5,
// 	})
// 	if err != nil {
// 		return msg, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
// 	}
// 	if len(evaluationList) == 0 {
// 		return msg, nil
// 	}
// 	nowTime := time.Now()
// 	for _, val := range evaluationList {
// 		if nowTime.After(val.EndTime) {
// 			msg = map[string]interface{}{
// 				"needNotify":     true,
// 				"cycleId":        strconv.FormatInt(val.CycleId, 10),
// 				"cycleName":      val.CycleName,
// 				"targetUserId":   strconv.Itoa(val.TargetUser.UserId),
// 				"targetUserName": val.TargetUser.UserName,
// 			}
// 			break
// 		}
// 	}
// 	if err := transactionContext.CommitTransaction(); err != nil {
// 		return msg, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
// 	}

// 	return msg, nil
// }