package scheduler

import (
	"context"
	"eta/eta_mini_crm/models"
	"eta/eta_mini_crm/utils"
	"fmt"
	"time"

	"github.com/beego/beego/v2/task"
)

func InitJob() {
	fmt.Println("消息推送任务开启。。。")
	// 每天凌晨12点10分检测, 发送消息
	tk1 := task.NewTask("SendReminderMsg", "0 10 0 * * *", SendReminderMsg)
	task.AddTask("发送消息提醒", tk1)
	// 每天凌晨12点检测, 修改用户状态
	tk2 := task.NewTask("ModifyUserStatus", "5 0 0 * * *", ModifyUserStatus)
	task.AddTask("定时修改用户状态", tk2)
	// 每隔5分钟，同步报告状态
	tk3 := task.NewTask("SyncReportPushStatus", "0 0/5 * * * *", SyncReportPushStatus)
	task.AddTask("定时同步报告推送状态", tk3)
	task.StartTask()
}

func SyncReportPushStatus(ctx context.Context) (err error) {
	defer func() {
		if err != nil {
			utils.FileLog.Info("同步研报推送状态出错，Err: %s", err)
		}
		if err := recover(); err != nil {
			utils.FileLog.Warn("同步研报推送状态出错，定时任务出错，Err: %s", err)
		}
	}()

	// 获取前30分钟修改的数据
	startTime := time.Now().Add(-30 * time.Minute).Format(utils.FormatDateTime)
	conditon := " AND modify_time >= ?"
	var pars []interface{}
	pars = append(pars, startTime)
	reportList, err := models.GetReportByCondition(conditon, pars)
	var reportIds []int
	for _, v := range reportList {
		reportIds = append(reportIds, v.Id)
	}
	reportPushList, err := models.GetReportPushStatusByReportIds(utils.ReportTypeEta, reportIds)
	if err != nil {
		return
	}
	reportPushMap := make(map[int]*models.ReportPushStatus)
	for _, v := range reportPushList {
		reportPushMap[v.ReportId] = v
	}
	var insertReportPushList []*models.ReportPushStatus
	for _, v := range reportList {
		var updateCols []string
		if reportPush, ok := reportPushMap[v.Id]; ok {
			if reportPush.Title != v.Title {
				reportPush.Title = v.Title
				updateCols = append(updateCols, "title")
			}
			if reportPush.Abstract != v.Abstract {
				reportPush.Abstract = v.Abstract
				updateCols = append(updateCols, "abstract")
			}
			if reportPush.Stage != v.Stage {
				reportPush.Stage = v.Stage
				updateCols = append(updateCols, "stage")
			}
			if reportPush.ClassifyIdFirst != v.ClassifyIdFirst {
				reportPush.ClassifyIdFirst = v.ClassifyIdFirst
				updateCols = append(updateCols, "classify_id_first")
			}
			if reportPush.ClassifyNameFirst != v.ClassifyNameFirst {
				reportPush.ClassifyNameFirst = v.ClassifyNameFirst
				updateCols = append(updateCols, "classify_name_first")
			}
			if reportPush.ClassifyIdSecond != v.ClassifyIdSecond {
				reportPush.ClassifyIdSecond = v.ClassifyIdSecond
				updateCols = append(updateCols, "classify_id_second")
			}
			if reportPush.ClassifyNameSecond != v.ClassifyNameSecond {
				reportPush.ClassifyNameSecond = v.ClassifyNameSecond
				updateCols = append(updateCols, "classify_name_second")
			}
			if reportPush.ClassifyIdThird != v.ClassifyIdThird {
				reportPush.ClassifyIdThird = v.ClassifyIdThird
				updateCols = append(updateCols, "classify_id_third")
			}
			if reportPush.ClassifyNameThird != v.ClassifyNameThird {
				reportPush.ClassifyNameThird = v.ClassifyNameThird
				updateCols = append(updateCols, "classify_name_third")
			}
			if reportPush.Author != v.Author {
				reportPush.Author = v.Author
				updateCols = append(updateCols, "author")
			}
			if reportPush.PublishTime != v.PublishTime {
				reportPush.PublishTime = v.PublishTime
				updateCols = append(updateCols, "publish_time")
			}
			if len(updateCols) > 0 {
				reportPush.Update(updateCols)
			}
		} else {
			insertReportPushList = append(insertReportPushList, &models.ReportPushStatus{
				ReportId:           v.Id,
				State:              0,
				Title:              v.Title,
				Abstract:           v.Abstract,
				Stage:              v.Stage,
				ClassifyIdFirst:    v.ClassifyIdFirst,
				ClassifyNameFirst:  v.ClassifyNameFirst,
				ClassifyIdSecond:   v.ClassifyIdSecond,
				ClassifyNameSecond: v.ClassifyNameSecond,
				ClassifyIdThird:    v.ClassifyIdThird,
				ClassifyNameThird:  v.ClassifyNameThird,
				Author:             v.Author,
				ReportType:         1,
				PublishTime:        v.PublishTime,
				CreateTime:         time.Now(),
				ModifyTime:         time.Now(),
			})
		}
	}

	err = models.BatchAddReportPushStatus(insertReportPushList)
	if err != nil {
		return
	}
	return
}

func ModifyUserStatus(ctx context.Context) (err error) {
	defer func() {
		if err != nil {
			utils.ApiLog.Info("修改用户状态，定时任务出错，Err: %s", err)
		}
		if err := recover(); err != nil {
			utils.ApiLog.Warn("修改用户状态，定时任务出错，Err: %s", err)
		}
	}()
	curTime := time.Now()
	var pars []interface{}
	condition := ` AND valid_end_time<?`
	pars = append(pars, curTime)
	condition += ` AND status=? `
	pars = append(pars, 2)
	userIds, err := models.GetUserIdListByCondition(condition, pars)
	if err != nil {
		return
	}
	err = models.UpdateUserStatus(condition, pars)
	if err != nil {
		return
	}
	userRecordList := make([]*models.UserChangeRecord, 0)
	for _, v := range userIds {
		record := &models.UserChangeRecord{}
		record.UserId = v
		record.SysUserId = 0
		record.Content = "有效期到期禁用用户"
		record.CreateTime = time.Now()
		userRecordList = append(userRecordList, record)
	}
	if len(userRecordList) > 0 {
		err = models.UserChangeRecordMultiInsert(userRecordList)
		if err != nil {
			return
		}
	}
	return
}

func SendReminderMsg(ctx context.Context) (err error) {
	defer func() {
		if err != nil {
			utils.ApiLog.Info("发送提醒消息，定时任务出错，Err: %s", err)
		}
		if err := recover(); err != nil {
			utils.ApiLog.Warn("发送提醒消息，定时任务出错，Err: %s", err)
		}
	}()
	var userPars7 []interface{}
	var userPars15 []interface{}
	var userPars30 []interface{}
	var userPars60 []interface{}
	var msgPars7 []interface{}
	var msgPars15 []interface{}
	var msgPars30 []interface{}
	var msgPars60 []interface{}

	userTime7 := time.Now().AddDate(0, 0, 7)
	userTime15 := time.Now().AddDate(0, 0, 15)
	userTime30 := time.Now().AddDate(0, 0, 30)
	userTime60 := time.Now().AddDate(0, 0, 60)
	msgTime7 := time.Now().AddDate(0, 0, -7)
	msgTime15 := time.Now().AddDate(0, 0, -15)
	msgTime30 := time.Now().AddDate(0, 0, -30)
	msgTime60 := time.Now().AddDate(0, 0, -60)

	userCondition1 := ` AND valid_end_time<? `
	userCondition2 := ` AND valid_end_time<? AND valid_end_time>? `
	msgCondition := ` AND create_time>? `
	userPars7 = append(userPars7, userTime7)
	userPars15 = append(userPars15, userTime15, userTime7)
	userPars30 = append(userPars30, userTime30, userTime15)
	userPars60 = append(userPars60, userTime60, userTime30)
	msgPars7 = append(msgPars7, msgTime7)
	msgPars15 = append(msgPars15, msgTime15)
	msgPars30 = append(msgPars30, msgTime30)
	msgPars60 = append(msgPars60, msgTime60)

	err = SendMsgToSysUser(userCondition1, msgCondition, userPars7, msgPars7, 7)
	if err != nil {
		utils.ApiLog.Warn("发送提醒消息，定时任务出错，Err: %s", err.Error())
	}
	err = SendMsgToSysUser(userCondition2, msgCondition, userPars15, msgPars15, 15)
	if err != nil {
		utils.ApiLog.Warn("发送提醒消息，定时任务出错，Err: %s", err.Error())
	}
	err = SendMsgToSysUser(userCondition2, msgCondition, userPars30, msgPars30, 30)
	if err != nil {
		utils.ApiLog.Warn("发送提醒消息，定时任务出错，Err: %s", err.Error())
	}
	err = SendMsgToSysUser(userCondition2, msgCondition, userPars60, msgPars60, 60)
	if err != nil {
		utils.ApiLog.Warn("发送提醒消息，定时任务出错，Err: %s", err.Error())
	}
	return
}

func SendMsgToSysUser(userCondition, msgCondition string, userPars, msgPars []interface{}, messagetType int) (err error) {
	total, err := models.GetUserCount(userCondition, userPars)
	if err != nil {
		utils.ApiLog.Warn("获取用户列表失败 task err: %s", err.Error())
	}
	if total == 0 {
		return
	}
	// 获得待发送用户的列表
	userList, err := models.GetUserList(userCondition, userPars, 0, total)
	if err != nil {
		return
	}

	// 获得待通知系统用户的列表
	sysUserIds, err := models.GetSysUserIdList()
	if err != nil {
		return
	}

	messageList, err := models.GetSysMessageReportByCondition(msgCondition, msgPars)
	if err != nil {
		return
	}
	layout := "【%s】到期%d天提醒，请及时跟进"
	messageMap := make(map[int]map[int]struct{})
	for _, v := range messageList {
		if mv, ok := messageMap[v.ReceiveSysUserId]; ok {
			mv[v.UserId] = struct{}{}
		} else {
			messageMap[v.ReceiveSysUserId] = make(map[int]struct{})
			messageMap[v.ReceiveSysUserId][v.UserId] = struct{}{}
		}
	}
	sendMsg := make([]*models.SysMessageReport, 0)
	for _, v := range sysUserIds {
		if userMap, ok := messageMap[v]; ok {
			for _, u := range userList {
				if _, ok := userMap[u.UserId]; !ok {
					sendMsg = append(sendMsg, &models.SysMessageReport{
						UserId:           u.UserId,
						ReceiveSysUserId: v,
						MessageType:      messagetType,
						IsRead:           false,
						CreateTime:       time.Now(),
						ModifyTime:       time.Now(),
						Content:          fmt.Sprintf(layout, u.RealName, messagetType),
					})
				}
			}
		} else {
			for _, u := range userList {
				sendMsg = append(sendMsg, &models.SysMessageReport{
					UserId:           u.UserId,
					ReceiveSysUserId: v,
					MessageType:      messagetType,
					IsRead:           false,
					CreateTime:       time.Now(),
					ModifyTime:       time.Now(),
					Content:          fmt.Sprintf(layout, u.RealName, messagetType),
				})
			}
		}
	}
	if len(sendMsg) > 0 {
		err = models.InsertMultiSysMessageReport(sendMsg)
	}
	return
}