package leagueQuest

import (
	"f1-game/internal/data"
	"f1-game/internal/enum"
	nameRoute "f1-game/internal/name/route"
	"f1-game/internal/pb"
	"f1-game/internal/sessions"
	"f1-game/nodes/map/internal/db"
	dbLeague "f1-game/nodes/map/internal/db/data/league"
	mapFacade "f1-game/nodes/map/internal/facade"
	"slices"

	cfacade "github.com/cherry-game/cherry/facade"
	cproto "github.com/cherry-game/cherry/net/proto"

	clog "github.com/cherry-game/cherry/logger"
)

var srv = &service{
	groupOpen: newServiceGroupOpen(),
	typ:       newServiceType(),
}

func Service() *service {
	return srv
}

type service struct {
	mapFacade.LeagueServiceBase[*db.MapLeagueTable]
	typ       serviceType
	groupOpen serviceGroupOpen
}

// 联盟创建时添加任务
func (p *service) OnInit(leagueTable *db.MapLeagueTable) {
	groupRows := []*data.QuestGroupRow{}

	// 添加联盟任务
	for _, leagueQuest := range data.LeagueQuest.List() {
		if leagueQuest.QuestType == int32(enum.LeagueQuestType_Process) {
			if leagueQuest.QuestGroupID <= 0 {
				continue
			}

			groupRow, found := data.QuestGroup.GetByGroupID(leagueQuest.QuestGroupID)
			if !found {
				clog.Warnf("league quest init fail, quest group not found. leagueID:%d, groupID:%d", leagueTable.LeagueID, leagueQuest.QuestGroupID)
				continue
			}

			groupRows = append(groupRows, groupRow)
		}
	}

	if len(groupRows) > 0 {
		p.AddQuestWithGroups(leagueTable, groupRows...)
	}
}

// 检测重置类型
func (p *service) OnReset(leagueTable *db.MapLeagueTable) {
	if !leagueTable.Stats.IsCanReset() {
		return
	}

	delIDList := []int32{}
	for _, questEntity := range leagueTable.Quests {
		groupRow, found := data.QuestGroup.GetByGroupID(questEntity.QuestGroupID)
		// 删除配表找不到的任务
		if !found {
			delIDList = append(delIDList, questEntity.QuestID)
			continue
		}

		// 删除 日循环任务
		if leagueTable.Stats.IsDayReset && groupRow.ResetType == enum.QuestResetType_HourOfDay {
			delIDList = append(delIDList, questEntity.QuestID)
			continue
		}

		// 删除 周循环任务
		if leagueTable.Stats.IsWeekReset && groupRow.ResetType == enum.QuestResetType_DayOfWeek {
			delIDList = append(delIDList, questEntity.QuestID)
			continue
		}
	}

	if len(delIDList) > 0 {
		leagueTable.Quests.DeleteQuests(delIDList)
		leagueTable.Save2Queue()
	}

	// 重置检查是否有新任务
	p.checkQuestReset(leagueTable.LeagueID)
}

func (p *service) Push(leagueTable *db.MapLeagueTable, session *cproto.Session) {
	p.ChangePushWithSession(session, leagueTable.Quests.List())
}

// TODO 现在任务变更是全联盟成员推送变更通知
func (p *service) ChangePush(leagueID int64, changeList []*dbLeague.Quest) {
	if leagueID <= 0 || len(changeList) <= 0 {
		return
	}

	leagueMemberTable, found := db.GetMapLeagueMemberTable(leagueID)
	if !found {
		clog.Warnf("league quest change push fail, league member table not found. leagueID:%d", leagueID)
		return
	}

	push := &pb.QuestList{}

	for _, change := range changeList {
		protoQuest := change.ToProto()
		push.Quests = append(push.Quests, &protoQuest)
	}

	sessions.PushPlayers(leagueMemberTable.GetLeagueMemberIDs(), nameRoute.PushMapLeague_Quests, push)
}

// ChangePush 推送任务变更列表
func (p *service) ChangePushWithSession(session *cproto.Session, changeList []*dbLeague.Quest) {
	if len(changeList) < 1 {
		return
	}

	push := &pb.QuestList{}

	for _, quest := range changeList {
		protoQuest := quest.ToProto()
		push.Quests = append(push.Quests, &protoQuest)
	}

	sessions.PushWithSession(session, nameRoute.PushMapLeague_Quests, push)
}

// CheckNewAndPush 检查是否有新的任务组&推送
func (p *service) checkQuestReset(leagueID int64) {
	var (
		leagueTable, _ = db.GetMapLeagueTable(leagueID)
		groupRows      = []*data.QuestGroupRow{}
	)

	// 遍历配置,获取是否有新增加的任务&组
	for _, groupRow := range data.QuestGroup.List() {
		// 功能触发类型的跳过
		if groupRow.OpenType == enum.QuestOpenType_TriggerOpen {
			continue
		}

		//验证本组是否开放
		if !p.groupOpen.validate(groupRow.OpenType, leagueID, groupRow) {
			continue
		}

		// 添加满足的任务组配置
		groupRows = append(groupRows, groupRow)
	}

	// 添加本组的任务
	p.AddQuestWithGroups(leagueTable, groupRows...)
}

// AddQuestWithGroups 根据任务组添加任务列表
func (p *service) AddQuestWithGroups(leagueTable *db.MapLeagueTable, groupRows ...*data.QuestGroupRow) bool {
	if len(groupRows) < 1 {
		return false
	}

	changeList := []*dbLeague.Quest{}
	for _, groupRow := range groupRows {
		questRows, found := data.Quest.ListByQuestGroupID(groupRow.GroupID)
		if !found {
			clog.Warnf("add quest with group fail, quest config not found. leagueID:%d", leagueTable.LeagueID)
			continue
		}

		for _, newQuestRow := range questRows {
			// 当前任务禁用， 跳过
			if newQuestRow.Disabled {
				continue
			}

			newQuestEntity, ok := p.AddQuest(leagueTable, newQuestRow)
			if !ok {
				continue
			}

			changeList = append(changeList, newQuestEntity)
		}
	}

	if len(changeList) < 1 {
		return false
	}

	// 保存任务数据
	leagueTable.Save2Queue()

	// 推送给客户端
	p.ChangePush(leagueTable.LeagueID, changeList)

	return true
}

// // AddQuest 添加一个任务
func (p *service) AddQuest(leagueTable *db.MapLeagueTable, questRow *data.QuestRow) (*dbLeague.Quest, bool) {
	if questRow == nil {
		clog.Warnf("quest is nil. [config = %+v]", questRow)
		return nil, false
	}

	if questRow.QuestType < 1 {
		clog.Warnf("quest type error. [config = %+v]", questRow)
		return nil, false
	}

	if leagueTable.Quests.ContainQuest(questRow.QuestID) {
		return nil, false
	}

	if len(questRow.QuestParams) < 1 {
		clog.Warnf("quest params is empty. [config = %+v]", questRow)
		return nil, false
	}

	// 获取任务类型解析器
	parser, found := p.typ.get(questRow.QuestType)
	if !found {
		clog.Warnf("quest type not implemented. [config = %+v]", questRow)
		return nil, false
	}

	// 创建任务
	newQuestEntity := dbLeague.NewQuest(questRow.QuestGroupID, questRow.QuestID)
	if !parser.OnCreate(leagueTable.LeagueID, &newQuestEntity, questRow) {
		clog.Warnf("create new questID fail. [questID = %d]", questRow.QuestID)
		return nil, false
	}

	// 检查任务是否完成
	newQuestEntity.CheckDataFinish(questRow.QuestParams[0])

	// 添加任务到存储
	isAdd := leagueTable.Quests.AddQuest(&newQuestEntity)
	return &newQuestEntity, isAdd
}

// TriggerOpenGroup 触发添加任务组(手工调用该函数)
func (p *service) TriggerOpenGroup(leagueID int64, groupID int32) bool {
	leagueTable, _ := db.GetMapLeagueTable(leagueID)
	if leagueTable.Quests.ContainGroup(groupID) {
		return false
	}

	groupRow, found := data.QuestGroup.GetByGroupID(groupID)
	if !found {
		return false
	}

	if groupRow.OpenType != enum.QuestOpenType_TriggerOpen {
		clog.Infof("[playerID = %d] [groupID = %d] openType != trigger open")
		return false
	}

	// 添加任务
	success := p.AddQuestWithGroups(leagueTable, groupRow)

	return success
}

func (p *service) DoEvent(leagueID int64, leagueTable *db.MapLeagueTable, e cfacade.IEventData) {
	changeList := []*dbLeague.Quest{} // 任务变更列表
	for _, questEntity := range leagueTable.Quests {
		// 已完成或已结束的任务 则跳过
		if questEntity.IsFinish() {
			continue
		}

		// 获取任务配置
		questRow, found := data.Quest.GetByQuestGroupIDQuestID(questEntity.QuestGroupID, questEntity.QuestID)
		if !found {
			clog.Warnf("[playerID = %d, quest = %+v] quest config not found.", leagueID, questEntity)
			continue
		}

		parser, found := p.typ.get(questRow.QuestType)
		if !found {
			clog.Warnf("[playerID = %d, quest = %+v] quest type not found.", leagueID, questRow)
			continue
		}

		// 联盟和玩家的事件都不包含
		if !slices.Contains(parser.LeagueEventNames(), e.Name()) && !slices.Contains(parser.PlayerEventNames(), e.Name()) {
			continue
		}

		// 通过事件更新任务数据
		if parser.OnUpdate(leagueID, questEntity, questRow, e) {
			// add to change list
			changeList = append(changeList, questEntity)

			// 检查是否完成
			questEntity.CheckDataFinish(questRow.QuestParams[0])
		}
	}

	if len(changeList) > 0 {
		// 推送变更数据
		leagueTable.Save2Queue()

		// 推送任务列表
		p.ChangePush(leagueID, changeList)
	}
}

func (p *service) LeagueEventNames() []string {
	return p.typ.leagueEventNames()
}

func (p *service) PlayerEventNames() []string {
	return p.typ.playerEventNames()
}