--[[--
Main menu mixin for the BookOrbit plugin.

KOReader's side of BookOrbit: an icon in KOReader's top menu bar that opens
BookOrbit in one tap (in a book, the This book sheet), a trimmed Tools entry
for anyone who turns the icon off, and the openers for BookOrbit's own menu
sheet, settings, sync status and sign-in pages. Those pages load on first
use. Installed onto the plugin controller as regular methods.
]]

local Device = require("device")
local InfoMessage = require("ui/widget/infomessage")
local NetworkMgr = require("ui/network/manager")
local UIManager = require("ui/uimanager")
local md5 = require("ffi/sha2").md5
local T = require("ffi/util").template
local _ = require("gettext")

local BookOrbitApi = require("bookorbit_api")
local BookOrbitHighlightDiagnostics = require("bookorbit_highlight_diagnostics")
local BookOrbitSweep = require("bookorbit_sweep")
local BoardStore = require("bookorbit_board_store")

local MainMenu = {}

local function formatBool(value)
    return value and _("On") or _("Off")
end

local function formatTime(ts)
    ts = tonumber(ts)
    if not ts or ts <= 0 then return _("never") end
    return os.date("%Y-%m-%d %H:%M", ts)
end

local function formatShortTime(ts)
    ts = tonumber(ts)
    if not ts or ts <= 0 then return _("never") end
    return os.date("%H:%M", ts)
end

local function deviceIdPrefix(device_id)
    if type(device_id) ~= "string" or device_id == "" then return _("unknown") end
    return device_id:sub(1, 8)
end

local function versionText(version)
    if type(version) ~= "string" or version == "" then return _("unknown") end
    return "v" .. version:gsub("^v", "")
end

local function recordText(entry)
    if type(entry) ~= "table" then return _("none") end
    local when = formatTime(entry.at)
    local message = entry.message or entry.event or _("unknown")
    return T(_("%1 at %2"), tostring(message), when)
end

local function highlightRecordText(entry)
    return BookOrbitHighlightDiagnostics.lastSyncText(entry, formatShortTime)
end

local function jobText(job)
    if type(job) ~= "table" then return _("none") end
    return tostring(job.label or job.family or _("unknown"))
end

local function jobStartedText(job)
    if type(job) ~= "table" then return _("none") end
    return formatTime(job.started_at)
end

local function safeDocumentDigest(plugin, has_open_book)
    if not has_open_book or not plugin.getDocumentDigest then return nil end
    local ok, digest = pcall(plugin.getDocumentDigest, plugin)
    if ok then return digest end
end

local function hasReaderBook(plugin)
    return plugin.ui and plugin.ui.document ~= nil
end

local function hasCredentials(settings)
    return settings.server_url ~= nil and settings.username ~= nil and settings.userkey ~= nil
end

-- What the sync knows, in sections for the Technical details page. Each
-- section: title and rows ({ label, value }); actions: { kind, label, icon }.
function MainMenu:diagnosticsSections()
    local status = BookOrbitSweep.syncStatus()
    local sync_status = self.getSyncCoordinatorStatus and self:getSyncCoordinatorStatus() or { pending_count = 0 }
    local outbox_status = self.getLifecycleOutboxStatus and self:getLifecycleOutboxStatus()
        or { count = 0, bytes = 0, blocked = 0 }
    local has_open_book = hasReaderBook(self)
    local digest = safeDocumentDigest(self, has_open_book)
    local scheduler = self.open_annotation_scheduler and self.open_annotation_scheduler:status() or nil
    local logged_in = self:isLoggedIn()
    local DeviceNames = require("bookorbit_device_names")
    local model = Device.model
    local device_name = DeviceNames.label(model) or _("unknown")
    if model and device_name ~= model then device_name = T(_("%1 (%2)"), device_name, model) end

    local sections = {
        { title = _("This device"), rows = {
            { _("Device"), device_name },
            { _("Device ID"), deviceIdPrefix(self.device_id) },
            { _("Plugin"), versionText(self.PLUGIN_VERSION) },
            { _("Latest plugin"), versionText(self.settings.update_latest_version) },
        } },
        { title = _("Account"), rows = {
            { _("Server"), self.settings.server_url or _("not set") },
            { _("Username"), self.settings.username or _("not set") },
            { _("Login"), logged_in and _("configured") or _("not configured") },
        } },
    }
    local actions = {}

    if not logged_in then
        if self.settings.last_error then
            table.insert(sections, { title = _("Last results"), rows = { { _("Last error"), recordText(self.settings.last_error) } } })
        end
        if hasCredentials(self.settings) then
            table.insert(actions, { kind = "test", label = _("Test connection"), icon = "wifi" })
        end
        return { sections = sections, actions = actions }
    end

    -- Short sections first, so the first page is full.
    table.insert(sections, { title = _("Last results"), rows = {
        { _("Last sync"), recordText(self.settings.last_sync) },
        { _("Last error"), recordText(self.settings.last_error) },
    } })

    table.insert(sections, { title = _("Library"), rows = {
        { _("Last sweep"), formatTime(status.lastSweepAt) },
        { _("Matched local books"), tostring(status.matched or 0) },
        { _("Unmatched local books"), tostring(status.unmatched or 0) },
    } })
    table.insert(sections, { title = _("Sync"), rows = {
        { _("Auto sync"), formatBool(self.settings.auto_sync) },
        { _("Two-way highlights & bookmarks"), formatBool(self.settings.annotation_sync) },
        { _("Skip offline auto-sync"), formatBool(self.settings.skip_sync_when_offline) },
        { _("Current sync"), jobText(sync_status.current) },
        { _("Current sync started"), jobStartedText(sync_status.current) },
        { _("Next sync"), jobText(sync_status.next) },
        { _("Pending syncs"), tostring(sync_status.pending_count or 0) },
        { _("Pending lifecycle syncs"), tostring(outbox_status.count or 0) },
        { _("Parked lifecycle syncs"), tostring(outbox_status.blocked or 0) },
        { _("Lifecycle sync storage"), tostring(outbox_status.bytes or 0) .. " B" },
    } })
    table.insert(sections, { title = _("Highlights"), rows = {
        { _("Open highlights"), BookOrbitHighlightDiagnostics.openHighlightsText{
            annotation_sync = self.settings.annotation_sync,
            has_open_book = has_open_book,
            matched = self.isOpenBookMatched and self:isOpenBookMatched(digest) or false,
            position_incompatible = self.isOpenBookPositionIncompatible and self:isOpenBookPositionIncompatible(digest) or false,
            scheduler_status = scheduler,
            last_highlight_sync = self.settings.last_highlight_sync,
        } },
        { _("Highlight apply retry"), BookOrbitHighlightDiagnostics.retryText(self.open_highlight_retry_status) },
        { _("Last highlight sync"), highlightRecordText(self.settings.last_highlight_sync) },
        { _("Last bookmark sync"), BookOrbitHighlightDiagnostics.lastBookmarkSyncText(self.settings.last_highlight_sync, formatShortTime) },
    } })
    if has_open_book then
        if self.settings.annotation_sync then
            table.insert(actions, { kind = "retry-highlights", label = _("Retry highlight sync"), icon = "highlighter" })
        end
        table.insert(actions, { kind = "retry-match", label = _("Retry open-book match"), icon = "book-open" })
    end
    table.insert(actions, { kind = "recheck", label = _("Recheck all book matches"), icon = "refresh-cw" })
    table.insert(actions, { kind = "test", label = _("Test connection"), icon = "wifi" })
    table.insert(actions, { kind = "check-update", label = _("Check for update"), icon = "download" })
    return { sections = sections, actions = actions }
end

-- The same as one flat list: rows, separators between sections and the
-- actions as rows that run them.
function MainMenu:diagnosticsRows()
    local d = self:diagnosticsSections()
    local rows = {}
    for index, section in ipairs(d.sections) do
        if index > 1 then table.insert(rows, "----------------------------") end
        for _i, row in ipairs(section.rows) do table.insert(rows, row) end
    end
    if #d.actions > 0 then table.insert(rows, "----------------------------") end
    local run = {
        test = function() self:testConnection() end,
        ["check-update"] = function() self:checkForUpdate() end,
        recheck = function() self:startMatchRecheck() end,
        ["retry-highlights"] = function() self:retryOpenHighlightSync() end,
        ["retry-match"] = function() self:retryOpenBookMatch() end,
    }
    for _i, a in ipairs(d.actions) do
        table.insert(rows, { a.label, _("Run"), callback = run[a.kind] })
    end
    return rows
end

function MainMenu:showDiagnostics()
    return require("bookorbit_diagnostics_page").open(self)
end

-- on_done(ok, reason): a page that shows the result itself; without it the
-- result is a message.
function MainMenu:testConnection(on_done)
    if not self.settings.server_url then
        require("bookorbit_toast").error(_("Set the BookOrbit server address first."))
        if on_done then on_done(false, _("No server address")) end
        return
    end
    if not self:isLoggedIn() then
        if on_done then on_done(false, _("Not signed in")) end
        self:promptLogin()
        return
    end

    NetworkMgr:runWhenConnected(function()
        local checking
        if not on_done then
            checking = require("bookorbit_toast").loading(_("Testing the connection…"), { dismissable = false })
        end
        local body, err = self:newClient():auth()
        if checking then checking:close() end
        if body then
            self:recordSyncSuccess("connection_test", _("Connection test succeeded"))
        else
            self:recordSyncError("connection_test", err)
        end
        if on_done then
            on_done(body ~= nil, not body and self:errorLabel(err) or nil)
        elseif body then
            require("bookorbit_toast").show(_("Connection works"))
        else
            require("bookorbit_toast").error(T(_("Connection failed: %1"), self:errorLabel(err)))
        end
    end)
end

-- A connection test that reports to the page that started it, on page.test:
-- testing, then ok or the reason it failed. The page repaints "Testing"
-- before the request, which blocks until the server answers.
function MainMenu:startPageTest(page, refresh)
    page.test = { running = true }
    refresh()
    UIManager:tickAfterNext(function()
        self:testConnection(function(ok, reason)
            if page.closed then return end
            page.test = ok and { ok = true } or { err = reason or _("Not reachable") }
            refresh(true)
        end)
    end)
end

-- ----------------------------------------------------------- menu bar icon
function MainMenu:menuBarIconEnabled()
    return self.settings.menu_bar_icon ~= false
end

function MainMenu:menuBarIconPath()
    if not self.path then return nil end
    local path = self.path .. "/assets/bookorbit.tab.svg"
    if path:sub(1, 1) ~= "/" then
        local cwd = require("libs/libkoreader-lfs").currentdir()
        if cwd then path = cwd .. "/" .. path end
    end
    return path
end

-- KOReader's tab bar looks icons up by name under its icon folders. Enough
-- ".." segments climb from any of them to the root, so the shipped SVG is
-- found by its absolute path without copying it anywhere.
function MainMenu:menuBarIconName()
    local path = self:menuBarIconPath()
    if not path then return "appbar.menu" end
    return string.rep("../", 32) .. path:gsub("^/+", ""):gsub("%.svg$", "")
end

function MainMenu:setMenuBarIconEnabled(enabled)
    self.settings.menu_bar_icon = enabled == true
    G_reader_settings:flush()
    require("bookorbit_menu_pin").refresh(enabled == true)
    -- The menu rebuilds from the rewritten order the next time it opens.
    if self.ui and self.ui.menu then self.ui.menu.tab_item_table = nil end
end

local function closeKOReaderMenu(ui)
    local menu = ui and ui.menu
    if not menu then return end
    if menu.onCloseFileManagerMenu then
        menu:onCloseFileManagerMenu()
    elseif menu.onCloseReaderMenu then
        menu:onCloseReaderMenu()
    end
end

-- The menu bar icon: BookOrbit in the file browser, This book in a book, and
-- sign-in for either when signed out. Opened after the menu's own close has
-- been painted, so a sheet's backdrop is the page, not the menu.
function MainMenu:onMenuBarIcon()
    closeKOReaderMenu(self.ui)
    UIManager:tickAfterNext(function()
        if not self:isLoggedIn() then
            self:openSignIn(function() self:onMenuBarIconAfterSignIn() end)
        elseif self.ui and self.ui.document then
            self:openBookSheet()
        else
            self:browseCatalog(false)
        end
    end)
end

function MainMenu:onMenuBarIconAfterSignIn()
    if self.ui and self.ui.document then
        self:openBookSheet()
    else
        self:browseCatalog(false)
    end
end

function MainMenu:addToMainMenu(menu_items)
    local items = {
        {
            -- The id predates the rename; scripts and patches look it up.
            id = "open_dashboard",
            text = _("Open BookOrbit"),
            callback = function()
                UIManager:tickAfterNext(function() self:openBookOrbit() end)
            end,
        },
    }
    if self.ui and self.ui.document then
        table.insert(items, {
            id = "this_book",
            text = _("This book"),
            callback = function()
                UIManager:tickAfterNext(function()
                    if self:isLoggedIn() then self:openBookSheet() else self:openSignIn() end
                end)
            end,
        })
    end
    table.insert(items, {
        id = "settings",
        text = _("Settings"),
        callback = function()
            UIManager:tickAfterNext(function() self:openSettings(self.catalog_browser) end)
        end,
    })
    menu_items.bookorbit = {
        text = _("BookOrbit"),
        -- Fallback placement only: BookOrbitMenuPin normally pins this entry
        -- right below calibre on the first page of the Tools menu.
        sorting_hint = "tools",
        sub_item_table = items,
    }
    if self:menuBarIconEnabled() then
        -- A tab that acts as a button, like the reader's file browser tab.
        -- BookOrbitMenuPin lists it in KOReader's menu bar order.
        menu_items.bookorbit_tab = {
            icon = self:menuBarIconName(),
            remember = false,
            callback = function() self:onMenuBarIcon() end,
        }
    end
end

-- ----------------------------------------------------------------- openers
function MainMenu:openBookOrbit()
    if not self:isLoggedIn() then
        self:openSignIn(function() self:browseCatalog(false) end)
        return
    end
    self:browseCatalog(false)
end

function MainMenu:openSignIn(on_signed_in)
    return require("bookorbit_signin_page").open(self, on_signed_in)
end

function MainMenu:openMenuSheet(catalog)
    return require("bookorbit_menu_sheet").open(self, catalog, function(page, action)
        return self:onMenuSheetAction(page, catalog, action)
    end)
end

function MainMenu:openSettings(catalog, view)
    return require("bookorbit_settings_page").open(self, catalog, view)
end

function MainMenu:openSyncStatus()
    return require("bookorbit_status_page").open(self)
end

function MainMenu:openBookSheet()
    if not (self.ui and self.ui.document) then return end
    return require("bookorbit_book_sheet").open(self)
end

-- The open book's title, for the sheet's Back to book tile.
function MainMenu:openBookTitle()
    local ui = self.ui
    if not (ui and ui.document) then return nil end
    local props = ui.doc_props or {}
    local title = props.display_title or props.title
    if title and title ~= "" then return title end
    local file = ui.document.file or ""
    return (file:gsub(".*/", ""):gsub("%.[^%.]+$", ""))
end

function MainMenu:openBookDetails(book_id)
    if not book_id then return end
    self:browseCatalog(false)
    local catalog = self.catalog_browser
    if catalog and catalog.loadBookDetail then
        UIManager:nextTick(function() catalog:loadBookDetail(book_id) end)
    end
end

-- What the sheet does with a tap it does not handle itself.
function MainMenu:onMenuSheetAction(page, catalog, action)
    local kind = action.kind
    local after = function(fn)
        page:close()
        UIManager:nextTick(fn)
    end
    if kind == "sync" or kind == "connect" then
        -- The sheet stays open and its Sync tile follows the run.
        local start = function()
            self:startSheetSync(page, catalog)
        end
        if kind == "connect" then NetworkMgr:runWhenConnected(start) else start() end
    elseif kind == "sync-stop" then
        self:confirmStopSync()
    elseif kind == "customize" then
        page:close()
        self:customizeHome(catalog)
    elseif kind == "home" then
        after(function() if catalog and catalog.goDashboard then catalog:goDashboard() end end)
    elseif kind == "exit" then
        after(function() if catalog then catalog:onCloseAllMenus() end end)
    elseif kind == "files" then
        self.skip_return_home_once = true
        after(function()
            if catalog then catalog:onCloseAllMenus() end
            UIManager:nextTick(function()
                UIManager:sendEvent(require("ui/event"):new("Home"))
            end)
        end)
    elseif kind == "search" then
        after(function() if catalog then catalog:onSearchButtonTap() end end)
    elseif kind == "link" then
        after(function() if catalog and catalog.boardOpenLink then catalog:boardOpenLink(action.link) end end)
    elseif kind == "list-options" then
        after(function()
            if not catalog then return end
            if catalog.listMode and catalog:listMode() then return catalog:listOpenSheet("sort") end
            catalog:showBookActions()
        end)
    elseif kind == "settings" then
        after(function() self:openSettings(catalog) end)
    elseif kind == "status" then
        after(function() self:openSyncStatus() end)
    elseif kind == "about" then
        after(function() self:openSettings(catalog, "about") end)
    elseif kind == "update" then
        after(function() self:applyUpdate(self.settings.update_latest_version) end)
    end
    return true
end

-- ------------------------------------------------------------- page syncs
-- Short words for how a sync started from a page ended.
function MainMenu:syncErrorLabel(err)
    if err == "cancelled" then return _("Stopped") end
    if err == "not_started" then return _("Another sync is running") end
    if err == "unmatched" then return _("Not in your BookOrbit library") end
    if err == "capture" or err == "changed" then return _("Could not read this book") end
    return self:errorLabel(err)
end

function MainMenu:confirmStopSync()
    require("bookorbit_dialog_ui").confirm{
        title = _("Stop syncing?"),
        text = _("What has synced so far is kept. The rest syncs next time."),
        ok_label = _("Stop"),
        on_ok = function() BookOrbitSweep.cancel("user") end,
    }
end

-- A library sync that reports to the page that started it: progress on
-- page.sync while it runs, then the outcome. A page closed in the meantime
-- hands the outcome to a notification instead.
-- opts.full_recheck runs Recheck all books instead.
function MainMenu:startPageSync(page, refresh, opts)
    if not self:isLoggedIn() then
        self:promptLogin()
        return
    end
    local recheck = opts and opts.full_recheck
    page.sync = { running = true, text = recheck and _("Rechecking") or _("Starting"), recheck = recheck }
    refresh()
    local start = recheck and self.startMatchRecheck or self.startSweep
    start(self, {
        quiet = true,
        on_progress = function(text)
            if page.closed then return end
            page.sync = { running = true, text = text, recheck = recheck }
            refresh()
        end,
        on_done = function(err)
            local outcome = err and { err = self:syncErrorLabel(err), recheck = recheck } or { done = true, recheck = recheck }
            if page.closed then
                local Toast = require("bookorbit_toast")
                if err then
                    Toast.error(T(_("Sync stopped: %1"), outcome.err))
                else
                    Toast.show(recheck and _("Books rechecked") or _("Library synced"))
                end
                return
            end
            page.sync = outcome
            refresh(true)
        end,
    })
end

function MainMenu:startSheetSync(page, catalog)
    local MenuSheet = require("bookorbit_menu_sheet")
    self:startPageSync(page, function(reload)
        if reload then page.sheet_data = MenuSheet.data(self, catalog) end
        page.sheet_data.sync = page.sync
        page:refresh()
    end)
end

-- ------------------------------------------------------------------ Home
function MainMenu:customizeHome(catalog)
    if not catalog then
        self:openCatalogBrowser(false)
        catalog = self.catalog_browser
    end
    if not catalog then return end
    UIManager:nextTick(function()
        if catalog.goDashboard and not catalog:dashboardMode() then catalog:goDashboard() end
        if catalog.boardEnterEdit then catalog:boardEnterEdit() end
    end)
end

-- Writes a board setting through the open catalog, so the board redraws, or
-- straight to the settings when it is closed.
function MainMenu:applyBoardSetting(catalog, change)
    local state = change(self.settings)
    if catalog and catalog.persistSetting then
        catalog:persistSetting(BoardStore.SETTING_KEY, state)
        catalog.board_edit = nil
        if catalog:dashboardMode() then
            catalog.current_context.board_page = 1
            catalog:boardRefreshIfMissing()
        end
    else
        self.settings[BoardStore.SETTING_KEY] = state
        G_reader_settings:flush()
    end
end

function MainMenu:applyBoardTiles(catalog, tiles)
    if catalog and catalog.boardSetTiles then
        catalog:boardSetTiles(tiles)
    else
        self.settings[BoardStore.SETTING_KEY] = BoardStore.withTiles(self.settings, tiles)
        G_reader_settings:flush()
    end
end

function MainMenu:applyBoardColour(catalog, colour)
    if catalog and catalog.boardSetColour then
        catalog:boardSetColour(colour)
    else
        self.settings[BoardStore.SETTING_KEY] = BoardStore.withColour(self.settings, colour)
        G_reader_settings:flush()
    end
end

function MainMenu:chooseDownloadFolder(catalog, on_done)
    if catalog and catalog.chooseDownloadDir then
        catalog:chooseDownloadDir(on_done)
        return
    end
    require("ui/downloadmgr"):new{
        onConfirm = function(path)
            G_reader_settings:saveSetting("download_dir", path)
            G_reader_settings:flush()
            if on_done then UIManager:nextTick(on_done) end
        end,
    }:chooseDir(require("bookorbit_download_root").get())
end

-- ---------------------------------------------------------------- shortcut
function MainMenu:gesturesData()
    local gestures = self.ui and self.ui.gestures
    return gestures and gestures.data or nil
end

function MainMenu:applyShortcut(id)
    local ok = require("bookorbit_shortcut").apply(self.ui and self.ui.gestures, id)
    if not ok then
        require("bookorbit_toast").error(_("Turn on KOReader's Gestures plugin first: Settings, Taps and gestures."))
    end
    return ok
end

function MainMenu:refreshActiveCatalogApi(refresh)
    local api = self:apiOpts(true)
    if not self.catalog_browser then return end
    self.catalog_browser:setApi(api)
    if refresh then self.catalog_browser:refreshCurrent() end
end

function MainMenu:applyServerAddress(server_url)
    if self.settings.server_url ~= server_url then
        self:clearAccountCaches()
    end
    self.settings.server_url = server_url
    self:refreshActiveCatalogApi(false)
end

-- The server address in the BookOrbit text panel; a value that is not a web
-- address keeps the panel open with the reason under the field.
function MainMenu:setServerAddress(on_done)
    local DialogUI = require("bookorbit_dialog_ui")
    local INK = require("bookorbit_board_metrics").INK
    local current = self.settings.server_url
    require("bookorbit_text_entry").open{
        title = _("Server address"),
        value = current and (current:gsub("/api/v1/?$", "")) or "https://",
        hint = "https://books.example.com",
        icon = "globe",
        validate = function(value)
            if not BookOrbitApi.normalizeServerUrl(value) then return _("Enter a valid http:// or https:// server address.") end
        end,
        below = function(_page, w)
            return {
                DialogUI.note(w, "info", _("The address you open BookOrbit at in a browser."), { col = INK.g3 }),
                DialogUI.pillRow(w, {
                    { label = _("Cancel"), kind = "outline", action = { kind = "close" } },
                    { label = _("Save"), icon = "check", action = { kind = "submit" } },
                }),
            }
        end,
        on_submit = function(value)
            local normalized = BookOrbitApi.normalizeServerUrl(value)
            self:applyServerAddress(normalized)
            require("bookorbit_toast").show(T(_("Server set to %1"), require("bookorbit_menu_ui").serverHost(normalized) or normalized))
            if on_done then on_done() end
        end,
    }
end

function MainMenu:doLogin(username, password, menu)
    Device:setIgnoreInput(true)
    local userkey = md5(password)
    local opts = self:apiOpts()
    opts.username = username
    opts.userkey = userkey
    local client = BookOrbitApi.new(opts)
    local body, err = client:auth()
    Device:setIgnoreInput(false)

    if body then
        if self.settings.username ~= username then self:clearAccountCaches() end
        self.settings.username = username
        self.settings.userkey = userkey
        self:refreshActiveCatalogApi(true)
        if menu then menu:updateItems() end
        UIManager:show(InfoMessage:new{ text = _("Logged in to BookOrbit.") })
        UIManager:scheduleIn(1, function()
            if self.requestUpdateCheck then
                self:requestUpdateCheck(false, "login")
            else
                self:maybeCheckForUpdate(false)
            end
        end)
    elseif err == 401 or err == 403 then
        UIManager:show(InfoMessage:new{
            text = _("Login failed. Create or check your KOReader credentials in BookOrbit web settings."),
        })
    else
        UIManager:show(InfoMessage:new{ text = T(_("Could not reach the BookOrbit server: %1"), tostring(err)) })
    end
end

function MainMenu:clearAccountCaches()
    self.settings.catalog_dashboard_cache = nil
    self.settings.catalog_detail_cache = nil
end

function MainMenu:logout(menu)
    self:clearAccountCaches()
    self.settings.userkey = nil
    self:refreshActiveCatalogApi(false)
    if menu then menu:updateItems() end
end


-- Stores credentials the sign-in page verified.
function MainMenu:completeSignIn(server_url, username, userkey)
    if self.settings.server_url ~= server_url or self.settings.username ~= username then
        self:clearAccountCaches()
    end
    self.settings.server_url = server_url
    self.settings.username = username
    self.settings.userkey = userkey
    G_reader_settings:flush()
    self:refreshActiveCatalogApi(true)
    require("bookorbit_toast").show(_("Signed in to BookOrbit"))
    UIManager:scheduleIn(1, function()
        if self.requestUpdateCheck then
            self:requestUpdateCheck(false, "login")
        end
    end)
end

function MainMenu:signOut(catalog)
    self:logout()
    G_reader_settings:flush()
    if catalog then catalog:onCloseAllMenus() end
end

function MainMenu.install(BookOrbit)
    for name, fn in pairs(MainMenu) do
        if name ~= "install" then
            BookOrbit[name] = fn
        end
    end
end

return MainMenu