Rules.ttslua

local Archive = require("Kdm/Archive")
local Check = require("Kdm/Util/Check")
local CircularArray = require("Kdm/Util/CircularArray")
local Expansion = require("Kdm/Expansion")
local Location = require("Kdm/Location")
local log = require("Kdm/Log").ForModule("Rules")
local NamedObject = require("Kdm/NamedObject")
local Trie = require("Kdm/Util/Trie")
local Ui = require("Kdm/Ui")
local Util = require("Kdm/Util/Util")

---------------------------------------------------------------------------------------------------

local Rules = {}

---------------------------------------------------------------------------------------------------

function Rules.Init()
    Rules.trie = Trie()
    Rules.history = CircularArray(100)
    Rules.index = {}
    Rules.searchResultButtons = {}

    for _, expansion in ipairs(Expansion.All()) do
        Rules.RegisterExpansion(expansion)
    end

    local rules = Rules.GetCurrentRules()
    if rules != nil then
        local currentState = rules.getStateId()
        local rulebookName = nil
        if currentState == 1 then
            rulebookName = rules.getName()
        else
            for _, state in ipairs(rules.getStates()) do
                if state.id == 1 then
                    rulebookName = state.name
                end
            end
        end
        assert(Check(rulebookName, "No rules page with state 1 in %s (%s)", rules.getName(), rules.getGUID()))
        Rules.history:Push({ rulebookName, currentState})
    end

    -----------------------------------------------------------------------------------------------

    local xStart = 70+100+10+30+10
    local yStart = -10
    local ui = Ui.Get2d()
    local colors = "#ffffff|#dddddd|#dddddd|#ffffff"
    Rules.searchInput = ui:Input({ id = "RulesSearch", x = xStart, y = yStart, width = 240, height = 30, placeholder = "search rules/events...", workaroundNilColors = true, textColor = "#000000", colors = colors, textOffset = "5 5 0 0", fontSize = 16, onValueChanged = function(value)
        Rules.SetSearchResults(Rules.Search(value))
    end })
    ui:Button({ id = "RulesCancelSearch", x = xStart+240+5, y = yStart, width = 30, height = 30, text = "X", textAlignment = "MiddleCenter", textColor = "#000000", colors = colors, fontSize = 20, onClick = function()
        Rules.SetSearchResults({})
        Rules.searchInput:SetText(nil)
    end })
    Rules.searchResultsPanel = ui:Panel({ id = "RulesSearchResults", x = xStart, y = yStart - 40, width = 300, height = 160, color = "#00000088", active = false })

    Rules.searchResultButtons = {}
    for i = 1, 5 do
        Rules.searchResultButtons[i] = Rules.searchResultsPanel:Button({ id = "Result"..i, x = 5, y = -5 + (i - 1) * -30, width = 280, height = 30, fontSize = 16, colors = Ui.INVISIBLE_COLORS, textColor = "#dddddd" })
    end

    -----------------------------------------------------------------------------------------------

    local ui = Ui.Create3d("RulesNav", NamedObject.Get("Rules Navigation Board"), 0.11)

    local x1 = 7.762758
    local x1End = 6.705129
    local width = x1End - x1
    local x13 = -6.702875
    local dx = (x13 - x1) / 12

    local y1 = -0.401185
    local y1End = 0.047924
    local height = y1End - y1
    local y2 = 0.392804
    local dy = y2 - y1

    local createButton = function(name, col, row, onClick)
        local topLeft = { x =  x1 + ((col - 1) * dx), y = y1 + ((row - 1) * dy) }
        local bottomRight = { x = topLeft.x + width, y = topLeft.y + height }
        ui:Button({ id = name, topLeft = topLeft, bottomRight = bottomRight, onClick = onClick })
    end

    local buttons = {
        { "Core Rules", 1, 1 },
        { "Dragon King Rules", 2, 1 },
        { "Dung Beetle Knight Rules", 3, 1 },
        { "Flower Knight Rules", 4, 1 },
        { "Gorm Rules", 5, 1 },
        { "Lion God Rules", 6, 1 },
        { "Lion Knight Rules", 7, 1 },
        { "Lonely Tree Rules", 8, 1 },
        { "Manhunter Rules", 9, 1 },
        { "Slenderman Rules", 10, 1 },
        { "Spidicules Rules", 11, 1 },
        { "Sunstalker Rules", 12, 1 },
        { "White Gigalion Rules", 13, 1 },
    }
    for _, button in ipairs(buttons) do
        createButton(button[1], button[2], button[3], function() Rules.SpawnRules(button[1], 1) end)
    end

    createButton("Back", 6, 2, Rules.Back)
    createButton("Previous Page", 7, 2, function() Rules.ChangePage(-1) end )
    createButton("Next Page", 8, 2, function() Rules.ChangePage(1) end)

    ui:ApplyToObject()
end


---------------------------------------------------------------------------------------------------

function Rules.RegisterExpansion(expansion)
    for rulebookIndex, rulebook in ipairs(expansion.rulebooks or {}) do
        local rulebookName = rulebook.name
        assert(Check.Str(rulebookName, "rulebook.name"))

        local pages = rulebook.pages
        assert(Check.Table(rulebook.pages))

        for pageName, pageData in pairs(pages) do
            assert(Check.Str(pageName, "rulebooks[%s].pages[pageName]", rulebookName))
            local state = pageData.state
            assert(Check.Num(state, "rulebooks[%s].pages[%s].state", rulebookName, pageName))

            assert(Check(Rules.index[pageName] == nil, "Rulebook page %s is already registered to %s", pageName, Rules.index[pageName]))
            Rules.index[pageName] = { rulebook = rulebookName, state = state }

            local keywords = pageData.keywords
            assert(Check.Table(keywords, "rulebooks[%s].pages[%s].keywords", rulebookName, pageName))

            local entry = {
                rulebook = rulebookName,
                name = pageName,
                state = state,
                timelineEvent = pageData.timelineEvent,
                showdown = pageData.showdown,
            }

            for keywordIndex, keyword in ipairs(keywords) do
                assert(Check.Str(keyword, "rulebooks[%s].pages[%s].keywords[%d]", rulebookName, pageName, keywordIndex))
                Rules.trie:Set(keyword, entry)
            end

            if pageData.huntEventStart then
                local huntEventStart = pageData.huntEventStart
                assert(Check.Num(huntEventStart, "rulebooks[%s].pages[%s].huntEventStart", rulebookName, pageName, keywordIndex))

                local huntEventEnd = pageData.huntEventEnd
                assert(Check.Num(huntEventEnd, "rulebooks[%s].pages[%s].huntEventEnd", rulebookName, pageName, keywordIndex))

                for huntEventNumber = huntEventStart, huntEventEnd do
                    Rules.trie:Set(tostring(huntEventNumber), entry)
                end
            end
        end
    end
end

---------------------------------------------------------------------------------------------------

function Rules.RulebookAndState(name)
    local data = Rules.index[name]
    assert(Check(data, "Unknown rule: %s", name))
    return data.rulebook, data.state
end

---------------------------------------------------------------------------------------------------

function Rules.Search(searchTerms)
    if searchTerms == nil or searchTerms == "" then
        return {}
    end

    -- only accept results that match all terms
    local matchIndex = {}
    local i = 1
    for term in string.gmatch(searchTerms, "%S+") do
        local termMatches = Rules.trie:Get(term)
        local termIndex = Util.Index(termMatches, "name")

        matchIndex = (i == 1) and termIndex or Util.Intersect(matchIndex, termIndex)
        i = i + 1
    end

    -- sort matches
    local sortedMatches = {}
    for _, m in pairs(matchIndex) do
        table.insert(sortedMatches, m)
    end
    table.sort(sortedMatches, function(x, y) return x.name < y.name end)

    return sortedMatches
end

---------------------------------------------------------------------------------------------------

function Rules.SetSearchResults(results)
    if #results == 0 then
        Rules.searchResultsPanel:Hide()
        return
    end

    Rules.searchResultsPanel:Show()
    local numResults = Util.Min(5, #results)
    Rules.searchResultsPanel:SetHeight(10 + (numResults * 30))

    for i = 1, numResults do
        local result = results[i]
        local button = Rules.searchResultButtons[i]
        button:Show()
        button:SetOnClick(function()
            Rules.searchInput:SetText(nil)
            Rules.SetSearchResults({})
            Rules.SpawnRules(result.rulebook, result.state)
            --Location.Get("Rules Board"):LookAt({ pitch = 90 })
        end)
        button:SetText(result.name)
    end

    for i = numResults + 1, 5 do
        local button = Rules.searchResultButtons[i]
        button:Hide()
        button:SetOnClick(nil)
        button:SetText(nil)
    end
end

---------------------------------------------------------------------------------------------------

function Rules.SpawnRules(rules, state, dontRecordHistory)
    assert(Check.Str(rules))
    assert(Check.Num(state))
    assert(Check.BooleanOrNil(dontRecordHistory))

    log:Debugf("Spawning rules %s[%d]", rules, state)

    local location = Location.Get("Rules Board")
    local blocking = location:BoxClean({ types = { "Rulebook" } })
    if #blocking > 0 then
        log:Broadcastf("Something is blocking the rules board. Please move the highlighted objects out of the way and try again.")
        Util.HighlightAll(blocking)
        return
    end

    if not Archive.Take({
        name = rules,
        type = "Rulebook",
        location = location,
        spawnFunc = function(obj)
            if state > 1 then
                obj = obj.setState(state)
            end
            Wait.frames(function() obj.setLock(true) end, 3)
        end,
    }) then
        log:Errorf("Unrecognized rules: %s[%d]", rules, state)
    end
    Archive.Clean()

    if not dontRecordHistory then
        Rules.history:Push({ rules, state })
    end
end

---------------------------------------------------------------------------------------------------

function Rules.GetCurrentRules()
    return Location.Get("Rules Board"):FirstObject({ types = { "Rulebook" } })
end

---------------------------------------------------------------------------------------------------

function Rules.Back()
    local rules = Rules.GetCurrentRules()
    if not rules then
        return
    end

    if Rules.history:Size() <= 1 then
        log:Debugf("<= 1 history element, can't go back")
        return
    end

    Rules.history:Pop()
    local last = Rules.history:Top()
    log:Debugf("Going back to %s[%d]", last[1], last[2])
    Rules.SpawnRules(last[1], last[2], true)   -- dontRecordHistory
end

---------------------------------------------------------------------------------------------------

function Rules.ChangePage(dir)
    local rules = Rules.GetCurrentRules()
    if not rules then
        log:Debugf("No rules to change")
        return
    end

    local currentState = rules.getStateId()
    local nextState = currentState + dir
    log:Debugf("Found current rules %s (%s) at state %d, looking for state %d", rules.getName(), rules.getGUID(), currentState, nextState)

    local rulebookName = (currentState == 1) and rules.getName() or nil
    local hasNext = false
     for _, state in ipairs(rules.getStates()) do
        if state.id == 1 then
            rulebookName = state.name
        end
        if state.id == nextState then
            log:Debugf("Found next state %d: %s", state.id, state.name)
            hasNext = true
        end
    end

    if not hasNext then
        log:Debugf("No state %d", nextState)
        return
    end

    assert(Check(rulebookName, "No rulebook name (page with state 1) in %s (%s)", rules.getName(), rules.getGUID()))

    Rules.history:Push({ rulebookName, nextState })
    local finalObj = rules.setState(nextState)
    Wait.frames(function() finalObj.setLock(true) end, 3)
end

---------------------------------------------------------------------------------------------------

return {
    Init = Rules.Init,
    RulebookAndState = Rules.RulebookAndState,
    Search = Rules.Search,
    SpawnRules = Rules.SpawnRules,
}