package enum

import "slices"

// 行军状态
type MarchState int32

const (
	// 基础状态
	MarchState_None          MarchState = -1 // 无
	MarchState_Standby       MarchState = 0  // 待命状态
	MarchState_Retreat       MarchState = 2  // 回城状态
	MarchState_Occupy        MarchState = 3  // 占领状态
	MarchState_Garrison      MarchState = 5  // 驻守状态
	MarchState_Siege         MarchState = 6  // 攻城状态
	MarchState_Redeploy      MarchState = 7  // 调动状态
	MarchState_Assemble      MarchState = 8  // 集结状态
	MarchState_Entrust       MarchState = 10 // 委托状态
	MarchState_Snatch        MarchState = 11 // 掠夺状态
	MarchState_SiegeAssemble MarchState = 12 // 攻城集结状态（暂定,用来和军团集结区分）

	// 基础移动状态
	MarchState_Stay  MarchState = 1   // 停留状态
	MarchState_March MarchState = 100 // 行军状态

	// 行军到结果发生状态
	MarchState_MarchAssemble      MarchState = 102 // 行军集结状态
	MarchState_MarchRedeploy      MarchState = 101 // 调动行军状态
	MarchState_MarchEntrust       MarchState = 104 // 委托行军状态
	MarchState_MarchSiegeAssemble MarchState = 105 // 攻城集结行军（指部队集结到攻城大营时的移动状态）
	MarchState_Rout               MarchState = 106 // 战败撤退

	// 战斗相关状态
	MarchState_Battle     MarchState = 200 // 战斗状态
	MarchState_BattleWait MarchState = 201 // 战斗等待状态

)

var (
	marchStateName = map[MarchState]string{
		MarchState_None:          "None",
		MarchState_Standby:       "Standby",
		MarchState_Stay:          "Stay",
		MarchState_Retreat:       "Retreat",
		MarchState_Occupy:        "Occupy",
		MarchState_Garrison:      "Garrison",
		MarchState_Siege:         "Siege",
		MarchState_Redeploy:      "Redeploy",
		MarchState_Assemble:      "Assemble",
		MarchState_March:         "March",
		MarchState_Snatch:        "Snatch",
		MarchState_SiegeAssemble: "SiegeAssemble",
		MarchState_MarchRedeploy: "MarchRedeploy",
		MarchState_MarchAssemble: "MarchAssemble",
		MarchState_Rout:          "Rout",
		MarchState_Battle:        "Battle",
		MarchState_BattleWait:    "BattleWait",
	}

	moveStates = []MarchState{
		MarchState_March,
		MarchState_Retreat,
		MarchState_Rout,
		MarchState_MarchRedeploy,
		MarchState_MarchAssemble,
		MarchState_MarchEntrust,
		MarchState_MarchSiegeAssemble,
	}

	// 可接收“行军”指令的行军状态
	marchableStates = []MarchState{
		MarchState_Standby,
		MarchState_Stay,
		MarchState_Redeploy,
		MarchState_SiegeAssemble,
	}

	notInMapStates = []MarchState{
		MarchState_Standby,
		MarchState_SiegeAssemble,
		MarchState_Redeploy,
		MarchState_Assemble,
	}

	assembleState = []MarchState{
		MarchState_Assemble,
	}

	// 军团状态转换到行军状态
	legionStateToMarchState = map[LegionState]MarchState{
		LegionState_None:           MarchState_None,
		LegionState_AssembleWait:   MarchState_Stay,
		LegionState_AssembleFinish: MarchState_Stay,
		LegionState_AssembleMarch:  MarchState_March,
		LegionState_BattleWait:     MarchState_BattleWait,
		LegionState_Crusade:        MarchState_Battle,
		LegionState_Siege:          MarchState_Siege,
	}

	// 可自动防守状态
	autoDefendStates = []MarchState{
		MarchState_Standby,
		MarchState_Redeploy,
		MarchState_SiegeAssemble,
	}
)

func GetMarchStateName(marchState MarchState) string {
	if val, found := marchStateName[marchState]; found {
		return val
	}

	return "Unknown"
}

func GetMarchStateByLegionState(legionState LegionState) MarchState {
	if val, found := legionStateToMarchState[legionState]; found {
		return val
	}

	return MarchState_None
}

func GetMarchStateByRetreatType(retreatType RetreatType) MarchState {
	switch retreatType {
	case RetreatType_Rout:
		return MarchState_Rout
	default:
		return MarchState_Retreat
	}
}

func IsAutoDefendState(state MarchState) bool {
	return slices.Contains(autoDefendStates, state)
}

// IsInMapState 拥有此状态的行军对象是否在地图上
func IsInMapState(state MarchState) bool {
	return !slices.Contains(notInMapStates, state)
}

// IsMovingState 拥有此状态的行军对象是否在移动中
func IsMovingState(state MarchState) bool {
	return slices.Contains(moveStates, state)
}

func IsMarchState(state MarchState) bool {
	return state == MarchState_March
}

func IsRetreatState(state MarchState) bool {
	return state == MarchState_Retreat || state == MarchState_Rout
}

func IsRedeployState(state MarchState) bool {
	return state == MarchState_Redeploy || state == MarchState_SiegeAssemble
}

func IsMarchRedeployState(state MarchState) bool {
	return state == MarchState_MarchRedeploy || state == MarchState_MarchSiegeAssemble
}

func IsAssembleState(state MarchState) bool {
	return slices.Contains(assembleState, state)
}

// IsMarchableState 当前状态是否为可执行行军指令的状态
func IsMarchableState(state MarchState) bool {
	return slices.Contains(marchableStates, state)
}