package lineup

import (
	"f1-game/internal/constant"
	"f1-game/internal/data"
	facade "f1-game/internal/facade"
	nameRoute "f1-game/internal/name/route"
	"f1-game/internal/pb"
	"f1-game/internal/sessions"
	"f1-game/internal/types"
	"f1-game/nodes/game/internal/db"
	dbLineup "f1-game/nodes/game/internal/db/data/lineup"

	cslice "github.com/cherry-game/cherry/extend/slice"
	clog "github.com/cherry-game/cherry/logger"
	cproto "github.com/cherry-game/cherry/net/proto"
)

var srv = &service{}

func Service() *service {
	return srv
}

type service struct {
	facade.PlayerServiceBase[*db.PlayerTable]
}

func (p *service) OnLogin(playerTable *db.PlayerTable, session *cproto.Session) {
	lineupTable := db.GetLineupTable(playerTable.PlayerID)

	// 检测阵容队伍变化 // TODO 暂时默认一个队伍
	if lineupTable.LineupMap.AddLineups(constant.Adventure_Type, 1) {
		lineupTable.Save2Queue()
	}
}

// func (p *service) OnLogined(playerTable *db.PlayerTable, session *cproto.Session) {

// }

// func (p *service) OnLogout(playerTable *db.PlayerTable) {

// }

// func (p *service) OnReset(playerTable *db.PlayerTable, _ *ctime.CherryTime, byLogin bool) {

// }

// Push 推送队伍信息
func (p *service) Push(playerTable *db.PlayerTable, session *cproto.Session) {
	lineupTable := db.GetLineupTable(playerTable.PlayerID)

	// 推送阵容数据
	lineupResp := pb.LineupsList{
		Lineups: lineupTable.LineupMap.ToProto(),
	}

	sessions.PushWithSession(session, nameRoute.PushGamePlayer_Lineup, &lineupResp)
}

// LineupChangePush 推送变化的阵容信息
func (p *service) LineupChangePush(playerID int64, lineupType int32, lineupIDList ...int32) {
	var (
		teamTable = db.GetLineupTable(playerID)
		list      = []*pb.Lineup{}
	)

	lineups, found := teamTable.LineupMap.GetLineups(lineupType)
	if !found {
		clog.Warnf("Lineup ChangePush lineupType not found. playerID:%d, lineupType:%d", playerID, lineupType)
		return
	}

	for _, lineupID := range lineupIDList {
		if lineup, ok := lineups.GetLineup(lineupID); ok {
			proto := lineup.ToProto()
			list = append(list, &proto)
		}
	}

	if len(list) == 0 {
		return
	}

	resp := &pb.Lineups{
		LineupType: lineupType,
		List:       list,
	}

	sessions.PushPlayer(playerID, nameRoute.PushGamePlayer_LineupChange, resp)
}

// 通过英雄列表获取羁绊列表
func (p *service) GetFetterListByHeroList(playerID int64, heroIDList types.Set[int32]) types.Set[int32] {
	if len(heroIDList) < 1 {
		return nil
	}

	activeFetterIDs := types.Set[int32]{}

	for heroID := range heroIDList {
		fetterIDs := data.HeroFetter.GetFetterIDs(heroID)
		// 当前英雄没有羁绊，则跳过
		if len(fetterIDs) < 1 {
			continue
		}

		for fetterID := range fetterIDs {
			if activeFetterIDs.Contains(fetterID) {
				continue
			}

			fetterRow, found := data.HeroFetter.GetByID(fetterID)
			if !found {
				clog.Warnf("[GetFetterListByHeroList] fetter not found, playerID:%d, fetterID: %d", playerID, fetterID)
				continue
			}

			curNum := int32(0)
			for _, needHeroID := range fetterRow.HeroIDs {
				if heroIDList.Contains(needHeroID) {
					curNum++

					// 如果当前所需英雄数量已经满足，则直接添加羁绊ID，并跳过
					if curNum >= fetterRow.ActiveHeroNum {
						activeFetterIDs.Add(fetterID)
						break
					}
				}
			}
		}
	}

	return activeFetterIDs
}

// 检测同队伍是否存在相同英雄
func (p *service) CheckLineupSameHero(heroTable *db.HeroTable, lineups dbLineup.Lineups, srcLineupID, srcLineupIndex, excludeLineupID, excludeIndex int32, heroIDs ...int32) bool {
	if len(lineups) <= 0 {
		return false
	}

	for _, lineup := range lineups {
		// 如果排除的位置为0 且 排除的阵容ID相同 则排除整个阵容
		if excludeIndex == 0 && lineup.LineupID == excludeLineupID {
			continue
		}

		for _, member := range lineup.Members {
			// 如果是不同阵容切换位置 则排除原位置
			if lineup.LineupID == srcLineupID && member.Index == srcLineupIndex {
				continue
			}

			// 排除上阵位置
			if lineup.LineupID == excludeLineupID && member.Index == excludeIndex {
				continue
			}

			hero, ok := heroTable.Heroes.Get(member.HeroGUID)
			if !ok {
				// 没找到返回true 防止上阵相同英雄
				return true
			}

			if _, ok := cslice.Int32In(hero.HeroID, heroIDs); ok {
				return true
			}
		}
	}

	return false
}

// 更新队伍羁绊列表
func (p *service) UpdateLineupFetterList(playerID int64, heroTable *db.HeroTable, updateTeams ...*dbLineup.Lineup) {
	if len(updateTeams) < 1 {
		return
	}

	for _, curTeam := range updateTeams {
		if len(curTeam.Members) < 1 {
			curTeam.FetterIDs.Clear()
			continue
		}

		// 获取英雄列表
		heroIDSet := types.Set[int32]{}
		for _, member := range curTeam.Members {
			curHeroEntity, found := heroTable.Heroes.Get(member.HeroGUID)
			if found {
				heroIDSet.Add(curHeroEntity.HeroID)
			}
		}

		// 刷新队伍羁绊
		fetterIDs := p.GetFetterListByHeroList(playerID, heroIDSet)
		curTeam.FetterIDs = fetterIDs
	}
}

// 检测阵容上阵人数是否已达上限
// index 当前上阵位置
func (p *service) CheckLineupMemberLimit(playerID int64, curLineup *dbLineup.Lineup, index int32) bool {
	playerTable, _ := db.GetPlayerTable(playerID)

	lordLevelRow, found := data.LordLevel.GetByLevel(playerTable.Lord.Level)
	if !found {
		clog.Warnf("[CheckLineupMemberLimit] lordLevelRow not found, playerID:%d, level:%d", playerID, playerTable.Lord.Level)
		return true
	}

	// 判断当前上阵位置是否存在英雄 如果存在
	memberCount := len(curLineup.Members)
	_, found = curLineup.GetLineupMember(index)
	// 上阵的位置不存在英雄 需要加上当前上阵英雄的数量
	if !found {
		memberCount++
	}

	return memberCount > lordLevelRow.LineupMemberLimit
}