package cache

import (
	"sort"
	"strings"
	"sync/atomic"

	"gitee.com/liuxuezhan/mylib/GameServer/CSV"
	proto "gitee.com/liuxuezhan/mylib/Protocol"
	"gitee.com/liuxuezhan/mylib/Utils/wlog"
	"gitee.com/liuxuezhan/mylib/Utils/wsort"
	"gitee.com/liuxuezhan/mylib/common"
)

//设置结构
type Asset_Settings struct {
	Basic
	AssetData *proto.ST_SettingAsset_PB
}

//重用
func (object *Asset_Settings) ReUse() {
	object.AssetData = &proto.ST_SettingAsset_PB{
		Audio: &proto.ST_AudioSetting_PB{
			BgmChannel: proto.SetBool(true),
			SfxChannel: proto.SetBool(true),
		},
		Notifiction:    &proto.ST_NotifictionSetting_PB{},
		Power:          make([]*proto.ST_PowerChat_PB, 0),
		LastReportTime: proto.SetUint64(0),
		DayReportCount: proto.SetUint32(0),
		FeedMark:       &proto.ST_FeedbackMark{},
	}
	object.Dirty()
}

//转换为客户端消息结构
func (object *Asset_Settings) ToClientString() []byte {
	object.RLock()
	defer object.RUnlock()

	clientAsset := proto.Clone(object.AssetData).(*proto.ST_SettingAsset_PB)
	clientAsset.DayReportCount = nil
	clientAsset.LastReportTime = nil
	clientAsset.Power = make([]*proto.ST_PowerChat_PB, 0)
	str := proto.Marshal(object.AssetData)
	return common.AddVersionInfoBeforeData(str, object.versionid)
}

//转换为服务器消息结构
func (object *Asset_Settings) ToServerString() []byte {
	object.RLock()
	defer object.RUnlock()

	return proto.Marshal(object.AssetData)
}

//从数据库加载
func (object *Asset_Settings) FromString(str []byte) {
	if 0 != len(str) {
		object.AssetData = &proto.ST_SettingAsset_PB{}
		if err := proto.Unmarshal(str, object.AssetData); nil != err {
			wlog.Error("unmarshal Asset_Settings failed: ", err.Error())
		}
	} else {
		object.ReUse()
	}

	powerStr := CSV.GetGameConfigValueString("MightReach")
	powerList := common.ParseStringToUint64List(powerStr)
	sort.Sort(sort.Reverse(wsort.Uint64Slice(powerList)))
	powers := make([]*proto.ST_PowerChat_PB, 0)
	find := false
	for _, v := range powerList {
		power := &proto.ST_PowerChat_PB{
			Power:  proto.SetUint64(v),
			IsChat: proto.SetBool(find),
		}
		powers = append(powers, power)

		if !find {
			for _, v1 := range object.AssetData.Power {
				if v1.GetPower() == power.GetPower() {
					power.IsChat = proto.SetBool(v1.GetIsChat())
					if power.GetIsChat() {
						find = true
					}
					break
				}
			}
		}

	}
	object.AssetData.Power = powers

	object.ServerDirty()
}

//用户是否在黑名单中
func (object *Asset_Settings) unsafeIsUserIdInBlockList(userId uint64) bool {
	for _, id := range object.AssetData.BlockListUid {
		if id == userId {
			return true
		}
	}
	return false
}

//用户加入黑名单
func (object *Asset_Settings) unsafeAddUserIdToBlockList(userId uint64) {
	object.AssetData.BlockListUid = append(object.AssetData.BlockListUid, userId)
}

//用户从黑名单删除
func (object *Asset_Settings) unsafeRemoveUserIdToBlockList(userId uint64) bool {
	for i := 0; i < len(object.AssetData.BlockListUid); i++ {
		if object.AssetData.BlockListUid[i] == userId {
			object.AssetData.BlockListUid = append(object.AssetData.BlockListUid[:i], object.AssetData.BlockListUid[i+1:]...)
			return true
		}
	}
	return false
}

//获取设置资产
func (userData *Info) WithSettingsAsset(readOrWrite bool, callback func(asset *Asset_Settings)) {
	if readOrWrite {
		userData.info.AssetData_Settings.RLock()
		defer userData.info.AssetData_Settings.RUnlock()
	} else {
		userData.info.AssetData_Settings.Lock()
		defer userData.info.AssetData_Settings.Unlock()
	}
	callback(userData.info.AssetData_Settings)
}

//用户id是否在黑名单
func (userData *Info) SafeIsUserIdInBlockList(userId uint64) bool {
	ret := false
	userData.WithSettingsAsset(true, func(asset *Asset_Settings) {
		ret = asset.unsafeIsUserIdInBlockList(userId)
	})
	return ret
}

//用户id加入黑名单
func (userData *Info) SafeAddBlockUserId(userId uint64) {
	userData.WithSettingsAsset(false, func(asset *Asset_Settings) {
		if !asset.unsafeIsUserIdInBlockList(userId) {
			asset.unsafeAddUserIdToBlockList(userId)
			asset.Dirty()
			userData.DirtyAll()
		}
	})
}

//
func (userData *Info) SafeCheckCanChatPower() (bool, uint64) {
	i := 0
	ret := false
	var retVal uint64
	userData.WithSettingsAsset(true, func(asset *Asset_Settings) {
		for ; i < len(asset.AssetData.Power); i++ {
			if asset.AssetData.Power[i].GetIsChat() == false &&
				asset.AssetData.Power[i].GetPower() <= userData.GetPower() {
				ret = true
				retVal = asset.AssetData.Power[i].GetPower()
				return
			}
		}
	})

	return ret, retVal
}

func (userData *Info) SafeSetPowerChat() {
	userData.WithSettingsAsset(false, func(asset *Asset_Settings) {
		for i := 0; i < len(asset.AssetData.Power); i++ {
			if asset.AssetData.Power[i].GetIsChat() == false &&
				asset.AssetData.Power[i].GetPower() <= userData.GetPower() {
				asset.AssetData.Power[i].IsChat = proto.SetBool(true)
				asset.Dirty()
				userData.ServerDirty()
				return
			}
		}
	})
}

func (userData *Info) SafeGetLastReportTime() uint64 {
	asset := userData.info.AssetData_Settings
	if asset.AssetData.LastReportTime == nil {
		return 0
	}
	return atomic.LoadUint64(asset.AssetData.LastReportTime)
}

func (userData *Info) SafeSetLastReportTime(lastTime uint64) {
	asset := userData.info.AssetData_Settings
	atomic.StoreUint64(asset.AssetData.LastReportTime, lastTime)
	asset.Dirty()
	userData.ServerDirty()
}

func (userData *Info) SafeGetDayReportCount() uint32 {
	asset := userData.info.AssetData_Settings
	if asset.AssetData.DayReportCount == nil {
		return 0
	}
	return atomic.LoadUint32(asset.AssetData.DayReportCount)
}

func (userData *Info) SafeSetDayReportCount(count uint32) {
	if count > 5 {
		count = 5
	}
	asset := userData.info.AssetData_Settings
	atomic.StoreUint32(asset.AssetData.DayReportCount, count)
	asset.Dirty()
	userData.ServerDirty()
}

//用户id移除黑名单
func (userData *Info) SafeRemoveBlockUserId(userId uint64) {
	userData.WithSettingsAsset(false, func(asset *Asset_Settings) {
		if asset.unsafeRemoveUserIdToBlockList(userId) {
			asset.Dirty()
			userData.DirtyAll()
		}
	})
}

//修改音频设置
func (userData *Info) SafeAlterAudioSettings(object *proto.ST_AudioSetting_PB) {
	userData.WithSettingsAsset(false, func(asset *Asset_Settings) {
		if nil == object {
			return
		}
		dirty := false
		if nil != object.BgmChannel {
			asset.AssetData.Audio.BgmChannel = proto.SetBool(object.GetBgmChannel())
			dirty = true
		}
		if nil != object.SfxChannel {
			asset.AssetData.Audio.SfxChannel = proto.SetBool(object.GetSfxChannel())
			dirty = true
		}
		if dirty {
			asset.Dirty()
			userData.DirtyAll()
		}
	})
}

//修改通知设置
func (userData *Info) SafeAlterNotificationSettings(object *proto.ST_NotifictionSetting_PB) {
	userData.WithSettingsAsset(false, func(asset *Asset_Settings) {
		if nil == object {
			return
		}
		asset.AssetData.Notifiction.Setting = proto.SetInt64(object.GetSetting())
		asset.Dirty()
		userData.DirtyAll()
	})
}

//
func (userData *Info) IsNotifyOpen(msgType proto.PushMsgType) bool {
	isOpen := false
	userData.WithSettingsAsset(true, func(asset *Asset_Settings) {
		if asset.AssetData.Notifiction.GetSetting()&(1<<uint32(msgType)) != 0 {
			isOpen = true
		}
	})

	return isOpen
}

func (userData *Info) SetDefaultNotifySetting() {
	userData.WithSettingsAsset(false, func(asset *Asset_Settings) {
		settingsStr := CSV.GetGameConfigValueString("PushMsgSwitch")
		settingStr := strings.Split(settingsStr, "|")
		for _, v := range settingStr {
			values := strings.Split(v, " ")
			if len(values) == 2 {
				if common.StringToInt32(values[1]) != 0 {
					asset.AssetData.Notifiction.Setting = proto.SetInt64(asset.AssetData.Notifiction.GetSetting() | (1 << common.StringToUint32(values[0])))
				} else {
					asset.AssetData.Notifiction.Setting = proto.SetInt64(asset.AssetData.Notifiction.GetSetting() &^ (1 << common.StringToUint32(values[0])))
				}
			}
		}

		asset.Dirty()
		userData.DirtyAll()
	})
}

func (userData *Info) UpdateFeedback(winPlayer bool, heroid, power uint32) {
	userData.WithSettingsAsset(true, func(asset *Asset_Settings) {
		if winPlayer && !asset.AssetData.FeedMark.GetFirstWinPlayer() {
			winPlayer = true
		} else {
			winPlayer = false
		}
		if power <= asset.AssetData.FeedMark.GetPower() {
			power = 0
		}
	})

	orangeHero := false
	if heroid > 0 {
		cfg := CSV.Mgr.CSV_HeroList.GetEntryPtr(int64(heroid))
		if cfg == nil || cfg.HeroQuality != 5 {
			return
		}
		orangeHero = true
	}

	if !winPlayer && !orangeHero && power == 0 {
		return
	}

	userData.WithSettingsAsset(false, func(asset *Asset_Settings) {
		feedMark := asset.AssetData.FeedMark
		if feedMark == nil {
			feedMark = &proto.ST_FeedbackMark{}
		}
		if winPlayer {
			feedMark.FirstWinPlayer = proto.SetBool(true)
		} else if orangeHero {
			feedMark.FirstOrangeHero = proto.SetBool(true)
		} else if power > uint32(0) {
			feedMark.Power = proto.SetUint32(power)
		}
		asset.Dirty()
		userData.DirtyAll()
	})
}