MessageCenter/rpc/internal/common/msglistService.go

package common

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"reflect"
	"strconv"
	"time"

	"app.yhyue.com/moapp/MessageCenter/entity"
	"app.yhyue.com/moapp/MessageCenter/rpc/internal/config"
	"app.yhyue.com/moapp/MessageCenter/rpc/type/message"
	"app.yhyue.com/moapp/MessageCenter/util"
	"app.yhyue.com/moapp/jybase/common"
	m "app.yhyue.com/moapp/jybase/mongodb"
	"app.yhyue.com/moapp/jybase/redis"
)

func BitmapUserMsgList(this *message.UserMsgListReq) (*message.UserMsgList, *message.Messages, error) {
	var (
		unread, count, toDoUnread int64
		data                      = new(message.UserMsgList)
	)
	//取出用户所有消息、已读消息id bitmap 查库
	userAllMsgArr, _, userUnreadArr, err := GetUserMsgSummary(this.UserId, this.IsfilterActive)
	if len(userAllMsgArr) == 0 && err != nil {
		log.Printf("此用户暂无消息 : %s", err)
	}
	//用户分类消息
	//_, userClassMsgMap := FindUserClassMsg(this.UserId)
	////用户分类未读消息
	//classUnreadCountMap, classUnreadMsgMap := FindUserClassUnread(this.UserId)
	classUnreadCountMap, classUnreadMsgMap, userClassMsgMap, err := FindUserClassUnreadAndClassAllMsg(this.UserId)
	if err != nil {
		fmt.Println("加载FindUserClassUnreadAndClassAllMsg")
		return nil, nil, err
	}
	//fmt.Println("用户所有消息数：", userAllMsgArr, "已读消息数：", userReadArr, "未读消息数：", userUnreadArr)
	//导航未读消息总数
	if !this.IsMsgList && !this.IsColumnNewMsg && !this.IsColumn { //消息未读数统计
		var sortUnread map[string]int64
		sortUnread, unread = BitmapCountUnread(this.UserId, classUnreadCountMap, true)
		data.Unread = unread
		data.ToDoUnread = sortUnread["11"]
		return data, nil, nil
	}
	//获取栏目下的数据
	sData := make(map[string][]*message.Messages)
	//移动端消息列表首页
	if this.IsColumnNewMsg && this.SortSize > 0 {
		messageColumn := entity.MessageColumn
		if this.IsClassSearch {
			messageColumn = append(messageColumn, map[string]interface{}{
				"group_id": 12,
			})
		}
		for _, val := range messageColumn {
			if util.IntAll(val["group_id"]) > 0 && util.IntAll(val["group_id"]) < 999 {
				//用户分类未读 交集
				userClassUnreadMsgArr := classUnreadMsgMap[util.IntAll(val["group_id"])]
				var lastMsgId int
				if len(userClassUnreadMsgArr) > 0 {
					lastMsgId = userClassUnreadMsgArr[len(userClassUnreadMsgArr)-1]
				} else {
					//没有未读，分类展示最新一条消息
					classMsg := userClassMsgMap[util.IntAll(val["group_id"])]
					if len(classMsg) > 0 {
						lastMsgId = classMsg[len(classMsg)-1]
					} else {
						continue
					}
				}
				lastMsg := GlobMsgMap[lastMsgId]
				if lastMsg == nil || len(lastMsg) <= 0 {
					mess := entity.Mysql.FindOne("message_send_log", map[string]interface{}{"id": int(lastMsgId)}, "id,msg_type,title,content,send_time,link,menu_name,group_id,sign", "")
					if mess != nil && len(*mess) > 0 {
						lastMsg = *mess
					} else {
						continue
					}
				}
				if common.IntAll(lastMsg["sign"]) == 4 {
					//查询用户注册时间
					rData, _ := entity.MQFW.FindOneByField("user", map[string]interface{}{"_id": m.StringTOBsonId(this.UserId)}, `{"l_registedate":1}`)
					if rData != nil && len(*rData) > 0 {
						lastMsg["send_time"] = time.Unix(common.Int64All((*rData)["l_registedate"]), 0).Local().Format("2006-01-02 15:04:05")
					}
				}
				var msg = message.Messages{
					Id:         strconv.FormatInt(util.Int64All(lastMsg["id"]), 10),
					Createtime: common.InterfaceToStr(lastMsg["send_time"]),
					Title:      common.InterfaceToStr(lastMsg["title"]),
					MsgType:    int64(util.IntAll(lastMsg["group_id"])),
				}
				if this.IsClassSearch && util.IntAll(val["group_id"]) == 12 {
					sData[common.InterfaceToStr(val["group_id"])] = []*message.Messages{&msg}
					continue
				}
				if sData[common.InterfaceToStr(lastMsg["group_id"])] == nil {
					sData[common.InterfaceToStr(lastMsg["group_id"])] = []*message.Messages{&msg}
				} else {
					sData[common.InterfaceToStr(lastMsg["group_id"])] = append(sData[common.InterfaceToStr(lastMsg["group_id"])], &msg)
				}
			}
		}
	}
	//pc消息列表消息分类
	var columnData []*message.AllSortData
	if this.IsColumn && this.MsgType > 0 && this.IsClassSearch {
		// 获取小分类下的未读数
		sortUnread, total := BitmapCountClassUnread(this.UserId, this.MsgType, classUnreadCountMap)
		columnArr := []entity.MsgClass{}
		if !this.IsColumnNewMsg { // 用于区分分类列表页和分类详情页   根据不同情况
			columnArr = append(columnArr, entity.ClassMap[this.MsgType])
		} else {
			columnArr = entity.ClassSearchMap[this.MsgType]
		}
		unread += total
		for i := 0; i < len(columnArr); i++ {
			tmp := columnArr[i]
			var column message.AllSortData
			column.Name = tmp.Name
			column.Img = fmt.Sprintf("/common-module/msgCenter/%s.png", tmp.Img)
			column.MsgType = tmp.MsgType
			// 消息未读数
			msgType := common.InterfaceToStr(tmp.MsgType)
			column.UnreadMessages = sortUnread[msgType]
			column.Data = sData[msgType]
			column.IsClassSearch = true
			columnData = append(columnData, &column)
		}
	} else if this.IsColumn || this.IsfilterActive {
		//获取所有分类未读数 不初始化
		sortUnread, total := BitmapCountUnread(this.UserId, classUnreadCountMap, false)
		//fmt.Println("*************", total)
		unread += total
		toDoUnread = sortUnread["11"]
		for _, v := range entity.MessageColumn {
			var column message.AllSortData
			column.Name = common.InterfaceToStr(v["name"])
			column.Img = fmt.Sprintf("/common-module/msgCenter/%s.png", common.InterfaceToStr(v["img"]))
			column.MsgType = common.Int64All(v["group_id"])
			if column.Name == "私信" {
				column.UnreadMessages = unreadMsg(this)
			} else if common.IntAll(v["group_id"]) > 0 {
				//消息未读数
				msgType := common.InterfaceToStr(v["group_id"])
				column.UnreadMessages = sortUnread[msgType]
				column.Data = sData[msgType]
			}
			if _, ok := entity.ClassSearchMap[column.MsgType]; ok {
				column.IsClassSearch = true
			}
			columnData = append(columnData, &column)
		}
	}
	data.SortData = columnData
	if len(userAllMsgArr) == 0 {
		log.Printf("此用户暂无消息 : %s", err)
		return data, nil, nil
	}

	count = int64(len(userAllMsgArr))
	//pc列表数据、移动端分类列表
	if this.IsMsgList {
		if count > 0 {
			var userMsgArr []int
			if this.OffSet <= 0 {
				this.OffSet = 1
			}
			if this.MsgType > 0 {
				var totalMsg []int
				//分类消息bitmap
				totalMsg = userClassMsgMap[int(this.MsgType)]
				if this.MsgType == 11 {
					if !this.IsClassSearch {
						totalMsg = append(totalMsg, userClassMsgMap[12]...)
					}
				}
				userMsgArr = totalMsg
			} else {
				userMsgArr = Uint32ArrToIntArr(userAllMsgArr)
			}
			if this.Read == 0 { //未读
				userMsgArr = Uint32ArrToIntArr(userUnreadArr)
			}
			if this.MsgType > 0 {
				count = int64(len(userMsgArr))
			}
			if len(userMsgArr) > 0 {
				userMsgArr = IntArrSort(userMsgArr)
				//fmt.Println("列表消息：", userMsgArr)
				//总页数
				var pageCount = 0
				if this.PageSize != 0 {
					if len(userMsgArr)%int(this.PageSize) > 0 {
						pageCount = len(userMsgArr)/int(this.PageSize) + 1
					} else {
						pageCount = len(userMsgArr) / int(this.PageSize)
					}
				}
				start := len(userMsgArr) - int(this.PageSize*(this.OffSet-1))
				end := start - int(this.PageSize)
				if int(this.OffSet) == pageCount || this.PageSize == 0 {
					end = 0
				}
				//fmt.Println(end, start)
				if end < 0 || start < 0 {
					return data, nil, nil
				}
				resArr := userMsgArr[end:start]
				resData := []*message.Messages{}
				if len(resArr) > 0 {
					//count = int64(len(resArr))
					unReadMap := map[int]bool{}
					for _, vv := range userUnreadArr {
						unReadMap[int(vv)] = true
					}
					for _, v := range resArr {
						msg := GlobMsgMap[v]
						if msg == nil || len(msg) <= 0 {
							ms := entity.Mysql.FindOne("message_send_log", map[string]interface{}{"id": v}, "id,msg_type,title,content,send_time,link,menu_name,group_id,sign", "")
							if ms != nil && len(*ms) > 0 {
								msg = *ms
							} else {
								continue
							}
						}
						if common.IntAll(msg["sign"]) == 4 {
							//查询用户注册时间
							rData, _ := entity.MQFW.FindOneByField("user", map[string]interface{}{"_id": m.StringTOBsonId(this.UserId)}, `{"l_registedate":1}`)
							if rData != nil && len(*rData) > 0 {
								msg["send_time"] = time.Unix(common.Int64All((*rData)["l_registedate"]), 0).Local().Format("2006-01-02 15:04:05")
							}
						}
						resData = append(resData, &message.Messages{
							Id:         common.InterfaceToStr(v),
							Createtime: common.InterfaceToStr(msg["send_time"]),
							Title:      common.InterfaceToStr(msg["title"]),
							MsgType:    int64(util.IntAll(msg["group_id"])),
							Link:       common.InterfaceToStr(msg["link"]),
							Content:    common.InterfaceToStr(msg["content"]),
							IsRead:     common.Int64All(common.If(unReadMap[v], 0, 1)),
							MsgLogId:   int64(v),
						})
					}
					for i := len(resData) - 1; i >= 0; i-- {
						data.Data = append(data.Data, resData[i])
					}
				}
			}
		}
	}
	data.Count = count
	if this.Read == 0 {
		//unread = count
		if this.IsContainLetter { //是否需要统计私信未读数
			unread += unreadMsg(this)
		}
	}
	data.Unread = unread
	data.ToDoUnread = toDoUnread
	//置顶消息
	if len(classUnreadMsgMap[1]) > 0 {
		activeMsgArr := classUnreadMsgMap[1]
		res2 := BitmapMessageGetLast(this, activeMsgArr[len(activeMsgArr)-1])
		return data, res2, nil
	}
	return data, nil, nil
}

// BitmapMessageGetLast 获取优惠活动的最新一条消息
func BitmapMessageGetLast(this *message.UserMsgListReq, msgId int) *message.Messages {
	if !this.IsMsgList && !this.IsColumnNewMsg && !this.IsColumn {
		return nil
	}
	lastMsg := GlobMsgMap[msgId]
	if lastMsg == nil && len(lastMsg) <= 0 {
		mess := entity.Mysql.FindOne("message_send_log", map[string]interface{}{"id": msgId}, "id,msg_type,title,content,send_time,link,menu_name,group_id,sign", "")
		if mess != nil && len(*mess) > 0 {
			lastMsg = *mess
		}
	}
	if lastMsg != nil && len(lastMsg) > 0 {
		if common.IntAll(lastMsg["sign"]) == 4 {
			//查询用户注册时间
			rData, _ := entity.MQFW.FindOneByField("user", map[string]interface{}{"_id": m.StringTOBsonId(this.UserId)}, `{"l_registedate":1}`)
			if rData != nil && len(*rData) > 0 {
				lastMsg["send_time"] = time.Unix(common.Int64All((*rData)["l_registedate"]), 0).Local().Format("2006-01-02 15:04:05")
			}
		}
		msg := message.Messages{
			Id:         common.InterfaceToStr(lastMsg["id"]),
			Createtime: common.InterfaceToStr(lastMsg["send_time"]),
			Title:      common.InterfaceToStr(lastMsg["title"]),
			MsgType:    common.Int64All(lastMsg["group_id"]),
			Link:       common.InterfaceToStr(lastMsg["link"]),
			Content:    common.InterfaceToStr(lastMsg["content"]),
			IsRead:     0,
			MsgLogId:   common.Int64All(lastMsg["id"]),
		}
		return &msg
	}
	return nil
}

type UserClassSummary struct {
	GroupId     int32    `ch:"group_id"`
	ClassUnread []uint32 `ch:"unreadArr"`
	ClassAll    []uint32 `ch:"classMsgArr"`
}

// BitmapCountUnread 未读消息合计 isRedis 是否需要初始化redis
func BitmapCountUnread(userId string, classUnreadCountMap map[int]int, isRedis bool) (map[string]int64, int64) {
	var (
		count              int64
		msgTypes, groupIds []string
	)
	data := make(map[string]int64)
	for _, v := range entity.MessageColumn {
		if util.IntAll(v["group_id"]) > 0 && util.IntAll(v["group_id"]) < 999 {
			//去除全部与私信
			msgTypes = append(msgTypes, fmt.Sprintf(`"%s"`, common.InterfaceToStr(v["group_id"])))
			key := fmt.Sprintf(MsgCountKey, userId, util.IntAll(v["group_id"]))
			groupIds = append(groupIds, common.InterfaceToStr(v["group_id"]))
			if exists, _ := redis.Exists(redisModule, key); exists {
				ct := util.Int64All(redis.GetInt(redisModule, key))
				data[common.InterfaceToStr(v["group_id"])] = ct
				count += ct
			}
		}
	}
	//classUnreadCountMap, _ := FindUserClassUnread(userId)
	if len(msgTypes) > 0 && len(msgTypes) != len(data) {
		for _, val := range entity.MessageColumn {
			if util.IntAll(val["group_id"]) > 0 && util.IntAll(val["group_id"]) < 999 {
				oneClassUnread := classUnreadCountMap[util.IntAll(val["group_id"])]
				if util.IntAll(val["group_id"]) == 11 {
					oneClassUnread += classUnreadCountMap[12]
				}
				if isRedis {
					//用户分类未读
					if oneClassUnread >= 0 {
						key := fmt.Sprintf(MsgCountKey, userId, util.IntAll(val["group_id"]))
						redis.Put(redisModule, key, oneClassUnread, 60*60)
					}
				}
				data[common.InterfaceToStr(val["group_id"])] = int64(oneClassUnread)
				count += int64(oneClassUnread)
			}
		}
	}
	return data, count //分类未读、未读总量
}

//BitmapCountClassUnread    userUnreadBitmap 用户未读
func BitmapCountClassUnread(userId string, groupId int64, classUnreadCountMap map[int]int) (classCount map[string]int64, total int64) {
	var (
		count int64
	)
	data := make(map[string]int64)
	classCount = map[string]int64{}
	if _, ok := entity.ClassSearchMap[groupId]; !ok {
		return
	}
	for i := 0; i < len(entity.ClassSearchMap[groupId]); i++ {
		msgClass := entity.ClassSearchMap[groupId][i]
		//fmt.Println("msgClass", msgClass)
		key := fmt.Sprintf(MsgClassCountKey, userId, msgClass.MsgType)
		if exists, _ := redis.Exists(redisModule, key); exists {
			ct := util.Int64All(redis.GetInt(redisModule, key))
			data[fmt.Sprintf("%d", msgClass.MsgType)] = ct
			count += ct
		} else {
			//分类所有消息
			classUnreadCount := classUnreadCountMap[util.IntAll(msgClass.MsgType)]
			if classUnreadCount >= 0 {
				redis.Put(redisModule, key, classUnreadCount, -1)
				data[fmt.Sprintf("%d", msgClass.MsgType)] = int64(classUnreadCount)
				count += int64(classUnreadCount)
			} else {
				log.Println("查询classUnreadCount失败，msgType：", msgClass.MsgType)
			}
		}
	}

	return data, count
}

//FindUserClassUnreadAndClassAllMsg 查询用户分类未读消息id
func FindUserClassUnreadAndClassAllMsg(userId string) (classUnreadCountMap map[int]int, classUnreadMsgMap, classAllMsgMap map[int][]int, err error) {
	redisKey := fmt.Sprintf(UserClassMapKey, userId)
	redisData, err := redis.GetBytes(redisModule, redisKey)
	findRes := []UserClassSummary{}
	classUnreadCountMap = map[int]int{}
	classUnreadMsgMap = map[int][]int{}
	classAllMsgMap = map[int][]int{}
	if redisData != nil && err == nil {
		json.Unmarshal(*redisData, &findRes)
		for _, v := range findRes {
			classUnreadCountMap[int(v.GroupId)] = len(v.ClassUnread)
			classUnreadMsgMap[int(v.GroupId)] = Uint32ArrToIntArr(v.ClassUnread)
			//classAllCountMap[int(v.GroupId)] = len(v.ClassAll)
			classAllMsgMap[int(v.GroupId)] = Uint32ArrToIntArr(v.ClassAll)
		}
	}
	rdata, err := redis.GetNewBytes(redisModule, fmt.Sprintf(UserClearUnread, userId))
	fmt.Println("erroer", err)
	rdataArr := []uint32{}
	if rdata != nil {
		log.Println("-------", rdata, reflect.TypeOf(rdata))
		if json.Unmarshal(*rdata, &rdataArr); err != nil {
			fmt.Println("取出本次已读消息反序列化出错：", err)
			return classUnreadCountMap, classUnreadMsgMap, classAllMsgMap, err
		}
	}

	sql := fmt.Sprintf(`select a2.group_id,bitmapToArray(bitmapAnd(a1.unreadArr,a2.msg_bitmap)) as unreadArr,bitmapToArray(bitmapAnd(a1.allMsg,a2.msg_bitmap)) as classMsgArr from 
			(SELECT bitmapAndnot(mus.allMsg,mus.readMsg) unreadArr,mus.allMsg FROM message_user_summary mus WHERE mus.userId = '%s') a1,
			(select msg_bitmap,group_id from message_summary ms  where 1=1 limit 10) a2`, userId)
	log.Println("FindUserClassUnreadAndClassAllMsg", sql)
	rows, err := entity.ClickhouseConn.Query(context.Background(), sql)
	if err != nil {
		log.Println("获取各分类未读消息数组出错：", err)
		return
	}
	for rows.Next() {
		group := UserClassSummary{}
		err = rows.ScanStruct(&group)
		if err != nil {
			log.Println("获取各分类读取分类数据出错：", err)
			return
		}
		//处理已读
		unreadArr := []uint32{}
		if len(rdataArr) > 0 {
			if len(rdataArr) > 0 {
				rdataMap := make(map[uint32]bool)
				for _, v := range rdataArr {
					rdataMap[v] = true
				}

				if len(group.ClassUnread) > 0 {
					for _, v := range group.ClassUnread {
						if !rdataMap[v] {
							unreadArr = append(unreadArr, v)
						}
					}
				}
				group.ClassUnread = unreadArr
				group.ClassUnread = append(group.ClassUnread, rdataArr...)
			}
		}

		findRes = append(findRes, group)
		//log.Println("========", len(group.ClassUnread))

	}
	if findRes != nil && len(findRes) > 0 { //缓存
		for _, val := range findRes {
			classUnreadCountMap[int(val.GroupId)] = len(val.ClassUnread)
			classUnreadMsgMap[int(val.GroupId)] = Uint32ArrToIntArr(val.ClassUnread)
			//classAllCountMap[int(group.GroupId)] = len(group.ClassAll)
			classAllMsgMap[int(val.GroupId)] = Uint32ArrToIntArr(val.ClassAll)
		}
		redis.Put(redisModule, redisKey, findRes, config.ConfigJson.RedisFailureTime)
	}
	return
}

// GetUserMsgSummary 从用户消息汇总表取数据
func GetUserMsgSummary(userId string, isfilterActive bool) (userAllMsg, userReadMsg, userUnreadMsg []uint32, err error) {
	userAllMsg = []uint32{}
	userReadMsg = []uint32{}
	userUnreadMsg = []uint32{}
	key := fmt.Sprintf(UserMsgSummery, userId)
	redisData, err := redis.GetBytes(redisModule, key)
	if redisData != nil && err == nil {
		var userData map[string][]uint32
		json.Unmarshal(*redisData, &userData)
		userAllMsg = userData["userAllMsg"]
		userReadMsg = userData["userReadMsg"]
		userUnreadMsg = userData["userUnreadMsg"]
		return
	}
	var sql string
	if isfilterActive && config.ConfigJson.IsFilterActive {
		sql = fmt.Sprintf("SELECT a1.userAllMsg,a1.userReadMsg,bitmapToArray(bitmapAndnot(a1.userunRead,a2.msg_bitmap)) as userunRead from (SELECT bitmapToArray(allMsg) as userAllMsg,bitmapToArray(readMsg) as userReadMsg,bitmapAndnot(allMsg,readMsg) as userunRead from message_user_summary where userId ='%s') a1,(select msg_bitmap,group_id from message_summary ms  where group_id = 1 ) a2", userId)
	} else {
		sql = fmt.Sprintf("SELECT bitmapToArray(allMsg) as userAllMsg,bitmapToArray(readMsg) as userReadMsg,bitmapToArray(bitmapAndnot(allMsg,readMsg)) as userunRead from message_user_summary where userId ='%s'", userId)
	}
	log.Println("GetUserMsgSummary加载缓存：", sql)
	// 在这里可以使用 lock 对共享资源进行保护
	lock := UserLocksMap.GetLock(userId)
	lock.Lock()
	defer lock.Unlock()
	log.Println("GetUserMsgSummary selcet2 ", sql)
	row := entity.ClickhouseConn.QueryRow(context.Background(), sql)
	err = row.Scan(&userAllMsg, &userReadMsg, &userUnreadMsg)
	if err != nil {
		log.Println("此用户暂无数据：", err)
		return userAllMsg, userReadMsg, userUnreadMsg, err
	}
	rdata, _ := redis.GetNewBytes(redisModule, fmt.Sprintf(UserClearUnread, userId))
	rdataArr := []uint32{}
	if rdata != nil {
		if json.Unmarshal(*rdata, &rdataArr); err != nil {
			return userAllMsg, userReadMsg, userUnreadMsg, err
		}
	}
	userUnreadArr := []uint32{}
	if len(rdataArr) > 0 {
		if len(rdataArr) > 0 {
			rdataMap := make(map[uint32]bool)
			for _, v := range rdataArr {
				rdataMap[v] = true
			}

			if len(userUnreadMsg) > 0 {
				for _, v := range userUnreadMsg {
					if !rdataMap[v] {
						userUnreadArr = append(userUnreadArr, v)
					}
				}
			}
			userReadMsg = append(userReadMsg, rdataArr...)
		}
	}
	//缓存
	redis.Put(redisModule, key, map[string][]uint32{
		"userAllMsg":    userAllMsg,
		"userReadMsg":   userReadMsg,
		"userUnreadMsg": userUnreadArr,
	}, config.ConfigJson.RedisFailureTime)
	return userAllMsg, userReadMsg, userUnreadMsg, nil
}

// Uint32ArrToIntArr []uint32转[]int
func Uint32ArrToIntArr(arr []uint32) []int {
	tmp := make([]int, 0)
	for _, v := range arr {
		tmp = append(tmp, int(v))
	}
	return tmp
}

func IntArrSort(arr []int) []int {
	if len(arr) <= 1 {
		return arr
	}
	splitData := arr[0]          //第一个数据为基准
	low := make([]int, 0, 0)     //比我小的数据
	height := make([]int, 0, 0)  //比我大的数据
	mid := make([]int, 0, 0)     //与我一样大的数据
	mid = append(mid, splitData) //加入一个
	for i := 1; i < len(arr); i++ {
		if arr[i] < splitData {
			low = append(low, arr[i])
		} else if arr[i] > splitData {
			height = append(height, arr[i])
		} else {
			mid = append(mid, arr[i])
		}
	}
	low, height = IntArrSort(low), IntArrSort(height) //切割递归处理
	resArr := append(append(low, mid...), height...)
	return resArr
}

type UserMsg struct {
	GroupId   int32    `ch:"group_id"`
	UnreadArr []uint32 `ch:"unreadArr"`
	ReadArr   []uint32 `ch:"readArr"`
}

func WorkDeskList(in *message.WorkingDesktopReq) (res1, res2 []*message.Messages, err error) {
	redisKey := fmt.Sprintf(UserWorkDeskKey, in.UserId)
	redisData, err := redis.GetBytes(redisModule, redisKey)
	if redisData != nil && err == nil {
		var userData map[string][]*message.Messages
		json.Unmarshal(*redisData, &userData)
		res1 = userData["res1"]
		res2 = userData["res2"]
		//fmt.Println("=====", userData)
		return
	}
	//待办查询
	sqlStr := ""
	needDo := map[int][]uint32{} //msgType对应的消息id
	if in.NeedDealtWithCount {
		sqlStr = fmt.Sprintf("  or p_group_id = 11")
	}
	sql := fmt.Sprintf(`select a2.group_id,bitmapToArray(bitmapAnd(a1.allMsg,a2.msg_bitmap)) as unreadArr,bitmapToArray(a1.readMsg) as readArr from 
				(SELECT mus.allMsg as allMsg,mus.readMsg as readMsg FROM message_user_summary mus WHERE mus.userId = '%s') a1,
			(select msg_bitmap,group_id from message_summary ms  where group_id = %d %s) a2`, in.UserId, in.MsgType, sqlStr)

	log.Println("WorkDeskList", sql)
	lock := UserLocksMap.GetLock(in.UserId)
	lock.Lock()
	defer lock.Unlock()
	rows, err := entity.ClickhouseConn.Query(context.Background(), sql)
	if err != nil {
		return nil, nil, err
	}
	readMsgMap := map[int]bool{}
	for rows.Next() {
		group := UserMsg{}
		err = rows.ScanStruct(&group)
		if err != nil {
			log.Println("获取各分类读取分类数据出错：", err)
			return nil, nil, err
		}
		if len(group.ReadArr) > 0 && len(readMsgMap) == 0 {
			for _, v := range group.ReadArr {
				readMsgMap[int(v)] = true
			}
		}
		if group.GroupId == int32(in.MsgType) {
			res1 = GetMsgList(IntArrSort(Uint32ArrToIntArr(group.UnreadArr)), int(in.PageSize), in.UserId, readMsgMap)
		} else {
			if len(group.UnreadArr) > 0 {
				needDo[int(group.GroupId)] = group.UnreadArr
			}
		}
	}
	if len(needDo) > 0 {
		totalMsg := append(needDo[11], needDo[12]...)
		needMsgArr := IntArrSort(Uint32ArrToIntArr(totalMsg))
		res2 = GetMsgList(needMsgArr, int(in.PageSize), in.UserId, readMsgMap)
	}
	//缓存
	res := map[string][]*message.Messages{}
	if res1 != nil {
		res["res1"] = res1
	}
	if res2 != nil {
		res["res2"] = res2
	}
	if res != nil {
		redis.Put(redisModule, redisKey, res, config.ConfigJson.RedisFailureTime)
	}
	return res1, res2, nil
}

func GetMsgList(arr []int, size int, userId string, readMsgMap map[int]bool) []*message.Messages {
	newMsg := []int{}
	if len(arr) > 0 {
		if len(arr) >= size {
			newMsg = arr[len(arr)-size:]
		} else {
			newMsg = arr
		}
	}
	//fmt.Println("*********8", newMsg)
	resData := []*message.Messages{}
	for i := len(newMsg) - 1; i >= 0; i-- {
		//for _, v := range newMsg {
		msg := GetMsgInfo(int(newMsg[i]), userId)
		links4 := common.InterfaceToStr(msg["link"])
		link4, androidUrl4, iosUrl4, weChatUrl4 := util.LinkSplit(links4)
		resData = append(resData, &message.Messages{
			Id:         common.InterfaceToStr(newMsg[i]),
			Createtime: common.InterfaceToStr(msg["send_time"]),
			Title:      common.InterfaceToStr(msg["title"]),
			MsgType:    int64(util.IntAll(msg["group_id"])),
			Link:       link4,
			Content:    common.InterfaceToStr(msg["content"]),
			MsgLogId:   int64(newMsg[i]),
			Url: map[string]string{
				"androidUrl": androidUrl4,
				"iosUrl":     iosUrl4,
				"weChatUrl":  weChatUrl4,
			},
			IsRead: common.Int64All(common.If(readMsgMap[int(newMsg[i])], 1, 0)),
		})
	}
	return resData
}

func GetMsgInfo(msgId int, userId string) map[string]interface{} {
	msg := GlobMsgMap[msgId]
	if msg == nil || len(msg) <= 0 {
		ms := entity.Mysql.FindOne("message_send_log", map[string]interface{}{"id": msgId}, "id,msg_type,title,content,send_time,link,menu_name,group_id,sign", "")
		if ms != nil && len(*ms) > 0 {
			msg = *ms
		}
	}
	if common.IntAll(msg["sign"]) == 4 {
		//查询用户注册时间
		rData, _ := entity.MQFW.FindOneByField("user", map[string]interface{}{"_id": m.StringTOBsonId(userId)}, `{"l_registedate":1}`)
		if rData != nil && len(*rData) > 0 {
			msg["send_time"] = time.Unix(common.Int64All((*rData)["l_registedate"]), 0).Local().Format("2006-01-02 15:04:05")
		}
	}
	return msg
}