package main

import (
	"strings"
	"testing"
	"time"
)

func TestStoryDifficultySelectionGoesStraightToOnboardingHub(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.state = stateStoryDifficulty
	m.storyDifficultyCursor = 2 // "Сложная"

	next, _ := m.Update(key("enter"))
	m = next.(AppModel)
	if m.state != stateStoryHub {
		t.Fatalf("после выбора сложности ожидался переход сразу в stateStoryHub (этап знакомства), получено %v", m.state)
	}
	if m.story == nil {
		t.Fatalf("ожидалось созданное состояние сторимода")
	}
	if m.story.Difficulty != StoryDifficultyHard {
		t.Errorf("ожидалась сложность StoryDifficultyHard, получено %v", m.story.Difficulty)
	}
	if m.story.Onboarding != StoryOnboardingTicTacToeOnly {
		t.Errorf("новая партия должна была начаться с этапа знакомства (только крестики-нолики), получено %v", m.story.Onboarding)
	}
}

func TestStoryDifficultySelectionPersistsToSave(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.state = stateStoryDifficulty
	m.storyDifficultyCursor = 1

	next, _ := m.Update(key("enter"))
	_ = next.(AppModel)

	loaded, err := LoadStoryModeState()
	if err != nil {
		t.Fatalf("неожиданная ошибка загрузки: %v", err)
	}
	if loaded.Difficulty != StoryDifficultyMedium {
		t.Errorf("сохранённая сложность должна была быть Medium, получено %v", loaded.Difficulty)
	}
}

func TestModeSelectStoryWithExistingSaveShowsGreetingThenHub(t *testing.T) {
	withTempConfigDir(t)
	pre := NewStoryModeState(StoryDifficultyEasy, time.Now())
	pre.Onboarding = StoryOnboardingDone // приветствие дня показывается только после знакомства
	if err := SaveStoryModeState(pre); err != nil {
		t.Fatalf("неожиданная ошибка сохранения: %v", err)
	}

	m := NewAppModel()
	next, _ := m.Update(key("enter")) // язык -> выбор режима
	m = next.(AppModel)
	next, _ = m.Update(key("down")) // курсор на "Режим истории"
	m = next.(AppModel)
	next, _ = m.Update(key("enter"))
	m = next.(AppModel)

	if m.state != stateStoryMorning {
		t.Fatalf("при входе через меню режимов ожидалось приветствие дня, получено %v", m.state)
	}
	if m.storyGreeting != storyGreetingPlayingAgain {
		t.Errorf("при входе в тот же день ожидалось приветствие storyGreetingPlayingAgain, получено %v", m.storyGreeting)
	}

	next, _ = m.Update(key(" "))
	m = next.(AppModel)
	if m.state != stateStoryHub {
		t.Fatalf("после приветствия ожидался переход в stateStoryHub, получено %v", m.state)
	}
	if m.story == nil || m.story.Difficulty != StoryDifficultyEasy {
		t.Fatalf("ожидалось загруженное состояние с сохранённой сложностью, получено %+v", m.story)
	}
}

func TestStoryHubLaunchesPlayableGame(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.state = stateStoryHub
	m.storyHubCursor = 0 // Крестики-нолики — единственная видимая игра на этапе знакомства

	next, _ := m.Update(key("enter"))
	m = next.(AppModel)
	if m.state != statePlaying {
		t.Fatalf("ожидался переход в statePlaying после запуска игры, получено %v", m.state)
	}
	if m.storyActiveResource == nil || *m.storyActiveResource != StoryResTicTacToe {
		t.Fatalf("ожидался отмеченный активный ресурс StoryResTicTacToe")
	}
	if _, ok := m.activeGame.(TicTacToeModel); !ok {
		t.Errorf("ожидалась запущенная модель TicTacToeModel, получено %T", m.activeGame)
	}
}

func TestAllStoryHubGamesAreWiredInStoryGameDefs(t *testing.T) {
	for _, id := range storyHubOrder {
		if _, ok := storyGameDefs[id]; !ok {
			t.Errorf("ресурс %v есть в storyHubOrder, но не подключён в storyGameDefs", id)
		}
	}
}

func TestStoryHubStillLaunchesLockedGame(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.story.Onboarding = StoryOnboardingDone // тест про полный хаб, не про этап знакомства
	m.story.Locked[StoryResTicTacToe] = true
	m.state = stateStoryHub
	m.storyHubCursor = indexOfStoryResource(t, StoryResTicTacToe)

	next, _ := m.Update(key("enter"))
	m = next.(AppModel)
	if m.activeGame == nil {
		t.Errorf("уже зафиксированная (запертая) игра должна была оставаться играбельной")
	}
}

func TestWinningStoryGameAwardsResourceAndReturnsToHub(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	before := m.story.Resources[StoryResTicTacToe]

	tm := NewTicTacToeModel(TicTacToeDifficultyEasy)
	tm.game.Phase = TicTacToePhaseOver
	tm.game.Result = &TicTacToeResult{Winner: tm.game.HumanMark}
	tm.backToMenu = true

	resource := StoryResTicTacToe
	m.storyActiveResource = &resource
	m.activeGame = tm
	m.state = statePlaying

	next, _ := m.Update(key("q")) // ключ не важен — уже готовый backToMenu=true проверяется в Update верхнего уровня
	m2, ok := next.(AppModel)
	if !ok {
		t.Fatalf("ожидался AppModel в ответе")
	}

	if m2.state != stateStoryHub {
		t.Fatalf("после победы в игре сторимода ожидался возврат в stateStoryHub, получено %v", m2.state)
	}
	if m2.story.Resources[StoryResTicTacToe] != before+1 {
		t.Errorf("ожидалось начисление +1 ресурса за победу, получено %d (было %d)", m2.story.Resources[StoryResTicTacToe], before)
	}
	if m2.storyActiveResource != nil {
		t.Errorf("отметка активного ресурса должна была сброситься после возврата")
	}
}

func TestLosingStoryGameDoesNotAwardResource(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	before := m.story.Resources[StoryResTicTacToe]

	tm := NewTicTacToeModel(TicTacToeDifficultyEasy)
	tm.game.Phase = TicTacToePhaseOver
	loser := TicTacToeX
	if tm.game.HumanMark == TicTacToeX {
		loser = TicTacToeO
	}
	tm.game.Result = &TicTacToeResult{Winner: loser}
	tm.backToMenu = true

	resource := StoryResTicTacToe
	m.storyActiveResource = &resource
	m.activeGame = tm
	m.state = statePlaying

	next, _ := m.Update(key("q"))
	m2 := next.(AppModel)

	if m2.story.Resources[StoryResTicTacToe] != before {
		t.Errorf("поражение не должно было начислять ресурс, получено %d (было %d)", m2.story.Resources[StoryResTicTacToe], before)
	}
	if m2.state != stateStoryHub {
		t.Errorf("после поражения тоже ожидался возврат в хаб, получено %v", m2.state)
	}
}

func TestStoryResourceLocksExactlyAtTarget(t *testing.T) {
	s := NewStoryModeState(StoryDifficultyEasy, time.Now())
	s.Resources[StoryResChess] = StoryTargetChess - 1
	s.RecordWin(StoryResChess)
	if !s.Locked[StoryResChess] {
		t.Fatalf("ресурс должен был зафиксироваться по достижении цели")
	}
}

// indexOfStoryResource находит позицию ресурса в storyHubOrder — не
// хардкодим индекс напрямую, чтобы тест не сломался при изменении
// порядка показа в хабе.
func indexOfStoryResource(t *testing.T, id StoryResourceID) int {
	t.Helper()
	for i, r := range storyHubOrder {
		if r == id {
			return i
		}
	}
	t.Fatalf("ресурс %v не найден в storyHubOrder", id)
	return -1
}

func TestStoryOutcomeBlackjackRequiresThreeRoundsMinimum(t *testing.T) {
	bm := NewBlackjackModel(1, 500, 25)
	for bm.game.Phase == BJPhasePlayerTurn {
		bm.game.Stand()
	}
	bm.game.RoundsPlayed = 2
	bm.game.Players[bm.humanIdx].Balance = bm.game.StartingCapital + 1000 // в большом плюсе, но раундов мало

	finished, won := storyOutcomeBlackjack(bm)
	if !finished {
		t.Fatalf("после завершения раунда партия должна была считаться finished")
	}
	if won {
		t.Errorf("меньше трёх раундов не должно засчитываться победой, даже при явном плюсе")
	}
}

func TestStoryOutcomeBlackjackWinsWithThreeRoundsAndProfit(t *testing.T) {
	bm := NewBlackjackModel(1, 500, 25)
	for bm.game.Phase == BJPhasePlayerTurn {
		bm.game.Stand()
	}
	bm.game.RoundsPlayed = 3
	bm.game.Players[bm.humanIdx].Balance = bm.game.StartingCapital + 1

	_, won := storyOutcomeBlackjack(bm)
	if !won {
		t.Errorf("три раунда и баланс выше стартового должны были засчитаться победой")
	}
}

func TestStoryOutcomeBlackjackNoWinWithoutProfit(t *testing.T) {
	bm := NewBlackjackModel(1, 500, 25)
	for bm.game.Phase == BJPhasePlayerTurn {
		bm.game.Stand()
	}
	bm.game.RoundsPlayed = 5
	bm.game.Players[bm.humanIdx].Balance = bm.game.StartingCapital // ровно столько же, не "выше"

	_, won := storyOutcomeBlackjack(bm)
	if won {
		t.Errorf("баланс не выше стартового (даже после многих раундов) не должен засчитываться победой")
	}
}

func TestStoryOutcomeBlackjackNotFinishedMidRound(t *testing.T) {
	bm := NewBlackjackModel(1, 500, 25)
	bm.game.Phase = BJPhasePlayerTurn // принудительно, чтобы не зависеть от случайного натурального блэкджека с раздачи
	finished, _ := storyOutcomeBlackjack(bm)
	if finished {
		t.Errorf("партия в процессе раунда не должна была считаться завершённой")
	}
}

func TestTicTacToeDrawCountsAsStoryWin(t *testing.T) {
	tm := NewTicTacToeModel(TicTacToeDifficultyEasy)
	tm.game.Phase = TicTacToePhaseOver
	tm.game.Result = &TicTacToeResult{Winner: TicTacToeEmpty} // ничья
	finished, won := storyOutcomeTicTacToe(tm)
	if !finished || !won {
		t.Errorf("ничья должна была засчитаться как победа в сторимоде, получено finished=%v won=%v", finished, won)
	}
}

func TestTicTacToeStoryTargetIsTen(t *testing.T) {
	if StoryTargetTicTacToe != 10 {
		t.Errorf("ожидалась цель 10 для крестиков-ноликов, получено %d", StoryTargetTicTacToe)
	}
}

func TestEnterStoryHubFromModeSelectShowsMorningScreenAfterADay(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	past := time.Now().Add(-25 * time.Hour)
	m.story = NewStoryModeState(StoryDifficultyEasy, past)
	m.story.Onboarding = StoryOnboardingDone

	m = m.enterStoryHubFromModeSelect()
	if m.state != stateStoryMorning {
		t.Fatalf("после прошедших суток ожидался утренний экран, получено %v", m.state)
	}
	if m.storyGreeting != storyGreetingWokeUp {
		t.Errorf("после ровно одних прошедших суток ожидалось приветствие storyGreetingWokeUp, получено %v", m.storyGreeting)
	}
	// возможные случайно сработавшие события (выброс/стук) не относятся
	// к тому, что здесь проверяется — своя логика очереди уже
	// покрыта отдельными тестами
	m.story.PendingNeurotoxinAlert = false
	m.story.PendingDoorKnockAlert = false

	next, _ := m.Update(key(" "))
	m2 := next.(AppModel)
	if m2.state != stateStoryHub {
		t.Errorf("после утреннего экрана ожидался переход в хаб, получено %v", m2.state)
	}
}

func TestEnterStoryHubFromModeSelectSkipsGreetingDuringOnboarding(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now()) // по умолчанию ещё на этапе знакомства

	m = m.enterStoryHubFromModeSelect()
	if m.state != stateStoryHub {
		t.Errorf("во время знакомства (ИИ ещё не представилась) приветствие дня показываться не должно, получено %v", m.state)
	}
}

func TestEnterStoryHubFromModeSelectShowsGreetingAfterOnboarding(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.story.Onboarding = StoryOnboardingDone

	m = m.enterStoryHubFromModeSelect()
	if m.state != stateStoryMorning {
		t.Errorf("после завершения знакомства вход через меню режимов должен был показывать одно из приветствий, получено %v", m.state)
	}
	if m.storyGreeting != storyGreetingPlayingAgain {
		t.Errorf("в тот же день ожидалось приветствие storyGreetingPlayingAgain, получено %v", m.storyGreeting)
	}
}

func TestEnterStoryHubAfterGameNeverShowsGreeting(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	past := time.Now().Add(-50 * time.Hour) // прошло несколько суток
	m.story = NewStoryModeState(StoryDifficultyEasy, past)

	m = m.enterStoryHub()
	if m.state != stateStoryHub {
		t.Errorf("возврат из партии не должен показывать приветствие дня даже после нескольких прошедших суток, получено %v", m.state)
	}
}

func TestStoryOutcomeTonkRequiresThreeRoundsAndMaxBalance(t *testing.T) {
	tm := NewModel()
	tm.game.Phase = PhaseGameOver
	tm.game.RoundsPlayed = 2
	tm.game.Players[tm.humanIdx].Balance = 999999 // в большом плюсе, но раундов мало
	if _, won := storyOutcomeTonk(tm); won {
		t.Errorf("меньше трёх раундов не должно засчитываться победой")
	}

	tm.game.RoundsPlayed = 3
	for _, p := range tm.game.Players {
		p.Balance = 0
	}
	tm.game.Players[tm.humanIdx].Balance = 100
	if _, won := storyOutcomeTonk(tm); !won {
		t.Errorf("три раунда и максимальный баланс должны были засчитаться победой")
	}
}

func TestStoryOutcomeDurakStreakResetsOnLoss(t *testing.T) {
	dm := NewDurakModel(4)
	dm.storyNonFoolStreak = 2
	dm.game.Result = &DurakResult{Loser: dm.humanIdx}
	if _, won := storyOutcomeDurak(dm); won {
		t.Errorf("поражение в решающей партии должно было сбросить серию, а не засчитать победу")
	}
}

func TestStoryOutcomeDurakStreakCountsCurrentGame(t *testing.T) {
	dm := NewDurakModel(4)
	dm.storyNonFoolStreak = 2 // уже 2 подряд без дурака
	other := (dm.humanIdx + 1) % len(dm.game.Players)
	dm.game.Result = &DurakResult{Loser: other} // в этой партии дураком стал не человек
	if _, won := storyOutcomeDurak(dm); !won {
		t.Errorf("третья подряд партия без дурака должна была засчитаться победой")
	}
}

func TestStoryOutcomeMinesweeperStreakResetsOnLoss(t *testing.T) {
	mm := NewMinesweeperModel(9, 9, 10)
	mm.storyWinStreak = 2
	mm.game.Result = &MinesweeperResult{Won: false}
	if _, won := storyOutcomeMinesweeper(mm); won {
		t.Errorf("взрыв в решающей партии должен был сбросить серию, а не засчитать победу")
	}
}

func TestStoryOutcomeMinesweeperStreakCountsCurrentGame(t *testing.T) {
	mm := NewMinesweeperModel(9, 9, 10)
	mm.storyWinStreak = 2
	mm.game.Result = &MinesweeperResult{Won: true}
	if _, won := storyOutcomeMinesweeper(mm); !won {
		t.Errorf("третья подряд победа без взрыва должна была засчитаться")
	}
}

func TestStoryOutcomeOneOhOneRequiresMatchOverNotJustRound(t *testing.T) {
	om := NewOneOhOneModel(3)
	om.game.Phase = OneOhOnePhaseRoundOver
	om.game.Result = &OneOhOneRoundResult{Winner: om.humanIdx, MatchOver: false}
	if finished, _ := storyOutcomeOneOhOne(om); finished {
		t.Errorf("отдельный раунд не должен засчитываться завершением партии — нужен весь матч")
	}

	om.game.Result.MatchOver = true
	om.game.Result.MatchWinner = om.humanIdx
	if finished, won := storyOutcomeOneOhOne(om); !finished || !won {
		t.Errorf("выигранный матч должен был засчитаться победой, получено finished=%v won=%v", finished, won)
	}
}

func TestStoryOutcomeThousandRequiresThreeHandsAndTopScore(t *testing.T) {
	tm := NewThousandModel()
	tm.game.Phase = ThousandPhaseHandOver
	tm.game.HandNumber = 2
	tm.game.Players[tm.humanIdx].Score = 999999
	if _, won := storyOutcomeThousand(tm); won {
		t.Errorf("меньше трёх раздач не должно засчитываться победой")
	}

	tm.game.HandNumber = 3
	for _, p := range tm.game.Players {
		p.Score = 0
	}
	tm.game.Players[tm.humanIdx].Score = 50
	if _, won := storyOutcomeThousand(tm); !won {
		t.Errorf("три раздачи и первое место по очкам должны были засчитаться победой")
	}
}

func TestStoryOutcomeKlondikeJustReportsWinFlag(t *testing.T) {
	km := NewKlondikeModel()
	km.game.Won = false
	if finished, _ := storyOutcomeKlondike(km); finished {
		t.Errorf("незавершённая партия не должна была считаться выигранной")
	}
	km.game.Won = true
	if finished, won := storyOutcomeKlondike(km); !finished || !won {
		t.Errorf("выигранная партия должна была вернуть finished=true won=true")
	}
}

func TestKlondikeDailyCounterAwardsResourceOnThirdWinOfDay(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())

	km := NewKlondikeModel()
	km.game.Won = true
	km.backToMenu = true

	for i := 0; i < 3; i++ {
		resource := StoryResKlondike
		m.storyActiveResource = &resource
		m.activeGame = km
		m.state = statePlaying
		next, _ := m.Update(key("q"))
		m = next.(AppModel)
	}

	if m.story.Resources[StoryResKlondike] != storyStartingAmount+1 {
		t.Errorf("после третьей победы за день ожидалось начисление ровно +1 ресурса, получено %d (было %d)",
			m.story.Resources[StoryResKlondike], storyStartingAmount)
	}
	if m.story.KlondikeWinsToday != 3 {
		t.Errorf("ожидался счётчик побед за день = 3, получено %d", m.story.KlondikeWinsToday)
	}
}

func TestStoryOutcomePokerRequiresTournamentOverAndNotEliminated(t *testing.T) {
	pm := NewPokerModel(4)
	if finished, _ := storyOutcomePoker(pm); finished {
		t.Errorf("турнир в процессе не должен считаться завершённым")
	}

	pm.game.Phase = PokerPhaseTournamentOver
	pm.game.Players[pm.humanSeat].Eliminated = false
	if finished, won := storyOutcomePoker(pm); !finished || !won {
		t.Errorf("невыбывший человек при завершении турнира должен был засчитаться победителем")
	}

	pm.game.Players[pm.humanSeat].Eliminated = true
	if _, won := storyOutcomePoker(pm); won {
		t.Errorf("выбывший человек не должен был засчитаться победителем турнира")
	}
}

func TestExistingSaveSkipsWelcomeScreen(t *testing.T) {
	withTempConfigDir(t)
	pre := NewStoryModeState(StoryDifficultyEasy, time.Now())
	pre.Onboarding = StoryOnboardingDone
	if err := SaveStoryModeState(pre); err != nil {
		t.Fatalf("неожиданная ошибка сохранения: %v", err)
	}

	m := NewAppModel()
	next, _ := m.Update(key("enter")) // язык -> выбор режима
	m = next.(AppModel)
	next, _ = m.Update(key("down")) // курсор на "Режим истории"
	m = next.(AppModel)
	next, _ = m.Update(key("enter"))
	m = next.(AppModel)

	if m.state != stateStoryMorning {
		t.Fatalf("ожидалось ежедневное приветствие (не одноразовое приветствие ИИ), получено %v", m.state)
	}
	if m.state == stateStoryWelcome {
		t.Fatalf("одноразовое приветствие ИИ не должно было показаться повторно")
	}
}

func TestStoryConditionsScreenListsAllGames(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.story.Onboarding = StoryOnboardingDone // клавиша c недоступна во время знакомства
	m.state = stateStoryHub

	next, _ := m.Update(key("c"))
	m = next.(AppModel)
	if m.state != stateStoryConditions {
		t.Fatalf("клавиша c должна была открыть экран условий, получено %v", m.state)
	}
	view := m.View()
	for _, id := range storyHubOrder {
		resDef := storyResourceDefs[id]
		if !strings.Contains(view, T(resDef.NameKey)) {
			t.Errorf("экран условий должен был упоминать %q", T(resDef.NameKey))
		}
	}

	next, _ = m.Update(key("esc"))
	m = next.(AppModel)
	if m.state != stateStoryHub {
		t.Errorf("любая клавиша на экране условий должна была вернуть в хаб, получено %v", m.state)
	}
}

func TestStoryEscapeOptionHiddenUntilConditionMet(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.state = stateStoryHub

	if m.storyEscapeUnlocked() {
		t.Fatalf("условие побега не должно было выполниться при стартовых ресурсах")
	}
	view := m.View()
	if strings.Contains(view, T("story.hub.escape_option")) {
		t.Errorf("пункт побега не должен был показываться до выполнения условия")
	}
}

func TestStoryEscapeRequiresAllThreeConditions(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.story.Onboarding = StoryOnboardingDone

	// стресс высокий, но запасов не хватает — не должно сработать
	m.story.Stress = 60
	if m.storyEscapeUnlocked() {
		t.Errorf("побег не должен был разблокироваться без достаточных запасов мыла/верёвок, даже при высоком стрессе")
	}

	// запасов хватает, но стресс низкий — тоже не должно сработать
	m.story.Stress = 20
	m.story.Resources[StoryResTicTacToe] = 50
	m.story.Resources[StoryResSenet] = 50
	if m.storyEscapeUnlocked() {
		t.Errorf("побег не должен был разблокироваться при низком стрессе, даже с достаточными запасами")
	}

	// все три условия разом — теперь должно сработать
	m.story.Stress = 60
	if !m.storyEscapeUnlocked() {
		t.Errorf("побег должен был разблокироваться при выполнении всех трёх условий разом")
	}
}

func TestStoryEscapeStillLockedBelowStressThreshold(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.story.Onboarding = StoryOnboardingDone
	m.story.Resources[StoryResTicTacToe] = 50
	m.story.Resources[StoryResSenet] = 50
	m.story.Stress = 59 // чуть ниже порога, запасов уже достаточно

	if m.storyEscapeUnlocked() {
		t.Errorf("побег не должен был разблокироваться при стрессе ниже 60%%, даже с достаточными запасами")
	}
}

func TestStoryEscapeOptionAppearsAndLeadsToAttemptScreen(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.story.Onboarding = StoryOnboardingDone // пункт побега скрыт во время знакомства
	m.story.Resources[StoryResTicTacToe] = 50
	m.story.Resources[StoryResSenet] = 50
	m.story.Stress = 60
	m.state = stateStoryHub
	m.storyHubCursor = len(storyHubOrder) // дополнительный пункт в конце списка

	if !m.storyEscapeUnlocked() {
		t.Fatalf("условие побега должно было выполниться при 50/50/60")
	}
	view := m.View()
	if !strings.Contains(view, T("story.hub.escape_option")) {
		t.Errorf("пункт побега должен был появиться в хабе")
	}

	next, _ := m.Update(key("enter"))
	m = next.(AppModel)
	if m.state != stateStoryEscapeAttempt {
		t.Fatalf("выбор пункта побега должен был вести на экран уговоров, получено %v", m.state)
	}
}

func TestStoryEscapeAttemptTakingPillResetsStressAndReturnsToHub(t *testing.T) {
	withTempConfigDir(t)
	m := AppModel{state: stateStoryEscapeAttempt, story: NewStoryModeState(StoryDifficultyEasy, time.Now())}
	m.story.Stress = 80
	next, _ := m.Update(key("1"))
	m = next.(AppModel)
	if m.state != stateStoryHub {
		t.Errorf("выбор таблетки должен был вернуть в хаб, получено %v", m.state)
	}
	if m.story.Stress != 0 {
		t.Errorf("таблетка должна была сбросить стресс до 0, получено %d", m.story.Stress)
	}
}

func TestStoryEscapeAttemptEscReturnsToHubWithoutTakingPill(t *testing.T) {
	m := AppModel{state: stateStoryEscapeAttempt, story: NewStoryModeState(StoryDifficultyEasy, time.Now())}
	m.story.Stress = 80
	next, _ := m.Update(key("esc"))
	m = next.(AppModel)
	if m.state != stateStoryHub {
		t.Errorf("esc должен был вернуть в хаб, получено %v", m.state)
	}
	if m.story.Stress != 80 {
		t.Errorf("esc не должен был трогать стресс, получено %d", m.story.Stress)
	}
}

func TestStoryEscapeAttemptLeavingGoesToEnding(t *testing.T) {
	m := AppModel{state: stateStoryEscapeAttempt}
	next, _ := m.Update(key("2"))
	m = next.(AppModel)
	if m.state != stateStoryEscapeEnding {
		t.Errorf("выбор 'сбежать' должен был вести на экран концовки, получено %v", m.state)
	}
}

func TestStoryEscapeEndingReturnsToModeSelect(t *testing.T) {
	m := AppModel{state: stateStoryEscapeEnding}
	next, _ := m.Update(key(" "))
	m = next.(AppModel)
	if m.state != stateModeSelect {
		t.Errorf("экран концовки должен был вести в меню режимов, получено %v", m.state)
	}
}

func TestFreshStoryStartsOnboardingWithTicTacToeOnly(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.state = stateStoryDifficulty
	next, _ := m.Update(key("enter"))
	m = next.(AppModel)

	if m.state != stateStoryHub {
		t.Fatalf("ожидался прямой переход в хаб, получено %v", m.state)
	}
	if m.story.Onboarding != StoryOnboardingTicTacToeOnly {
		t.Fatalf("ожидался этап знакомства TicTacToeOnly, получено %v", m.story.Onboarding)
	}
	visible := m.storyVisibleGames()
	if len(visible) != 1 || visible[0] != StoryResTicTacToe {
		t.Fatalf("на этапе знакомства должны были быть видны только крестики-нолики, получено %v", visible)
	}

	view := m.View()
	if strings.Contains(view, "/10") || strings.Contains(view, "Сложность:") {
		t.Errorf("на этапе знакомства не должно быть чисел ресурсов или строки сложности, получено:\n%s", view)
	}
	if strings.Contains(view, T(storyGameDefs[StoryResCheckers].NameKey)) {
		t.Errorf("шашки не должны быть видны на самом первом этапе знакомства")
	}
}

func TestOnboardingShowsGameNameNotResourceName(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.state = stateStoryHub

	view := m.View()
	if !strings.Contains(view, T("game.tictactoe.name")) {
		t.Errorf("на этапе знакомства должно было показываться чистое название игры %q, получено:\n%s", T("game.tictactoe.name"), view)
	}
	if strings.Contains(view, T(storyResourceDefs[StoryResTicTacToe].NameKey)) {
		t.Errorf("на этапе знакомства не должно было показываться название ресурса (%q) — оно ещё ничего не значит для игрока, получено:\n%s", T(storyResourceDefs[StoryResTicTacToe].NameKey), view)
	}
}

func TestThreeTicTacToeWinsUnlockCheckers(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.state = stateStoryHub

	tm := NewTicTacToeModel(TicTacToeDifficultyEasy)
	tm.game.Phase = TicTacToePhaseOver
	tm.game.Result = &TicTacToeResult{Winner: tm.game.HumanMark}
	tm.backToMenu = true

	for i := 0; i < 3; i++ {
		resource := StoryResTicTacToe
		m.storyActiveResource = &resource
		m.activeGame = tm
		m.state = statePlaying
		next, _ := m.Update(key("q"))
		m = next.(AppModel)
	}

	if m.story.Onboarding != StoryOnboardingWithCheckers {
		t.Fatalf("после 3 побед ожидался переход на этап WithCheckers, получено %v", m.story.Onboarding)
	}
	if m.state != stateStoryHub {
		t.Fatalf("ожидался возврат в хаб (не приветствие) — знакомство ещё не завершено, получено %v", m.state)
	}
	visible := m.storyVisibleGames()
	if len(visible) != 2 {
		t.Fatalf("ожидалось 2 видимые игры (крестики-нолики + шашки), получено %v", visible)
	}
}

func TestOneCheckersWinCompletesOnboardingAndShowsWelcome(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.story.Onboarding = StoryOnboardingWithCheckers
	m.story.Resources[StoryResTicTacToe] = storyStartingAmount + StoryOnboardingTicTacToeWinsNeeded
	m.state = stateStoryHub

	cm := NewCheckersModel(0, ColorChoiceA)
	cm.game.Result = &CheckersResult{Winner: cm.human}
	cm.backToMenu = true

	resource := StoryResCheckers
	m.storyActiveResource = &resource
	m.activeGame = cm
	m.state = statePlaying
	next, _ := m.Update(key("q"))
	m = next.(AppModel)

	if m.story.Onboarding != StoryOnboardingDone {
		t.Fatalf("после победы в шашках знакомство должно было завершиться, получено %v", m.story.Onboarding)
	}
	if m.state != stateStoryWelcome {
		t.Fatalf("ровно в момент завершения знакомства ожидалось приветствие, получено %v", m.state)
	}

	next, _ = m.Update(key(" ")) // показать текст полностью (пропустить печать)
	m = next.(AppModel)
	next, _ = m.Update(key(" ")) // продолжить в хаб
	m = next.(AppModel)
	if m.state != stateStoryHub {
		t.Fatalf("после приветствия ожидался переход в полный хаб, получено %v", m.state)
	}
	view := m.View()
	if !strings.Contains(view, "Сложность:") {
		t.Errorf("после завершения знакомства хаб должен был показывать обычный вид со строкой сложности, получено:\n%s", view)
	}
	visible := m.storyVisibleGames()
	if len(visible) != len(storyHubOrder) {
		t.Errorf("после завершения знакомства должны были стать видны все игры, получено %d из %d", len(visible), len(storyHubOrder))
	}
}

func TestWelcomeScreenNeverShownAgainAfterOnboarding(t *testing.T) {
	withTempConfigDir(t)
	s := NewStoryModeState(StoryDifficultyEasy, time.Now())
	s.Onboarding = StoryOnboardingDone
	if err := SaveStoryModeState(s); err != nil {
		t.Fatalf("неожиданная ошибка сохранения: %v", err)
	}

	m := NewAppModel()
	next, _ := m.Update(key("enter")) // язык -> выбор режима
	m = next.(AppModel)
	next, _ = m.Update(key("down")) // курсор на "Режим истории"
	m = next.(AppModel)
	next, _ = m.Update(key("enter"))
	m = next.(AppModel)

	if m.state != stateStoryMorning {
		t.Fatalf("при завершённом знакомстве и существующем сохранении ожидалось ежедневное приветствие, получено %v", m.state)
	}
}

func TestStoryRevealPartialTextPreservesParagraphs(t *testing.T) {
	text := "Раз два три.\n\nЧетыре пять шесть семь."
	// первые 3 слова — только первый абзац целиком, второй ещё не начат
	got := storyRevealPartialText(text, 3)
	if got != "Раз два три." {
		t.Errorf("ожидался только первый абзац целиком, получено %q", got)
	}
	// 3+2=5 слов — первый абзац целиком плюс первые 2 слова второго
	got = storyRevealPartialText(text, 5)
	if got != "Раз два три.\n\nЧетыре пять" {
		t.Errorf("ожидался первый абзац целиком плюс частичный второй, получено %q", got)
	}
	// все слова — весь текст целиком, без изменений
	got = storyRevealPartialText(text, storyTotalWords(text))
	if got != text {
		t.Errorf("при показе всех слов текст должен был совпасть с оригиналом, получено %q, ожидалось %q", got, text)
	}
}

func TestStoryRevealPartialTextZeroWordsIsEmpty(t *testing.T) {
	if got := storyRevealPartialText("Раз два три", 0); got != "" {
		t.Errorf("при 0 слов ожидалась пустая строка, получено %q", got)
	}
}

func TestStoryWelcomeTicksRevealWordsGradually(t *testing.T) {
	withTempConfigDir(t)
	m := AppModel{state: stateStoryWelcome, storyWelcomeWordsShown: 0}
	total := storyTotalWords(T("story.welcome.text"))

	next, cmd := m.Update(storyWelcomeTickMsg{})
	m = next.(AppModel)
	if m.storyWelcomeWordsShown != 1 {
		t.Fatalf("после одного тика ожидалось показанное 1 слово, получено %d", m.storyWelcomeWordsShown)
	}
	if cmd == nil {
		t.Errorf("должен был запланироваться следующий тик — текст ещё не показан целиком (всего слов: %d)", total)
	}
}

func TestStoryWelcomeTicksStopAtTotalWords(t *testing.T) {
	m := AppModel{state: stateStoryWelcome}
	total := storyTotalWords(T("story.welcome.text"))
	m.storyWelcomeWordsShown = total - 1

	next, cmd := m.Update(storyWelcomeTickMsg{})
	m = next.(AppModel)
	if m.storyWelcomeWordsShown != total {
		t.Fatalf("ожидалось, что счётчик достигнет total=%d, получено %d", total, m.storyWelcomeWordsShown)
	}
	if cmd != nil {
		t.Errorf("после показа всего текста дальнейший тик планироваться не должен")
	}
}

func TestStoryWelcomeKeyPressSkipsTypingFirst(t *testing.T) {
	m := AppModel{state: stateStoryWelcome, storyWelcomeWordsShown: 2}
	total := storyTotalWords(T("story.welcome.text"))

	next, _ := m.Update(key(" "))
	m = next.(AppModel)
	if m.state != stateStoryWelcome {
		t.Fatalf("первое нажатие во время печати должно было остаться на экране приветствия, получено %v", m.state)
	}
	if m.storyWelcomeWordsShown != total {
		t.Errorf("первое нажатие должно было сразу показать весь текст, получено %d из %d слов", m.storyWelcomeWordsShown, total)
	}
}

func TestStoryWelcomeKeyPressContinuesWhenFullyShown(t *testing.T) {
	withTempConfigDir(t)
	total := storyTotalWords(T("story.welcome.text"))
	m := AppModel{state: stateStoryWelcome, storyWelcomeWordsShown: total, story: NewStoryModeState(StoryDifficultyEasy, time.Now())}

	next, _ := m.Update(key(" "))
	m = next.(AppModel)
	if m.state != stateStoryHub {
		t.Errorf("нажатие после полного показа текста должно было продолжить в хаб, получено %v", m.state)
	}
}

func TestStoryWelcomeViewShowsTypingHintWhileIncomplete(t *testing.T) {
	m := AppModel{state: stateStoryWelcome, storyWelcomeWordsShown: 1}
	view := m.viewStoryWelcome()
	if !strings.Contains(view, T("story.welcome.hint.typing")) {
		t.Errorf("во время печати должна была показываться подсказка 'показать сразу', получено:\n%s", view)
	}
}

func TestStoryWelcomeViewShowsContinueHintWhenComplete(t *testing.T) {
	total := storyTotalWords(T("story.welcome.text"))
	m := AppModel{state: stateStoryWelcome, storyWelcomeWordsShown: total}
	view := m.viewStoryWelcome()
	if !strings.Contains(view, T("story.welcome.hint")) || strings.Contains(view, T("story.welcome.hint.typing")) {
		t.Errorf("после полного показа текста должна была показываться обычная подсказка 'продолжить', получено:\n%s", view)
	}
}

func TestStoryHubShowsVitalsWhenOnboardingDone(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.story.Onboarding = StoryOnboardingDone
	m.story.Stress = 45
	m.story.Poisoning = 10
	m.story.ToxinLevel = 5
	m.state = stateStoryHub

	view := m.View()
	if !strings.Contains(view, "45") || !strings.Contains(view, "10") || !strings.Contains(view, "5") {
		t.Errorf("хаб должен был показывать значения стресса/отравления/токсина, получено:\n%s", view)
	}
}

func TestStoryHubHidesVitalsDuringOnboarding(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.state = stateStoryHub

	view := m.View()
	if strings.Contains(view, T("story.hub.difficulty_label")) {
		t.Errorf("на этапе знакомства показатели выживания не должны показываться")
	}
}

func TestStoryHubUKeyOpensUseItemScreen(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.story.Onboarding = StoryOnboardingDone
	m.state = stateStoryHub

	next, _ := m.Update(key("u"))
	m = next.(AppModel)
	if m.state != stateStoryUseItem {
		t.Fatalf("клавиша u должна была открыть экран использования, получено %v", m.state)
	}
}

func TestStoryHubUKeyDisabledDuringOnboarding(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.state = stateStoryHub

	next, _ := m.Update(key("u"))
	m = next.(AppModel)
	if m.state != stateStoryHub {
		t.Errorf("клавиша u не должна была работать на этапе знакомства, получено %v", m.state)
	}
}

func TestStoryUseItemSpendsResourceAndAppliesEffect(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.story.Stress = 40
	m.story.Resources[StoryResKlondike] = 5
	m.state = stateStoryUseItem

	next, _ := m.Update(key("1")) // антидепрессант — первый пункт
	m = next.(AppModel)
	if m.story.Stress != 20 {
		t.Errorf("ожидался стресс 20 после траты антидепрессанта, получено %d", m.story.Stress)
	}
	if m.story.Resources[StoryResKlondike] != 4 {
		t.Errorf("ожидалось списание 1 антидепрессанта, получено %d", m.story.Resources[StoryResKlondike])
	}
	if m.state != stateStoryUseItem {
		t.Errorf("после использования должны были остаться на этом же экране, получено %v", m.state)
	}
}

func TestStoryUseItemEscReturnsToHub(t *testing.T) {
	m := AppModel{state: stateStoryUseItem}
	next, _ := m.Update(key("esc"))
	m = next.(AppModel)
	if m.state != stateStoryHub {
		t.Errorf("esc на экране использования должен был вернуть в хаб, получено %v", m.state)
	}
}

func TestStoryGreetingForDaysMapping(t *testing.T) {
	cases := []struct {
		days int
		want storyGreetingKind
	}{
		{0, storyGreetingPlayingAgain},
		{1, storyGreetingWokeUp},
		{2, storyGreetingWorried},
		{5, storyGreetingWorried},
	}
	for _, c := range cases {
		if got := storyGreetingForDays(c.days); got != c.want {
			t.Errorf("для %d дней ожидалось %v, получено %v", c.days, c.want, got)
		}
	}
}

func TestRandomStoryPostGameFlavorReturnsValidKey(t *testing.T) {
	valid := make(map[string]bool)
	for _, k := range storyPostGameFlavorKeys {
		valid[k] = true
	}
	for i := 0; i < 30; i++ {
		got := randomStoryPostGameFlavor()
		if !valid[got] {
			t.Fatalf("randomStoryPostGameFlavor вернул неизвестный ключ %q", got)
		}
	}
}

func TestPostGameFlavorPoolHasTwelveDistinctPhrases(t *testing.T) {
	if len(storyPostGameFlavorKeys) != 12 {
		t.Fatalf("ожидалось 12 фраз в пуле, получено %d", len(storyPostGameFlavorKeys))
	}
	seen := make(map[string]bool)
	for _, k := range storyPostGameFlavorKeys {
		text := T(k)
		if text == "" || text == k {
			t.Errorf("ключ %q не имеет перевода", k)
		}
		if seen[text] {
			t.Errorf("повторяющийся текст фразы: %q", text)
		}
		seen[text] = true
	}
}

func TestPostGameFlavorShownAfterReturningFromGame(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.story.Onboarding = StoryOnboardingDone

	tm := NewTicTacToeModel(TicTacToeDifficultyEasy)
	tm.game.Phase = TicTacToePhaseOver
	loser := TicTacToeX
	if tm.game.HumanMark == TicTacToeX {
		loser = TicTacToeO
	}
	tm.game.Result = &TicTacToeResult{Winner: loser}
	tm.backToMenu = true

	resource := StoryResTicTacToe
	m.storyActiveResource = &resource
	m.activeGame = tm
	m.state = statePlaying
	next, _ := m.Update(key("q"))
	m = next.(AppModel)

	if m.storyPostGameFlavor == "" {
		t.Fatalf("после возврата из партии ожидалась выбранная фраза-наблюдение")
	}
	view := m.View()
	if !strings.Contains(view, T(m.storyPostGameFlavor)) {
		t.Errorf("хаб должен был показывать выбранную фразу, получено:\n%s", view)
	}
}

func TestStoryHubNKeyShowsResetConfirmation(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.story.Onboarding = StoryOnboardingDone
	m.state = stateStoryHub

	next, _ := m.Update(key("N"))
	m = next.(AppModel)
	if !m.storyConfirmingReset {
		t.Fatalf("клавиша N должна была включить режим подтверждения сброса")
	}
	view := m.View()
	if !strings.Contains(view, T("story.hub.reset_confirm")) {
		t.Errorf("ожидался текст подтверждения сброса, получено:\n%s", view)
	}
}

func TestStoryHubResetConfirmYDeletesSaveAndGoesToDifficulty(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyHard, time.Now())
	m.story.Resources[StoryResChess] = 50
	if err := SaveStoryModeState(m.story); err != nil {
		t.Fatalf("неожиданная ошибка сохранения: %v", err)
	}
	m.state = stateStoryHub
	m.storyConfirmingReset = true

	next, _ := m.Update(key("y"))
	m = next.(AppModel)
	if m.state != stateStoryDifficulty {
		t.Fatalf("после подтверждения ожидался переход на выбор сложности, получено %v", m.state)
	}
	if m.storyConfirmingReset {
		t.Errorf("режим подтверждения должен был сброситься")
	}
	if _, err := LoadStoryModeState(); err != ErrStoryModeNoSave {
		t.Errorf("сохранение должно было быть удалено, получено err=%v", err)
	}
}

func TestStoryHubResetConfirmNCancelsAndKeepsProgress(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.story.Resources[StoryResChess] = 77
	m.state = stateStoryHub
	m.storyConfirmingReset = true

	next, _ := m.Update(key("n"))
	m = next.(AppModel)
	if m.storyConfirmingReset {
		t.Errorf("отмена должна была выключить режим подтверждения")
	}
	if m.state != stateStoryHub {
		t.Errorf("после отмены ожидался возврат в хаб, получено %v", m.state)
	}
	if m.story.Resources[StoryResChess] != 77 {
		t.Errorf("прогресс не должен был пострадать при отмене, получено %d", m.story.Resources[StoryResChess])
	}
}

func TestStoryHubResetConfirmEscCancels(t *testing.T) {
	m := AppModel{state: stateStoryHub, storyConfirmingReset: true, story: NewStoryModeState(StoryDifficultyEasy, time.Now())}
	next, _ := m.Update(key("esc"))
	m = next.(AppModel)
	if m.storyConfirmingReset {
		t.Errorf("esc должен был отменить подтверждение сброса")
	}
}

func TestStoryHubResetAvailableDuringOnboarding(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now()) // по умолчанию этап знакомства
	m.state = stateStoryHub

	next, _ := m.Update(key("N"))
	m = next.(AppModel)
	if !m.storyConfirmingReset {
		t.Errorf("сброс должен быть доступен и во время знакомства, получено storyConfirmingReset=%v", m.storyConfirmingReset)
	}
}

func TestAdvanceStoryEventQueueOrdering(t *testing.T) {
	m := AppModel{story: NewStoryModeState(StoryDifficultyEasy, time.Now())}

	m.story.PendingNeurotoxinAlert = true
	m.story.PendingDoorKnockAlert = true
	if got := m.advanceStoryEventQueue(); got != stateStoryNeurotoxinAlert {
		t.Errorf("при обоих ожидающих событиях сначала должен был идти выброс, получено %v", got)
	}

	m.story.PendingNeurotoxinAlert = false
	if got := m.advanceStoryEventQueue(); got != stateStoryDoorKnockAlert {
		t.Errorf("после выброса должен был идти стук, получено %v", got)
	}

	m.story.PendingDoorKnockAlert = false
	if got := m.advanceStoryEventQueue(); got != stateStoryHub {
		t.Errorf("без ожидающих событий должен был идти хаб, получено %v", got)
	}
}

func TestNeurotoxinAlertDismissAdvancesToKnockThenHub(t *testing.T) {
	withTempConfigDir(t)
	m := AppModel{state: stateStoryNeurotoxinAlert, story: NewStoryModeState(StoryDifficultyEasy, time.Now())}
	m.story.PendingNeurotoxinAlert = true
	m.story.PendingDoorKnockAlert = true
	m.story.ToxinLevel = 45

	next, _ := m.Update(key(" "))
	m = next.(AppModel)
	if m.story.PendingNeurotoxinAlert {
		t.Errorf("после показа флаг выброса должен был сброситься")
	}
	if m.state != stateStoryDoorKnockAlert {
		t.Fatalf("ожидался переход к экрану стука в дверь, получено %v", m.state)
	}

	next, _ = m.Update(key(" "))
	m = next.(AppModel)
	if m.story.PendingDoorKnockAlert {
		t.Errorf("после показа флаг стука должен был сброситься")
	}
	if m.state != stateStoryHub {
		t.Errorf("после обоих уведомлений ожидался переход в хаб, получено %v", m.state)
	}
}

func TestNeurotoxinAlertViewShowsToxinLevel(t *testing.T) {
	m := AppModel{story: NewStoryModeState(StoryDifficultyEasy, time.Now())}
	m.story.ToxinLevel = 55
	view := m.viewStoryNeurotoxinAlert()
	if !strings.Contains(view, "55") {
		t.Errorf("экран выброса должен был показывать текущий уровень токсина, получено:\n%s", view)
	}
}

func TestDoorKnockAlertDismissGoesToHubWhenNothingElsePending(t *testing.T) {
	withTempConfigDir(t)
	m := AppModel{state: stateStoryDoorKnockAlert, story: NewStoryModeState(StoryDifficultyEasy, time.Now())}
	m.story.PendingDoorKnockAlert = true

	next, _ := m.Update(key(" "))
	m = next.(AppModel)
	if m.story.PendingDoorKnockAlert {
		t.Errorf("флаг стука должен был сброситься после показа")
	}
	if m.state != stateStoryHub {
		t.Errorf("ожидался переход в хаб, получено %v", m.state)
	}
}

// TestOnboardingCompletesInOneDayDespiteDailyGrantsLimit — регрессия:
// раньше суточный лимит начислений (StoryDailyGrantsLimit = 3)
// применялся и во время знакомства, а оно требует 4 начисления
// подряд (3 победы в крестики-нолики + 1 в шашки) — если сыграть всё
// это за один день, четвёртое начисление (победа в шашках) просто не
// проходило, и знакомство зависало навсегда на этапе "+ Шашки".
func TestOnboardingCompletesInOneDayDespiteDailyGrantsLimit(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.state = stateStoryHub

	ttt := NewTicTacToeModel(TicTacToeDifficultyEasy)
	ttt.game.Phase = TicTacToePhaseOver
	ttt.game.Result = &TicTacToeResult{Winner: ttt.game.HumanMark}
	ttt.backToMenu = true
	for i := 0; i < 3; i++ {
		resource := StoryResTicTacToe
		m.storyActiveResource = &resource
		m.activeGame = ttt
		m.state = statePlaying
		next, _ := m.Update(key("q"))
		m = next.(AppModel)
	}
	if m.story.Onboarding != StoryOnboardingWithCheckers {
		t.Fatalf("после 3 побед в крестики-нолики ожидался переход на этап WithCheckers, получено %v", m.story.Onboarding)
	}
	if m.story.DailyGrantsUsed[StoryResTicTacToe] != StoryDailyGrantsLimit {
		t.Fatalf("три победы должны были исчерпать суточный лимит именно крестиков-ноликов (%d), получено %d", StoryDailyGrantsLimit, m.story.DailyGrantsUsed[StoryResTicTacToe])
	}

	cm := NewCheckersModel(0, ColorChoiceA)
	cm.game.Result = &CheckersResult{Winner: cm.human}
	cm.backToMenu = true
	resource := StoryResCheckers
	m.storyActiveResource = &resource
	m.activeGame = cm
	m.state = statePlaying
	next, _ := m.Update(key("q"))
	m = next.(AppModel)

	if m.story.Onboarding != StoryOnboardingDone {
		t.Errorf("победа в шашках в тот же день должна была завершить знакомство несмотря на исчерпанный суточный лимит, получено %v", m.story.Onboarding)
	}
}

func TestCheatCodeArmsOnlyDuringActiveStoryGame(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.state = stateStoryHub // не во время партии

	next, _ := m.Update(key(":"))
	m = next.(AppModel)
	if m.cheatArmed {
		t.Errorf("двоеточие вне активной партии не должно было вооружить чит-код")
	}
}

func TestCheatCodeTripleSevenForcesWin(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.story.Onboarding = StoryOnboardingDone
	before := m.story.Resources[StoryResChess]

	resource := StoryResChess
	m.storyActiveResource = &resource
	m.activeGame = NewChessModel(0, ColorChoiceA) // партия и близко не завершена
	m.state = statePlaying

	next, _ := m.Update(key(":"))
	m = next.(AppModel)
	if !m.cheatArmed {
		t.Fatalf("двоеточие во время активной партии сторимода должно было вооружить чит-код")
	}

	for i := 0; i < 3; i++ {
		next, _ = m.Update(key("7"))
		m = next.(AppModel)
	}

	if m.cheatArmed {
		t.Errorf("после ввода 777 чит-код должен был сработать и разоружиться")
	}
	if m.state != stateStoryHub {
		t.Fatalf("после чит-кода ожидался возврат в хаб, получено %v", m.state)
	}
	if m.story.Resources[StoryResChess] != before+1 {
		t.Errorf("чит-код должен был засчитать победу в шахматах, получено %d (было %d)", m.story.Resources[StoryResChess], before)
	}
	if m.storyActiveResource != nil {
		t.Errorf("отметка активного ресурса должна была сброситься после чит-кода")
	}
}

func TestCheatCodeWrongDigitCancels(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	before := m.story.Resources[StoryResChess]

	resource := StoryResChess
	m.storyActiveResource = &resource
	m.activeGame = NewChessModel(0, ColorChoiceA)
	m.state = statePlaying

	next, _ := m.Update(key(":"))
	m = next.(AppModel)
	next, _ = m.Update(key("7"))
	m = next.(AppModel)
	next, _ = m.Update(key("8")) // не та цифра — отменяет попытку
	m = next.(AppModel)

	if m.cheatArmed {
		t.Errorf("неверная цифра должна была отменить вооружённый чит-код")
	}
	if m.story.Resources[StoryResChess] != before {
		t.Errorf("отменённая попытка не должна была засчитать победу, получено %d (было %d)", m.story.Resources[StoryResChess], before)
	}
}

func TestCheatCodeOnboardingAlsoAdvances(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.story.Onboarding = StoryOnboardingWithCheckers
	m.story.Resources[StoryResTicTacToe] = storyStartingAmount + StoryOnboardingTicTacToeWinsNeeded

	resource := StoryResCheckers
	m.storyActiveResource = &resource
	m.activeGame = NewCheckersModel(0, ColorChoiceA)
	m.state = statePlaying

	next, _ := m.Update(key(":"))
	m = next.(AppModel)
	for i := 0; i < 3; i++ {
		next, _ = m.Update(key("7"))
		m = next.(AppModel)
	}

	if m.story.Onboarding != StoryOnboardingDone {
		t.Errorf("чит-код тоже должен был продвинуть знакомство, получено %v", m.story.Onboarding)
	}
	if m.state != stateStoryWelcome {
		t.Errorf("завершение знакомства через чит-код тоже должно было показать приветствие, получено %v", m.state)
	}
}

func TestSurvivalEndingRequiresAllSevenSpecificResources(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.story.Onboarding = StoryOnboardingDone

	// запираем 7 ЛЮБЫХ ресурсов, но не тех самых семи — не должно сработать
	m.story.Locked[StoryResNardy] = true
	m.story.Locked[StoryResBlackjack] = true
	m.story.Locked[StoryResUr] = true
	m.story.Locked[StoryResSenet] = true
	m.story.Locked[StoryResOneOhOne] = true
	m.story.Locked[StoryResThousand] = true
	m.story.Locked[StoryResTicTacToe] = true
	if m.storySurvivalEndingUnlocked() {
		t.Fatalf("секретная концовка не должна была разблокироваться от произвольных 7 ресурсов")
	}

	// теперь запираем именно нужные семь
	for _, id := range storySurvivalResources {
		m.story.Locked[id] = true
	}
	if !m.storySurvivalEndingUnlocked() {
		t.Errorf("секретная концовка должна была разблокироваться при запертых Тонк/Шашки/Шахматы/Сапёр/Го/Дурак/Косынка")
	}
}

func TestSurvivalOptionAppearsInHubAndLeadsToAttemptScreen(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.story.Onboarding = StoryOnboardingDone
	for _, id := range storySurvivalResources {
		m.story.Locked[id] = true
	}
	m.state = stateStoryHub
	m.storyHubCursor = len(storyHubOrder) // единственный дополнительный пункт пока

	view := m.View()
	if !strings.Contains(view, T("story.hub.survival_option")) {
		t.Fatalf("пункт 'Выйти из бункера' должен был появиться в хабе")
	}

	next, _ := m.Update(key("enter"))
	m = next.(AppModel)
	if m.state != stateStorySurvivalAttempt {
		t.Fatalf("выбор пункта должен был вести на экран уговоров остаться, получено %v", m.state)
	}
}

func TestSurvivalAttemptStayingReturnsToHub(t *testing.T) {
	m := AppModel{state: stateStorySurvivalAttempt}
	next, _ := m.Update(key("1"))
	m = next.(AppModel)
	if m.state != stateStoryHub {
		t.Errorf("выбор 'остаться' должен был вернуть в хаб, получено %v", m.state)
	}
}

func TestSurvivalAttemptLeavingGoesToEnding(t *testing.T) {
	m := AppModel{state: stateStorySurvivalAttempt}
	next, _ := m.Update(key("2"))
	m = next.(AppModel)
	if m.state != stateStoryEscapeEnding {
		t.Errorf("выбор 'выйти' должен был вести на экран концовки, получено %v", m.state)
	}
}

func TestBothSecretEndingsCanAppearTogether(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.story.Onboarding = StoryOnboardingDone
	for _, id := range storySurvivalResources {
		m.story.Locked[id] = true
	}
	m.story.Resources[StoryResTicTacToe] = 50
	m.story.Resources[StoryResSenet] = 50
	m.story.Stress = 60
	m.state = stateStoryHub

	extras := m.storyExtraHubItems()
	if len(extras) != 2 {
		t.Fatalf("ожидалось 2 дополнительных пункта одновременно, получено %d", len(extras))
	}
	if extras[0].State != stateStorySurvivalAttempt {
		t.Errorf("первым должен был идти пункт выживания, получено %v", extras[0].State)
	}
	if extras[1].State != stateStoryEscapeAttempt {
		t.Errorf("вторым должен был идти пункт побега от отчаяния, получено %v", extras[1].State)
	}

	// второй пункт (побег) должен быть доступен по курсору len(visible)+1
	m.storyHubCursor = len(storyHubOrder) + 1
	next, _ := m.Update(key("enter"))
	m = next.(AppModel)
	if m.state != stateStoryEscapeAttempt {
		t.Errorf("второй по счёту дополнительный пункт должен был вести на экран побега, получено %v", m.state)
	}
}

func TestAllFifteenLockedTriggersTrueEnding(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	m.story.Onboarding = StoryOnboardingDone
	// запираем 14 из 15 заранее — победа в оставшейся должна замкнуть круг
	for i := 0; i < int(storyResourceCount); i++ {
		if StoryResourceID(i) != StoryResChess {
			m.story.Locked[i] = true
		}
	}
	m.story.Resources[StoryResChess] = StoryTargetChess - 1

	tm := NewChessModel(0, ColorChoiceA)
	tm.game.Result = &ChessResult{Winner: tm.human}
	tm.backToMenu = true
	resource := StoryResChess
	m.storyActiveResource = &resource
	m.activeGame = tm
	m.state = statePlaying

	next, _ := m.Update(key("q"))
	m = next.(AppModel)
	if m.state != stateStoryTrueEnding {
		t.Fatalf("после запирания последнего, 15-го ресурса ожидалась истинная концовка, получено %v", m.state)
	}
}

func TestTrueEndingDeletesSaveAndReturnsToModeSelect(t *testing.T) {
	withTempConfigDir(t)
	s := NewStoryModeState(StoryDifficultyEasy, time.Now())
	if err := SaveStoryModeState(s); err != nil {
		t.Fatalf("неожиданная ошибка сохранения: %v", err)
	}
	m := AppModel{state: stateStoryTrueEnding, story: s}

	next, _ := m.Update(key(" "))
	m = next.(AppModel)
	if m.state != stateModeSelect {
		t.Errorf("после истинной концовки ожидался переход в меню режимов, получено %v", m.state)
	}
	if _, err := LoadStoryModeState(); err != ErrStoryModeNoSave {
		t.Errorf("сохранение должно было быть удалено после истинной концовки, получено err=%v", err)
	}
}

func TestEscapeEndingAlsoDeletesSave(t *testing.T) {
	withTempConfigDir(t)
	s := NewStoryModeState(StoryDifficultyEasy, time.Now())
	if err := SaveStoryModeState(s); err != nil {
		t.Fatalf("неожиданная ошибка сохранения: %v", err)
	}
	m := AppModel{state: stateStoryEscapeEnding, story: s}

	next, _ := m.Update(key(" "))
	m = next.(AppModel)
	if m.state != stateModeSelect {
		t.Errorf("ожидался переход в меню режимов, получено %v", m.state)
	}
	if _, err := LoadStoryModeState(); err != ErrStoryModeNoSave {
		t.Errorf("сохранение должно было быть удалено (общий экран для обеих концовок 'выйти'), получено err=%v", err)
	}
}

func TestModeSelectStartsFreshAfterAnyEnding(t *testing.T) {
	withTempConfigDir(t)
	// симулируем, что концовка уже случилась и сохранение удалено
	_ = DeleteStoryModeSave()

	m := NewAppModel()
	next, _ := m.Update(key("enter")) // язык -> выбор режима
	m = next.(AppModel)
	next, _ = m.Update(key("down")) // курсор на "Режим истории"
	m = next.(AppModel)
	next, _ = m.Update(key("enter"))
	m = next.(AppModel)

	if m.state != stateStoryDifficulty {
		t.Errorf("после любой концовки следующий заход должен был начинаться с выбора сложности заново, получено %v", m.state)
	}
}

func TestEnterStoryHubFromModeSelectRedirectsIfAlreadyComplete(t *testing.T) {
	withTempConfigDir(t)
	m := NewAppModel()
	m.story = NewStoryModeState(StoryDifficultyEasy, time.Now())
	for i := range m.story.Locked {
		m.story.Locked[i] = true
	}

	m = m.enterStoryHubFromModeSelect()
	if m.state != stateStoryTrueEnding {
		t.Errorf("уже полностью собранное сохранение должно было сразу вести на истинную концовку, получено %v", m.state)
	}
}

// TestStoryHubHintWrapsInsteadOfOverflowing — регрессия: длинная
// подсказка хаба (7 разных клавиш) раньше выводилась без переноса и
// просто обрезалась терминалом на узком экране вместо переноса на
// следующую строку.
func TestStoryHubHintWrapsInsteadOfOverflowing(t *testing.T) {
	withTempConfigDir(t)
	m := AppModel{story: NewStoryModeState(StoryDifficultyEasy, time.Now()), termWidth: 60}
	m.story.Onboarding = StoryOnboardingDone
	m.state = stateStoryHub

	view := m.View()
	for _, line := range strings.Split(view, "\n") {
		plain := stripANSI(line)
		if w := len([]rune(plain)); w > 60 {
			t.Errorf("строка шириной %d превышает ширину терминала 60: %q", w, plain)
		}
	}
}