-- Introduction to Lua with Mufibot
--
-- Developer mode
--
-- __Dofus/app/config-custom.xml__
-- ```xml
-- <LangFile>
--     <!-- Developer mode -->
--     <entry key="dev.mode">true</entry>
--     <!-- Controler (display FPS, MEM usage and shorcuts to Console, Event and Lua consoles) -->
--     <entry key="dev.auto.display.controler">true</entry>
--     <!-- Event Console -->
--     <entry key="dev.auto.display.eventUtil">false</entry>
--     <!-- Lua Console -->
--     <entry key="dev.auto.display.luaUtil">false</entry>
--     <!-- Console -->
--     <entry key="boo">true</entry>
-- </LangFile>
-- ```
--
-- Console mode
-- /uiinspector
-- UI inspector provides information about the targeted entity such as a player, NPC, a monster, an interactive object (door, zaap, garbage, etc.).
-- Useful to get IDs.
--
-- 1. Mufibot presentation
-- 2. Lua presentation
-- 3. Functional programming
-- 4. Functional primitives
-- 5. Dopples

-- Move ├────────────────────────────────────────────────────────────────────────

function move()
    return { { map = '-1,13', custom = main } }
end

-- Main ├────────────────────────────────────────────────────────────────────────

function main()

    if not onMap('-1,13') then
        return
    end

    local npc_dopple = function(id, start)
        npc.npc(id, 1)
        if start then -- ugly
            npc_reply(-1)(-2)(-1)
        else
            npc_reply(-1)(-2)(-1)
        end
        -- Start fight
        leaveDialog()
    end

    local function door(cell)
        use(cell, -1)
        return door
    end

    local change_map = Function:chain(changeMap)
    local npc_reply  = Function:chain(npc.reply)

    -- Sadida
    go({-1,9}, (function(map)
        local special_map = {
            ['-1,11'] = (function() changeMap('right') end),
             ['0,11'] = (function() moveToCell(0)      end) }
        local fn = special_map[currentMap()]
        if fn then fn() end
    end))
    door(342)(274)
    npc_dopple(442, 'start')
    change_map(408)(397)
    change_map(408)(397)

    -- Cra
    go({0,9})({0,3})
    door(401)(311)
    npc_dopple(439)
    change_map(472)(({451,465})[1])

    -- Iop
    go({1,3})
    door(356)
    change_map(({415,429})[1])
    npc_dopple(434)
    door(269)
    change_map(({410,425})[1])

    -- Rogue
    go({3,3})
    door(191)
    npc.npc(1422, 1)
    npc_reply(-1)
    door(159)(338)(311)(323)
    npc_dopple(1414)
    door(({495,509})[1])
    change_map(347)
    door(({439,453})[1])(({329,343})[1])
    npc.npc(1422, 1)
    npc_reply(-2)
    door(241)

    -- Xelor
    go({3,1})
    door(373)(346)
    npc_dopple(437)
    change_map(410)(({397,411})[1])

    -- Eliotrope
    go({4,0})
    door(274)
    change_map('right')('left')
    npc_dopple(2834)
    change_map('right')('south')
    use(498, 213)

    -- Eniripsa
    go({7,1})
    door(412)(290)(426)(346)
    -- npc_dopple(435)
    door(({348,362})[1])(({337,350})[1])(({319,333})[1])
    change_map('down')

    -- Osamodas
    go({8,2})
    door(261)(242)
    -- npc_dopple(436)
    door(458)(424)

    -- Féca
    go({12,5})
    door(400)(290)
    -- npc_dopple(433)
    door(451)(424)

    -- Foggernaut
    go({9,1})
    door(217)(344)(398)(499)
    -- npc_dopple(1594)
    door(311)(494)(({452,466})[1])
    use(438, 213)

    -- Pandawa
    go({4,-2})
    door(381)(317)
    -- npc_dopple(672)
    door(452)(452)

    -- Huppermage
    go({-4,-2})
    door(272)(up)
    change_map('right')('up')
    door(474)
    -- npc_dopple(3053)
    change_map('left|down')('down')('left')('left|down')
    door(177)

    -- Sram
    go({-4,0})
    door(({317,384})[1])(275)
    -- npc_dopple(441)
    door(416)(({388,442})[1])

    -- Enutrof
    go({-1,-4})
    door(415)(311)
    -- npc_dopple(440)
    door(325)(({456,469})[1])

    -- Ecaflip
    go({1,-5})
    door(314)(245)(305)
    -- npc_dopple(438)
    door(233)(214)(({382,397})[1])

    -- Masqueraider
    go({1,-8})
    door(144)(107)(184)(184)(287)(290)
    -- npc_dopple(1425)
    door(284)(511)(402)(393)(394)(347)

    -- Sacrier
    go({0,-8})({0,-7})({-2,-7})
    door(194)(394)
    go({-2,-8})
    door(286)(285)(243)
    -- npc_dopple(443)

end

-- Utility ├─────────────────────────────────────────────────────────────────────

function go(destination, fn)

    local destination_str = Function:join(destination, ',')

    local current_map = Function:map(Function:split(currentMap(), ','), tonumber)

    local x_current,     y_current     = unpack(current_map)
    local x_destination, y_destination = unpack(destination)

    local direction = function(start, stop) return (start == stop) and 0 or (start < stop) and 1 or -1 end

    local x_direction = { [-1] = 'left',   [0] = nil, [1] = 'right'  }
    local y_direction = { [-1] = 'top',    [0] = nil, [1] = 'bottom' }

    local map = { map       = current_map,
                  direction = Function:join(Function:compact({ x_direction[direction(x_current, x_destination)],
                                                               y_direction[direction(y_current, y_destination)] }), '|') }

    local saved_current_map_str = currentMap()

    if fn then fn(map) end

    if (currentMap() == saved_current_map_str) then
        changeMap(map.direction)
    end

    return (currentMap() == destination_str) and go or go(destination, fn)
end

-- Library ├─────────────────────────────────────────────────────────────────────

-- todo split

Function = {
    map = function(self, objects, fn)
        local collection = {}
        for key, object in pairs(objects) do
            collection[key] = fn(object)
        end
        return collection
    end,

    curry = function(self, fn, nargs)
        nargs = nargs or debug.getinfo(fn, 'u').nparamsend
        local helper = function(args, n)
            return n < 1 and fn(unpack(args)) or (function(...) return helper(self:concat(args, {...}), n - #{...}) end)
        end
        return helper({}, nargs)
    end,

    infinite = (1/0),

    flatten = function(self, _table, level)
        level = level or self.infinite
        return self:inject((function(memo, value)
            return (level < 1) or (type(value) ~= 'table') and self:push(memo, value) or self:concat(memo, self:flatten(value))
        end), {}, _table)
    end,

    insert = function(self, index, _table, object)
        local smart_index = (function(index, length) return (index > 0) and index or ((length + 2) + index) end)
        local res = self:copy(_table)
        local index = smart_index(index, #res)
        local entry = res[index]
        res[index] = object
        return not entry and res or self:insert((index + 1), res, entry)
    end,

    push = function(self, _table, object)
        return self:insert(-1, _table, object)
    end,

    reverse = function(self, _table)
        local reversed = {}
        for key, value in pairs(_table) do
            reversed[#_table + 1 - key] = value
        end
        return reversed
    end,

    join = function(self, _table, separator)
        return self:inject((function(memo, value) return memo .. (separator or '') .. value end), self:head(_table), self:tail(_table))
    end,

    split = function(self, str, sep)
        res = {}
        pattern = string.format("([^%s]+)", sep)
        str:gsub(pattern, (function(match) res[#res + 1] = match end))
        return res
    end,

    head = function(self, _table)
        return _table[1]
    end,

    tail = function(self, _table)
        return { select(2, unpack(_table)) }
    end,

    merge = function(self, a, b, fn)
        local a_copy, b_copy = self:copy(a), self:copy(b)
        local merged = a_copy
        for key, value in pairs(b_copy) do
            merged[key] = (merged[key] == nil) and value or (fn == nil) and value or fn(key, a_copy[key], b_copy[key])
        end
        return merged
    end,

    copy = function(self, object)
        if type(object) ~= 'table' then
            return object
        end
        local res = {}
        for key, value in pairs(object) do
            res[self:copy(key)] = self:copy(value)
        end
        return res
    end,

    inject = function(self, fn, initial, _table)
        local memo = self:copy(initial)
        for key, value in pairs(_table) do
            memo = fn(memo, value)
        end
        return memo
    end,

    range = function(self, start, stop, step)
        local step = (step ~= nil) and step or (start < stop) and 1 or -1
        local res = {}
        for value = start, stop, step do
            res[#res + 1] = value
        end
        return res
    end,

    concat = function(self, head, ...)
        local head = self:copy(head)
        for key, tail in pairs({...}) do
            for key, value in pairs(tail) do
                head[#head + 1] = value
            end
        end
        return head
    end,

    filter = function(self, _table, fn)
        local filtered = {}
        for key, value in pairs(self:copy(_table)) do
            if fn(value) then
                filtered[#filtered + 1] = value
            end
        end
        return filtered
    end,

    select = function(self, _table, fn)
        return self:head(self:filter(_table, fn))
    end,

    compact = function(self, _table)
        return self:filter(_table, (function(value) return (value ~= nil) end))
    end,

    tap = function(self, object, fn)
        return fn(object)
    end,

    chain = function(self, fn)
        local function helper(...)
            fn(...)
            return helper
        end
        return helper
    end,
}