namespace LivingVillage.Desktop.Tests

open Microsoft.VisualStudio.TestTools.UnitTesting
open LivingVillage.Kernel
open LivingVillage.Desktop

[<TestClass>]
type M6bMenuTests () =

    [<TestMethod>]
    member _.MainMenuHasRequiredOrderAndStartsAtNewGame () =
        let state = MenuState.create SimulationControl.initial false

        Assert.AreEqual<MenuPage>(MainMenu, state.Page)
        Assert.AreEqual<MenuItem list>(
            [ NewGameItem; LoadItem; ExitItem ],
            MenuState.items state)
        Assert.AreEqual<string list>([ "开始"; "读档"; "退出" ], MenuState.items state |> List.map MenuState.itemLabel)
        Assert.AreEqual<int>(0, state.Selected)

    [<TestMethod>]
    member _.SelectionWrapsAndConfirmProducesNewGameCommand () =
        let state = MenuState.create SimulationControl.initial false
        let wrapped = MenuState.move Up state
        let confirmed = MenuState.update Confirm wrapped |> snd

        Assert.AreEqual<MenuItem>(ExitItem, MenuState.selectedItem wrapped)
        Assert.AreEqual<MenuCommand>(ExitGame, confirmed)
        let newGameState, newGameCommand = MenuState.update Confirm state
        Assert.AreEqual<MenuPage>(MainMenu, newGameState.Page)
        Assert.AreEqual<MenuCommand>(StartNewGame, newGameCommand)

    [<TestMethod>]
    member _.SettingsCanSelectEveryExistingSimulationMode () =
        let initial = MenuState.create SimulationControl.initial false
        let settings = MenuState.openSettings initial
        let oneX, oneXCommand = MenuState.update Confirm settings
        let twoX, twoXCommand = MenuState.update Confirm (MenuState.move Down settings)
        let fiveX, fiveXCommand = MenuState.update Confirm (MenuState.move Down (MenuState.move Down settings))
        let paused, pausedCommand = MenuState.update Confirm (MenuState.move Down (MenuState.move Down (MenuState.move Down settings)))

        Assert.AreEqual<MenuPage>(Settings, settings.Page)
        Assert.AreEqual<MenuCommand>(ApplySettings { Paused = false; Speed = OneX }, oneXCommand)
        Assert.AreEqual<MenuCommand>(ApplySettings { Paused = false; Speed = TwoX }, twoXCommand)
        Assert.AreEqual<MenuCommand>(ApplySettings { Paused = false; Speed = FiveX }, fiveXCommand)
        Assert.AreEqual<MenuCommand>(ApplySettings { Paused = true; Speed = OneX }, pausedCommand)
        Assert.AreEqual<MenuPage>(Settings, oneX.Page)

    [<TestMethod>]
    member _.EscapeReturnsToPreviousPageAndKeepsCurrentWorld () =
        let playing = MenuState.create SimulationControl.initial true |> MenuState.enterGame
        let settings = MenuState.openSettings playing
        let returned, command = MenuState.update Back settings
        let main = MenuState.openMain playing
        let continued, continueCommand = MenuState.update Confirm main

        Assert.AreEqual<MenuPage>(Playing, returned.Page)
        Assert.AreEqual<MenuCommand>(NoCommand, command)
        Assert.IsTrue(returned.HasCurrentWorld)
        Assert.AreEqual<MenuPage>(MainMenu, main.Page)
        Assert.AreEqual<MenuItem>(ContinueItem, MenuState.selectedItem main)
        Assert.AreEqual<MenuPage>(Playing, continued.Page)
        Assert.AreEqual<MenuCommand>(ContinueGame, continueCommand)

    [<TestMethod>]
    member _.ControlsPageExposesCompleteKeyboardBindings () =
        let state = MenuState.openControls (MenuState.create SimulationControl.initial false)
        let keys = MenuState.controlRows |> List.map (fun row -> row.Keys)

        Assert.AreEqual<MenuPage>(Controls, state.Page)
        Assert.AreEqual<string list>(
            [ "WASD"; "E"; "1-6"; "Q"; "TAB"; "C"; "L"; "P"; "F1/F2/F3"; "F6"; "F7"; "ESC"; "UP/DOWN"; "ENTER" ],
            keys)

    [<TestMethod>]
    member _.LoadFailureIsAnExplicitPageAndBackReturnsToMenu () =
        let failed = MenuState.showLoadError "missing save" (MenuState.create SimulationControl.initial false)
        let returned, command = MenuState.update Back failed

        Assert.AreEqual<MenuPage>(LoadError, failed.Page)
        Assert.AreEqual<string option>(Some "missing save", failed.Error)
        Assert.AreEqual<MenuPage>(MainMenu, returned.Page)
        Assert.AreEqual<MenuCommand>(NoCommand, command)

    // ---- P15 开局职业选择页 ----

    [<TestMethod>]
    member _.OccupationSelectOffersFourKindsThenNoneAndDefaultsToNone () =
        let page = MenuState.openOccupationSelect (MenuState.create SimulationControl.initial false)

        Assert.AreEqual<MenuPage>(OccupationSelect, page.Page)
        Assert.AreEqual<Occupation.Kind option list>(
            [ Some Occupation.Farmer; Some Occupation.Fisher; Some Occupation.Peddler; Some Occupation.Scholar; None ],
            MenuState.occupationOptions)
        Assert.AreEqual<Occupation.Kind option>(None, MenuState.selectedOccupation page)
        Assert.AreEqual<string>("暂不选择", MenuState.occupationLabel None)
        Assert.AreEqual<string>("农夫", MenuState.occupationLabel (Some Occupation.Farmer))
        Assert.AreEqual<string>("书生", MenuState.occupationLabel (Some Occupation.Scholar))

    [<TestMethod>]
    member _.OccupationSelectConfirmEmitsChosenKindAndBackReturnsToMenu () =
        let page = MenuState.openOccupationSelect (MenuState.create SimulationControl.initial false)
        let _, defaultCommand = MenuState.update Confirm page
        Assert.AreEqual<MenuCommand>(StartNewGameWith None, defaultCommand)

        let picked = MenuState.move Up (MenuState.move Up page)
        Assert.AreEqual<Occupation.Kind option>(Some Occupation.Peddler, MenuState.selectedOccupation picked)
        let _, command = MenuState.update Confirm picked
        Assert.AreEqual<MenuCommand>(StartNewGameWith (Some Occupation.Peddler), command)

        let back, backCommand = MenuState.update Back page
        Assert.AreEqual<MenuPage>(MainMenu, back.Page)
        Assert.AreEqual<MenuCommand>(NoCommand, backCommand)