--------------------------------------------------------
-- Minetest :: ActiveFormspecs Mod v2.6 (formspecs)
--
-- See README.txt for licensing and release notes.
-- Copyright (c) 2016-2019, Leslie Ellen Krause
--
-- ./games/just_test_tribute/mods/formspecs/init.lua
--------------------------------------------------------

print( "Loading ActiveFormspecs Mod" )

minetest.FORMSPEC_SIGEXIT = "true"  -- player clicked exit button or pressed esc key (boolean for backward compatibility)
minetest.FORMSPEC_SIGQUIT = 1       -- player logged off
minetest.FORMSPEC_SIGKILL = 2       -- player was killed
minetest.FORMSPEC_SIGTERM = 3       -- server is shutting down
minetest.FORMSPEC_SIGPROC = 4       -- procedural closure
minetest.FORMSPEC_SIGTIME = 5       -- timeout reached
minetest.FORMSPEC_SIGSTOP = 6       -- procedural closure (cannot be trapped)
minetest.FORMSPEC_SIGHOLD = 7       -- child form opened, parent is suspended
minetest.FORMSPEC_SIGCONT = 8       -- child form closed, parent can continue

local afs = { }     -- obtain localized, protected namespace

afs.forms = { }
afs.timers = { }
afs.session_id = 0
afs.session_seed = math.random( 0, 65535 )

afs.stats = { active = 0, opened = 0, closed = 0 }

afs.stats.on_open = function ( self )
    self.active = self.active + 1
    self.opened = self.opened + 1
end

afs.stats.on_close = function ( self )
    self.active = self.active - 1
    self.closed = self.closed + 1
end

-----------------------------------------------------------------
-- trigger callbacks at set intervals within timer queue
-----------------------------------------------------------------

do
    -- localize needed object references for efficiency
    local get_us_time = minetest.get_us_time
    local timers = afs.timers
    local t_cur = get_us_time( )
    local t_off = -t_cur

    -- step monotonic clock with graceful 32-bit overflow
    local step_clock = function( )
        local t_new = get_us_time( )

        if t_new < t_cur then
            t_off = t_off + 4294967290
        end

        t_cur = t_new
        return t_off + t_new
    end
    afs.get_uptime = function( )
        return ( t_off + t_cur ) / 1000000
    end

    minetest.register_globalstep( function( dtime )
--local x = get_us_time( )
        local curtime = step_clock( ) / 1000000
        local idx = #timers

        -- iterate through table in reverse order to allow removal
        while idx > 0 do
            local self = timers[ idx ]

            if curtime >= self.exptime then
                self.counter = self.counter + 1
                self.overrun = curtime - self.exptime
                self.exptime = curtime + self.form.timeout

                self.form.newtime = math.floor( curtime )
                self.form.on_close( self.form.meta, self.form.player, { quit = minetest.FORMSPEC_SIGTIME } )

                self.overrun = 0.0
                        end
            idx = idx - 1
            end
    end )
end

-----------------------------------------------------------------
-- override node registrations for attached formspecs
-----------------------------------------------------------------

local on_rightclick = function( pos, node, player )
    local nodedef = minetest.registered_nodes[ node.name ]
    local meta = nodedef.before_open and nodedef.before_open( pos, node, player ) or pos
    local formspec = nodedef.on_open( meta, player )

    if formspec then
        local player_name = player:get_player_name( )
        minetest.create_form( meta, player_name, formspec, nodedef.on_close )
        afs.forms[ player_name ].origin = node.name
    end
end

local old_register_node = minetest.register_node
local old_override_item = minetest.override_item

minetest.register_node = function ( name, def )
    if def.on_open and not def.on_rightclick then
        def.on_rightclick = on_rightclick
    end
    old_register_node( name, def )
end

minetest.override_item = function ( name, def )
    if minetest.registered_nodes[ name ] and def.on_open then
        def.on_rightclick = on_rightclick
    end
    old_override_item( name, def )
end

-----------------------------------------------------------------
-- trigger callbacks during formspec events
-----------------------------------------------------------------

minetest.register_on_player_receive_fields( function( player, formname, fields )
    local player_name = player:get_player_name( )
    local form = afs.forms[ player_name ]

    -- perform a basic sanity check, since these shouldn't technically occur
    if not form or player ~= form.player or formname ~= form.name then return end

    -- handle reverse-lookups of dropdown indexes
    for name, keys in pairs( form.dropdowns ) do
        if fields[ name ] then
            fields[ name ] = keys[ fields[ name ] ]
        end
    end

    form.newtime = os.time( )
    form.on_close( form.meta, form.player, fields )

    -- end current session when closing formspec
    if fields.quit then
        minetest.get_form_timer( player_name ).stop( )

        afs.stats:on_close( )
        if form.parent_form then
            -- restore previous session
            form = form.parent_form
            afs.forms[ player_name ] = form

            -- delay a single tick to ensure formspec updates are handled by client
            minetest.after( 0.0, function ( )
                form.on_close( form.meta, form.player, { quit = minetest.FORMSPEC_SIGCONT } )
            end )
        else
            afs.forms[ player_name ] = nil
        end
    end
end )

-----------------------------------------------------------------
-- expose timer functionality within a helper object
-----------------------------------------------------------------

minetest.get_form_timer = function ( player_name, form_name )
    local self = { }
    local form = afs.forms[ player_name ]

    if not form or form_name and form_name ~= form.name then return end

    self.start = function ( timeout )
        if not form.timeout and timeout >= 0.5 then
            local curtime = afs.get_uptime( )

            form.timeout = timeout
            table.insert( afs.timers, { form = form, counter = 0, oldtime = curtime, exptime = curtime + timeout, overrun = 0.0 } )
        end
    end
    self.stop = function ( )
        if not form.timeout then return end

        form.timeout = nil

        for i, v in ipairs( afs.timers ) do
            if v.form == form then
                table.remove( afs.timers, i )
                            return
            end
        end
    end
    self.get_state = function ( )
        if not form.timeout then return end

        for i, v in ipairs( afs.timers ) do
            local curtime = afs.get_uptime( )

            if v.form == form then
                return { elapsed = curtime - v.oldtime, remain = v.exptime - curtime, overrun = v.overrun, counter = v.counter }
            end
        end
    end

    return self
end

-----------------------------------------------------------------
-- parse specialized formspec elements and escapes codes
-----------------------------------------------------------------

local _
local function is_match( str, pat )
        -- use array for captures
        _ = { string.match( str, pat ) }
        return #_ > 0 and _ or nil
end

local function escape( str )
    return string.gsub( str, "\\.",
        { ["\\]"] = "\\x5D", ["\\["] = "\\x5B", ["\\,"] = "\\x2C", ["\\;"] = "\\x3B" } )
end

local function unescape( str, is_raw )
    return string.gsub( str, "\\x..",
        { ["\\x5D"] = "\\]", ["\\x5B"] = "\\[", ["\\x2C"] = "\\,", ["\\x3B"] = "\\;" } )
end

local function unescape_raw( str, is_raw )
    return string.gsub( str, "\\x..",
        { ["\\x5D"] = "]", ["\\x5B"] = "[", ["\\x2C"] = ",", ["\\x3B"] = ";" } )
end

local function parse_elements( form, formspec )
    formspec = escape( formspec )
    form.dropdowns = { }    -- reset the dropdown lookup

    -- dropdown elements can optionally return the selected
        -- index rather than the value of the option itself
    formspec = string.gsub( formspec, "dropdown%[(.-)%]", function( params )
        if is_match( params, "^([^;]*;[^;]*;([^;]*);([^;]*);[^;]*);([^;]*)$" ) then
            local prefix = _[ 1 ]
            local name = _[ 2 ]
            local options = _[ 3 ]
            local use_index = _[ 4 ]

            if use_index == "true" then
                form.dropdowns[ name ] = { }
                for idx, val in ipairs( string.split( options, ",", true ) ) do
                    form.dropdowns[ name ][ unescape_raw( val ) ] = idx     -- add to reverse lookup table
                end
                return string.format( "dropdown[%s]", prefix )
            elseif use_index == "false" or use_index == "" then
                return string.format( "dropdown[%s]", prefix )
            else
                return ""   -- strip invalid dropdown elements
            end
                end
        return string.format( "dropdown[%s]", params )
    end )

    -- hidden elements only provide default, initial values
    -- for state table and are always stripped afterward
    formspec = string.gsub( formspec, "hidden%[(.-)%]", function( params )
        if is_match( params, "^([^;]*);([^;]*)$" ) or is_match( params, "^([^;]*);([^;]*);([^;]*)$" ) then
            local key = _[ 1 ]
            local value = _[ 2 ]
            local type = _[ 3 ]

            if key ~= "" and form.meta[ key ] == nil then
                -- parse according to specified data type
                if type == "string" or type == "" or type == nil then
                    form.meta[ key ] = unescape_raw( value )
                elseif type == "number" then
                    form.meta[ key ] = tonumber( value )
                elseif type == "boolean" then
                    form.meta[ key ] = ( { ["1"] = true, ["0"] = false, ["true"] = true, ["false"] = false } )[ value ]
                end
            end
        end
        return ""       -- strip hidden elements prior to showing formspec
        end )

    return unescape( formspec )
end

-----------------------------------------------------------------
-- open detached formspec with session-based state table
-----------------------------------------------------------------

minetest.create_form = function ( meta, player_name, formspec, on_close, signal )
    -- short circuit whenever required params are missing
    if not player_name or not formspec then return end

    if type( player_name ) ~= "string" then
        player_name = player_name:get_player_name( )
    end

    local form = afs.forms[ player_name ]

    -- trigger previous callback before formspec closure
    if form then
        minetest.get_form_timer( player_name, form.name ).stop( )
        if signal ~= minetest.FORMSPEC_SIGSTOP then
            form.on_close( form.meta, form.player, { quit = signal or minetest.FORMSPEC_SIGPROC } )
        end
        if signal ~= minetest.FORMSPEC_SIGHOLD then
            form = nil
            afs.stats:on_close( )
        end
    end

    -- start new session when opening formspec
    afs.session_id = afs.session_id + 1

    form = { parent_form = form }
    form.id = afs.session_id
    form.name = minetest.get_password_hash( player_name, afs.session_seed + afs.session_id )
    form.player = minetest.get_player_by_name( player_name )
    form.origin = string.match( debug.getinfo( 2 ).source, "^@.*[/\\]mods[/\\](.-)[/\\]" ) or "?"
    form.on_close = on_close or function ( ) end
    form.meta = meta or { }
    form.oldtime = math.floor( afs.get_uptime( ) )
    form.newtime = form.oldtime

    afs.forms[ player_name ] = form
    afs.stats:on_open( )
    minetest.show_formspec( player_name, form.name, parse_elements( form, formspec ) )

    return form.name
end

minetest.update_form = function ( player, formspec )
    local pname = type( player ) == "string" and player or player:get_player_name( )
    local form = afs.forms[ pname ]

    if form then
        form.oldtime = math.floor( afs.get_uptime( ) )
        minetest.show_formspec( pname, form.name, parse_elements( form, formspec ) )
    end
end

minetest.destroy_form = function ( player, signal )
    local pname = type( player ) == "string" and player or player:get_player_name( )
    local form = afs.forms[ pname ]

    if form then
        minetest.close_formspec( pname, form.name )
        minetest.get_form_timer( pname ):stop( )

        if signal ~= minetest.FORMSPEC_SIGSTOP then
            form.on_close( form.meta, form.player, { quit = signal or minetest.FORMSPEC_SIGPROC } )
        end

        afs.stats:on_close( )
        afs.forms[ pname ] = nil
    end
end

-----------------------------------------------------------------
-- trigger callbacks after unexpected formspec closure
-----------------------------------------------------------------

minetest.register_on_leaveplayer( function( player, is_timeout )
    local pname = player:get_player_name( )
    local form = afs.forms[ pname ]

    if form then
        minetest.get_form_timer( pname, form.name ).stop( )

        form.newtime = os.time( )
        form.on_close( form.meta, form.player, { quit = minetest.FORMSPEC_SIGQUIT } )

        afs.stats:on_close( )
        afs.forms[ pname ] = nil
    end
end )

minetest.register_on_dieplayer( function( player )
    local pname = player:get_player_name( )
    local form = afs.forms[ pname ]

    if form then
        minetest.get_form_timer( pname, form.name ).stop( )

        form.newtime = os.time( )
        form.on_close( form.meta, form.player, { quit = minetest.FORMSPEC_SIGKILL } )

        afs.stats:on_close( )
        afs.forms[ pname ] = nil
    end
end )

minetest.register_on_shutdown( function( )
    for _, form in pairs( afs.forms ) do
        minetest.get_form_timer( form.player:get_player_name( ), form.name ).stop( )

        form.newtime = os.time( )
        form.on_close( form.meta, form.player, { quit = minetest.FORMSPEC_SIGTERM } )

        afs.stats:on_close( )
    end
    afs.forms = { }
end )

-----------------------------------------------------------------
-- display realtime information about form sessions
-----------------------------------------------------------------

minetest.register_chatcommand( "fs", {
        description = "Display realtime information about form sessions",
    privs = { server = true },
        func = function( pname, param )
        local page_idx = 1
        local page_size = 10
        local sorted_forms

        local get_sorted_forms = function( )
            local f = { }
            for k, v in pairs( afs.forms ) do
                table.insert( f, v )
            end
            table.sort( f, function( a, b ) return a.id < b.id end )
            return f
        end
        local get_formspec = function( )
            local uptime = math.floor( afs.get_uptime( ) )

            local formspec = "size[9.5,7.5]"
                .. default.gui_bg
                .. default.gui_bg_img

                .. "label[0.1,6.7;ActiveFormspecs v2.6"
                .. string.format( "label[0.1,0.0;%s]label[0.1,0.5;%d min %02d sec]",
                    minetest.colorize( "#888888", "uptime:" ), math.floor( uptime / 60 ), uptime % 60 )
                .. string.format( "label[5.6,0.0;%s]label[5.6,0.5;%d]",
                    minetest.colorize( "#888888", "active" ), afs.stats.active )
                .. string.format( "label[6.9,0.0;%s]label[6.9,0.5;%d]",
                    minetest.colorize( "#888888", "opened" ), afs.stats.opened )
                .. string.format( "label[8.2,0.0;%s]label[8.2,0.5;%d]",
                    minetest.colorize( "#888888", "closed" ), afs.stats.closed )

                .. string.format( "label[0.5,1.5;%s]label[3.5,1.5;%s]label[6.9,1.5;%s]label[8.2,1.5;%s]",
                    minetest.colorize( "#888888", "player" ),
                    minetest.colorize( "#888888", "origin" ),
                    minetest.colorize( "#888888", "idletime" ),
                    minetest.colorize( "#888888", "lifetime" )
                )

                .. "box[0,1.2;9.2,0.1;#111111]"
                .. "box[0,6.2;9.2,0.1;#111111]"

            local num = 0
            for idx = ( page_idx - 1 ) * page_size + 1, math.min( page_idx * page_size, #sorted_forms ) do
                local form = sorted_forms[ idx ]

                local player_name = form.player:get_player_name( )
                local lifetime = uptime - form.oldtime
                local idletime = uptime - form.newtime

                local vert = 2.0 + num * 0.5

                formspec = formspec
                    .. string.format( "button[0.1,%0.1f;0.5,0.3;del:%s;x]", vert + 0.1, player_name )
                    .. string.format( "label[0.5,%0.1f;%s]", vert, player_name )
                    .. string.format( "label[3.5,%0.1f;%s]", vert, form.origin )
                    .. string.format( "label[6.9,%0.1f;%dm %02ds]", vert, math.floor( idletime / 60 ), idletime % 60 )
                    .. string.format( "label[8.2,%0.1f;%dm %02ds]", vert, math.floor( lifetime / 60 ), lifetime % 60 )
                num = num + 1
            end

            formspec = formspec
                .. "button[6.4,6.5;1,1;prev;<<]"
                .. string.format( "label[7.4,6.7;%d of %d]", page_idx, math.max( 1, math.ceil( #sorted_forms / page_size ) ) )
                .. "button[8.4,6.5;1,1;next;>>]"

            return formspec
        end
        local on_close = function( meta, player, fields )
            if fields.quit == minetest.FORMSPEC_SIGTIME then
                sorted_forms = get_sorted_forms( )
                minetest.update_form( pname, get_formspec( ) )

            elseif fields.prev and page_idx > 1 then
                page_idx = page_idx - 1
                minetest.update_form( pname, get_formspec( ) )

            elseif fields.next and page_idx < #sorted_forms / page_size then
                page_idx = page_idx + 1
                minetest.update_form( pname, get_formspec( ) )

            else
                local player_name = string.match( next( fields, nil ), "del:(.+)" )
                if player_name and afs.forms[ player_name ] then
                    minetest.destroy_form( player_name )
                end
            end
        end

        sorted_forms = get_sorted_forms( )

        minetest.create_form( nil, pname, get_formspec( ), on_close )
        minetest.get_form_timer( pname ).start( 1 )

        return true
    end,
} )