package model

import (
	"rocommon/service"
	"rocommon/util"
	"roserver/baseserver/model"
	"roserver/serverproto"
	"strconv"
	"strings"
)

///invitation
const (
	Invitation_Member_Max_Num = 30
)

//生成邀请码
func InvitationGenNumber(uid uint64, bGenNumber bool, checkMasterUid uint64) (uint64, uint64) {
	var genNumber int64 = 0
	if bGenNumber {
		genNumber = service.GetRedis().Incr(InvitationNumberPrefix).Val()
		genNumber = 100000 + genNumber
		filedStr := strconv.FormatUint(uint64(genNumber), 10)
		service.GetRedis().HSet(RoleInvitationNumberPrefix, filedStr, uid)
	}

	//判断maseter是否合理
	if checkMasterUid > 0 {
		masterUidStr := strconv.FormatUint(checkMasterUid, 10)
		masterKeyStr := RoleInvitationPrefix + masterUidStr

		memberStr := "m:" + strconv.FormatUint(uid, 10)
		bExist := service.GetRedis().HExists(masterKeyStr, memberStr).Val()
		if !bExist {
			checkMasterUid = 0
		}
	}

	return uint64(genNumber), checkMasterUid
}

//根据邀请码查询玩家信息
func InvitationGetUserInfoByNumber(uid uint64, number uint64, ackMsg *serverproto.SSInvitationNumberUserInfoAck) {
	filedStr := strconv.FormatUint(uint64(number), 10)
	masterUidStr, err := service.GetRedis().HGet(RoleInvitationNumberPrefix, filedStr).Result()
	if err != nil && err != service.NIL {
		util.InfoF("uid=%v InvitationGetUserInfoByNumber number=%v err=%v", uid, number, err)
		ackMsg.Error = int32(serverproto.ErrorCode_ERROR_INVITATION_NUMBER_INVALID)
		return
	}

	masterUid, err := model.Str2NumU64(masterUidStr)
	if err != nil {
		util.InfoF("uid=%v InvitationGetUserInfoByNumber uidstr=%v convert uid err=%v", uid, masterUidStr, err)
		ackMsg.Error = int32(serverproto.ErrorCode_ERROR_INVITATION_NUMBER_INVALID)
		return
	}
	err, masterBfInfo := GetPlayerBriefInfo(masterUid)
	if err != nil {
		util.InfoF("uid=%v InvitationGetUserInfoByNumber master br nil err=%v", uid, masterUidStr, err)
		ackMsg.Error = int32(serverproto.ErrorCode_ERROR_INVITATION_NUMBER_INVALID)
		return
	}

	masterKeyStr := RoleInvitationPrefix + masterUidStr
	masterMemberNumStr := service.GetRedis().HGet(masterKeyStr, "mnum").Val()
	masterMemberNum, _ := model.Str2Num(masterMemberNumStr)

	ackMsg.Error = int32(serverproto.ErrorCode_ERROR_OK)
	ackMsg.Brief = masterBfInfo
	ackMsg.Number = number
	ackMsg.MemberNum = int32(masterMemberNum)
}

//玩家成为导师成员
func InvitationBeToBeMember(masterNumber, masterUid uint64, selfUid *serverproto.InvitationMemberValData) serverproto.ErrorCode {
	masterUidStr := strconv.FormatUint(masterUid, 10)
	masterKeyStr := RoleInvitationPrefix + masterUidStr

	masterMemberNumStr := service.GetRedis().HGet(masterKeyStr, "mnum").Val()
	masterMemberNum, _ := model.Str2Num(masterMemberNumStr)
	if masterMemberNum >= Invitation_Member_Max_Num {
		return serverproto.ErrorCode_ERROR_INVITATION_NUM_LIMIT
	}

	memberStr := "m:" + strconv.FormatUint(selfUid.Uid, 10)
	bExist := service.GetRedis().HExists(masterKeyStr, memberStr).Val()
	if bExist {
		return serverproto.ErrorCode_ERROR_INVITATION_IS_MEMBER
	}

	//add member
	err, msgData := model.GetEncodeMessage(selfUid)
	if err == nil {
		masterMemberNum++
		service.GetRedis().HSet(masterKeyStr, "mnum", masterMemberNum)
		service.GetRedis().HSet(masterKeyStr, memberStr, msgData)
	}

	return serverproto.ErrorCode_ERROR_OK
}

//
var MaxInvitationLogCount int64 = 50

/*
hkey
base
task:id
mnum
m:uid

lkey
*/

func SetInvitationDataToRedis(uid uint64, msg *serverproto.SSInvitationSaveNtf) {
	uidStr := strconv.FormatUint(uid, 10)
	keyStr := RoleInvitationPrefix + uidStr
	if msg.BaseSave {
		roleInvitation := &serverproto.RoleInvitation{
			ClickNum:              msg.ClickNum,
			SelfInvitationNumber:  msg.SelfInvitationNumber,
			MasterUid:             msg.MasterUid,
			MasterEndTime:         msg.MasterEndTime,
			ClickMemberList:       msg.ClickMemberList,
			ClickReplayMasterList: msg.ClickReplayMasterList,
		}
		fieldStr := "base"
		_, msgData := model.GetEncodeMessage(roleInvitation)
		service.GetRedis().HSet(keyStr, fieldStr, msgData)
	}

	//task list
	for idx := 0; idx < len(msg.TaskList); idx++ {
		fieldStr := "task:" + strconv.Itoa(int(msg.TaskList[idx].TaskId))
		_, msgData := model.GetEncodeMessage(msg.TaskList[idx])
		service.GetRedis().HSet(keyStr, fieldStr, msgData)
	}

	//member list
	service.GetRedis().HSet(keyStr, "mnum", msg.MemberNum) //总人数
	for idx := 0; idx < len(msg.AddMemberUidList); idx++ {
		memberData := msg.AddMemberUidList[idx]
		uidStr := strconv.FormatUint(memberData.Uid, 10)
		fieldStr := "m:" + uidStr
		_, msgData := model.GetEncodeMessage(memberData)
		service.GetRedis().HSet(keyStr, fieldStr, msgData)
	}
	for idx := 0; idx < len(msg.DelMemberUidList); idx++ {
		memberInfo := &serverproto.InvitationMemberValData{}
		fieldStr := "m:" + strconv.FormatUint(msg.DelMemberUidList[idx], 10)
		msgStr, err := service.GetRedis().HGet(keyStr, fieldStr).Result()
		if err != nil {
			continue
		}
		err = model.GetDecodeMessage(memberInfo, msgStr)
		if err != nil {
			continue
		}
		//该玩家没有提供过初心值，删除时不做保留
		if memberInfo.ResVal <= 0 {
			service.GetRedis().HDel(keyStr, fieldStr)
		} else {
			memberInfo.State = true //表示已经被删除
			err, msgData := model.GetEncodeMessage(memberInfo)
			if err == nil {
				service.GetRedis().HSet(keyStr, fieldStr, msgData)
			}
		}
	}

	//log
	logKeyStr := RoleInvitationLogPrefix + uidStr
	for idx := 0; idx < len(msg.AddLogList); idx++ {
		_, msgData := model.GetEncodeMessage(msg.AddLogList[idx])
		ret, err := service.GetRedis().LPush(logKeyStr, msgData).Result()
		if err == nil && ret > MaxInvitationLogCount {
			service.GetRedis().LTrim(logKeyStr, 0, MaxInvitationLogCount-1)
		}
	}
}

func GetRoleInvitationFromRedis(uid uint64, msg *serverproto.RoleInvitation) {
	uidStr := strconv.FormatUint(uid, 10)
	keyStr := RoleInvitationPrefix + uidStr

	valList, err := service.GetRedis().HGetAll(keyStr).Result()
	if err != nil && err != service.NIL {
		util.InfoF("GetRoleInvitationFromRedis get key=%v err=%v uid=%v", keyStr, err, uid)
		return
	}

	for key, val := range valList {
		if key == "base" {
			tmpInfo := &serverproto.RoleInvitation{}
			err := model.GetDecodeMessage(tmpInfo, val)
			if err == nil {
				msg.ClickNum = tmpInfo.ClickNum
				msg.SelfInvitationNumber = tmpInfo.SelfInvitationNumber
				msg.MasterUid = tmpInfo.MasterUid
				msg.MasterEndTime = tmpInfo.MasterEndTime
				msg.ClickMemberList = tmpInfo.ClickMemberList
				msg.ClickReplayMasterList = tmpInfo.ClickReplayMasterList
			}
		} else if strings.Contains(key, "task:") {
			taskInfo := &serverproto.InvitationTaskData{}
			err := model.GetDecodeMessage(taskInfo, val)
			if err == nil {
				msg.TaskList = append(msg.TaskList, taskInfo)
			}
		} else if strings.Contains(key, "m:") {
			memberInfo := &serverproto.InvitationMemberValData{}
			err := model.GetDecodeMessage(memberInfo, val)
			if err == nil {
				msg.MemberUidList = append(msg.MemberUidList, memberInfo)
			}
		}
	}
	//log
	logKeyStr := RoleInvitationLogPrefix + uidStr
	logList, err := service.GetRedis().LRange(logKeyStr, 0, -1).Result()
	if err == nil {
		for idx := 0; idx < len(logList); idx++ {
			logInfo := &serverproto.InvitationLogData{}
			err := model.GetDecodeMessage(logInfo, logList[idx])
			if err == nil {
				msg.LogList = append(msg.LogList, logInfo)
			}
		}
	}
}

//等级,充值等数据变更时通知导师(导师不在线保存到数据库)
func InvitationMemberDataChangeNotice(selfUid, masterUid uint64, param *serverproto.KeyValueType) {
	masterUidStr := strconv.FormatUint(masterUid, 10)
	selfUidStr := strconv.FormatUint(selfUid, 10)
	masterKeyStr := RoleInvitationPrefix + masterUidStr

	memberStr := "m:" + selfUidStr
	bExist := service.GetRedis().HExists(masterKeyStr, memberStr).Val()
	if !bExist {
		util.ErrorF("InvitationMemberDataChangeNotice not member master=%v self=%v param=%v", masterUid, selfUid, *param)
		return
	}

	//get member info
	msgStr, err := service.GetRedis().HGet(masterKeyStr, memberStr).Result()
	if err != nil {
		return
	}
	memberInfo := &serverproto.InvitationMemberValData{}
	err = model.GetDecodeMessage(memberInfo, msgStr)
	if err != nil {
		return
	}

	//已经被导师删除
	if memberInfo.State {
		util.ErrorF("InvitationMemberDataChangeNotice not member[del] master=%v self=%v param=%v", masterUid, selfUid, *param)
		return
	}

	if param.Key == int32(serverproto.TaskType_Invitation_Base_Level_Num) {
		//base level
		memberInfo.Level = param.Value
	} else if param.Key == int32(serverproto.TaskType_Invitation_Recharge_Num) {
		//total recharge
		memberInfo.TotalRecharge = float32(param.Value)
	}
	err, msgData := model.GetEncodeMessage(memberInfo)
	if err == nil {
		service.GetRedis().HSet(masterKeyStr, memberStr, msgData)
	}
	util.InfoF("InvitationMemberDataChangeNotice ok master=%v self=%v param=%v", masterUid, selfUid, *param)
}