dotfiles/multimedia/.config/mpv/scripts/playlistmanager.lua

local settings = {

    -- #### FUNCTIONALITY SETTINGS

    -- navigation keybindings force override only while playlist is visible
    -- if "no" then you can display the playlist by any of the navigation keys
    dynamic_binds = true,

    -- to bind multiple keys separate them by a space
    key_moveup = "UP",
    key_movedown = "DOWN",
    key_selectfile = "RIGHT LEFT",
    key_unselectfile = "",
    key_playfile = "ENTER",
    key_removefile = "BS",
    key_closeplaylist = "ESC",

    -- replaces matches on filenames based on extension, put as empty string to not replace anything
    -- replace rules are executed in provided order
    -- replace rule key is the pattern and value is the replace value
    -- uses :gsub('pattern', 'replace'), read more http://lua-users.org/wiki/StringLibraryTutorial
    -- 'all' will match any extension or protocol if it has one
    -- uses json and parses it into a lua table to be able to support .conf file

    filename_replace = "",

    --[=====[ START OF SAMPLE REPLACE, to use remove start and end line
  --Sample replace: replaces underscore to space on all files
  --for mp4 and webm; remove extension, remove brackets and surrounding whitespace, change dot between alphanumeric to space
  filename_replace = [[
    [
      {
        "ext": { "all": true},
        "rules": [
          { "_" : " " }
        ]
      },{
        "ext": { "mp4": true, "mkv": true },
        "rules": [
          { "^(.+)%..+$": "%1" },
          { "%s*[%[%(].-[%]%)]%s*": "" },
          { "(%w)%.(%w)": "%1 %2" }
        ]
      },{
        "protocol": { "http": true, "https": true },
        "rules": [
          { "^%a+://w*%.?": "" }
        ]
      }
    ]
  ]],
--END OF SAMPLE REPLACE ]=====]

    -- json array of filetypes to search from directory
    loadfiles_filetypes = [[
    [
      "jpg", "jpeg", "png", "tif", "tiff", "gif", "webp", "svg", "bmp",
      "mp3", "wav", "ogm", "flac", "m4a", "wma", "ogg", "opus",
      "mkv", "avi", "mp4", "ogv", "webm", "rmvb", "flv", "wmv", "mpeg", "mpg", "m4v", "3gp"
    ]
  ]],

    -- loadfiles at startup if there is 0 or 1 items in playlist, if 0 uses worḱing dir for files
    loadfiles_on_start = false,

    -- sort playlist on mpv start
    sortplaylist_on_start = false,

    -- sort playlist when files are added to playlist
    sortplaylist_on_file_add = false,

    -- use alphanumerical sort
    alphanumsort = true,

    -- "linux | windows | auto"
    system = "auto",

    -- Use ~ for home directory. Leave as empty to use mpv/playlists
    playlist_savepath = "",

    -- show playlist or filename every time a new file is loaded
    -- 2 shows playlist, 1 shows current file(filename strip applied) as osd text, 0 shows nothing
    -- instead of using this you can also call script-message playlistmanager show playlist/filename
    -- ex. KEY playlist-next ; script-message playlistmanager show playlist
    show_playlist_on_fileload = 0,

    -- sync cursor when file is loaded from outside reasons(file-ending, playlist-next shortcut etc.)
    -- has the sideeffect of moving cursor if file happens to change when navigating
    -- good side is cursor always following current file when going back and forth files with playlist-next/prev
    sync_cursor_on_load = true,

    -- playlist open key will toggle visibility instead of refresh, best used with long timeout
    open_toggles = true,

    -- allow the playlist cursor to loop from end to start and vice versa
    loop_cursor = true,

    -- ####  VISUAL SETTINGS

    -- prefer to display titles for following files: "all", "url", "none". Sorting still uses filename.
    prefer_titles = "url",

    -- call youtube-dl to resolve the titles of urls in the playlist
    resolve_titles = false,

    -- osd timeout on inactivity, with high value on this open_toggles is good to be true
    playlist_display_timeout = 5,

    -- amount of entries to show before slicing. Optimal value depends on font/video size etc.
    showamount = 16,

    -- font size scales by window, if false requires larger font and padding sizes
    scale_playlist_by_window = true,
    -- playlist ass style overrides inside curly brackets, \keyvalue is one field, extra \ for escape in lua
    -- example {\\fnUbuntu\\fs10\\b0\\bord1} equals: font=Ubuntu, size=10, bold=no, border=1
    -- read http://docs.aegisub.org/3.2/ASS_Tags/ for reference of tags
    -- undeclared tags will use default osd settings
    -- these styles will be used for the whole playlist
    style_ass_tags = "{}",
    -- paddings from top left corner
    text_padding_x = 10,
    text_padding_y = 30,

    -- set title of window with stripped name
    set_title_stripped = false,
    title_prefix = "",
    title_suffix = " - mpv",

    -- slice long filenames, and how many chars to show
    slice_longfilenames = false,
    slice_longfilenames_amount = 70,

    -- Playlist header template
    -- %mediatitle or %filename = title or name of playing file
    -- %pos = position of playing file
    -- %cursor = position of navigation
    -- %plen = playlist length
    -- %N = newline
    playlist_header = "[%cursor/%plen]",

    -- Playlist file templates
    -- %pos = position of file with leading zeros
    -- %name = title or name of file
    -- %N = newline
    -- you can also use the ass tags mentioned above. For example:
    --  selected_file="{\\c&HFF00FF&}➔ %name"   | to add a color for selected file. However, if you
    --  use ass tags you need to reset them for every line (see https://github.com/jonniek/mpv-playlistmanager/issues/20)
    normal_file = "○ %name",
    hovered_file = "● %name",
    selected_file = "➔ %name",
    playing_file = "▷ %name",
    playing_hovered_file = "▶ %name",
    playing_selected_file = "➤ %name",

    -- what to show when playlist is truncated
    playlist_sliced_prefix = "...",
    playlist_sliced_suffix = "..."

}
local opts = require("mp.options")
opts.read_options(settings, "playlistmanager",
                  function(list) update_opts(list) end)

local utils = require("mp.utils")
local msg = require("mp.msg")
local assdraw = require("mp.assdraw")

-- check os
if settings.system == "auto" then
    local o = {}
    if mp.get_property_native('options/vo-mmcss-profile', o) ~= o then
        settings.system = "windows"
    else
        settings.system = "linux"
    end
end

-- global variables
local playlist_visible = false
local strippedname = nil
local path = nil
local directory = nil
local filename = nil
local pos = 0
local plen = 0
local cursor = 0
-- table for saved media titles for later if we prefer them
local url_table = {}
-- table for urls that we have request to be resolved to titles
local requested_urls = {}
-- state for if we sort on playlist size change
local sort_watching = false

local filetype_lookup = {}

function update_opts(changelog)
    msg.verbose('updating options')

    -- parse filename json
    if changelog.filename_replace then
        if (settings.filename_replace ~= "") then
            settings.filename_replace = utils.parse_json(
                                            settings.filename_replace)
        else
            settings.filename_replace = false
        end
    end

    -- parse loadfiles json
    if changelog.loadfiles_filetypes then
        settings.loadfiles_filetypes = utils.parse_json(
                                           settings.loadfiles_filetypes)

        filetype_lookup = {}
        -- create loadfiles set
        for _, ext in ipairs(settings.loadfiles_filetypes) do
            filetype_lookup[ext] = true
        end
    end

    if changelog.resolve_titles then resolve_titles() end

    if changelog.playlist_display_timeout then
        keybindstimer = mp.add_periodic_timer(settings.playlist_display_timeout,
                                              remove_keybinds)
        keybindstimer:kill()
    end

    if playlist_visible then showplaylist() end
end

update_opts({filename_replace = true, loadfiles_filetypes = true})

function on_loaded()
    filename = mp.get_property("filename")
    path = mp.get_property('path')
    -- if not a url then join path with working directory
    if not path:match("^%a%a+:%/%/") then
        path = utils.join_path(mp.get_property('working-directory'), path)
        directory = utils.split_path(path)
    else
        directory = nil
    end

    refresh_globals()
    if settings.sync_cursor_on_load then
        cursor = pos
        -- refresh playlist if cursor moved
        if playlist_visible then draw_playlist() end
    end

    local media_title = mp.get_property("media-title")
    if path:match('^https?://') and not url_table[path] and path ~= media_title then
        url_table[path] = media_title
    end

    strippedname = stripfilename(mp.get_property('media-title'))
    if settings.show_playlist_on_fileload == 2 then
        showplaylist()
    elseif settings.show_playlist_on_fileload == 1 then
        mp.commandv('show-text', strippedname)
    end
    if settings.set_title_stripped then
        mp.set_property("title", settings.title_prefix .. strippedname ..
                            settings.title_suffix)
    end

    local didload = false
    if settings.loadfiles_on_start and plen == 1 then
        didload = true -- save reference for sorting
        msg.info("Loading files from playing files directory")
        playlist()
    end

    -- if we promised to sort files on launch do it
    if promised_sort then
        promised_sort = false
        msg.info("Your playlist is sorted before starting playback")
        if didload then
            sortplaylist()
        else
            sortplaylist(true)
        end
    end

    -- if we promised to listen and sort on playlist size increase do it
    if promised_sort_watch then
        promised_sort_watch = false
        sort_watching = true
        msg.info("Added files will be automatically sorted")
        mp.observe_property('playlist-count', "number", autosort)
    end
end

function on_closed()
    strippedname = nil
    path = nil
    directory = nil
    filename = nil
    if playlist_visible then showplaylist() end
end

function refresh_globals()
    pos = mp.get_property_number('playlist-pos', 0)
    plen = mp.get_property_number('playlist-count', 0)
end

function escapepath(dir, escapechar)
    return string.gsub(dir, escapechar, '\\' .. escapechar)
end

-- strip a filename based on its extension or protocol according to rules in settings
function stripfilename(pathfile, media_title)
    if pathfile == nil then return '' end
    local ext = pathfile:match("^.+%.(.+)$")
    local protocol = pathfile:match("^(%a%a+)://")
    if not ext then ext = "" end
    local tmp = pathfile
    if settings.filename_replace and not media_title then
        for k, v in ipairs(settings.filename_replace) do
            if (v['ext'] and
                (v['ext'][ext] or (ext and not protocol and v['ext']['all']))) or
                (v['protocol'] and
                    (v['protocol'][protocol] or
                        (protocol and not ext and v['protocol']['all']))) then
                for ruleindex, indexrules in ipairs(v['rules']) do
                    for rule, override in pairs(indexrules) do
                        tmp = tmp:gsub(rule, override)
                    end
                end
            end
        end
    end
    if settings.slice_longfilenames and tmp:len() >
        settings.slice_longfilenames_amount + 5 then
        tmp = tmp:sub(1, settings.slice_longfilenames_amount) .. " ..."
    end
    return tmp
end

-- gets a nicename of playlist entry at 0-based position i
function get_name_from_index(i, notitle)
    refresh_globals()
    if plen <= i then
        msg.error("no index in playlist", i, "length", plen);
        return nil
    end
    local _, name = nil
    local title = mp.get_property('playlist/' .. i .. '/title')
    local name = mp.get_property('playlist/' .. i .. '/filename')

    local should_use_title = settings.prefer_titles == 'all' or
                                 name:match('^https?://') and
                                 settings.prefer_titles == 'url'
    -- check if file has a media title stored or as property
    if not title and should_use_title then
        local mtitle = mp.get_property('media-title')
        if i == pos and mp.get_property('filename') ~= mtitle then
            if not url_table[name] then url_table[name] = mtitle end
            title = mtitle
        elseif url_table[name] then
            title = url_table[name]
        end
    end

    -- if we have media title use a more conservative strip
    if title and not notitle and should_use_title then
        return stripfilename(title, true)
    end

    -- remove paths if they exist, keeping protocols for stripping
    if string.sub(name, 1, 1) == '/' or name:match("^%a:[/\\]") then
        _, name = utils.split_path(name)
    end
    return stripfilename(name)
end

function parse_header(string)
    local esc_title = stripfilename(mp.get_property("media-title"), true):gsub(
                          "%%", "%%%%")
    local esc_file = stripfilename(mp.get_property("filename")):gsub("%%",
                                                                     "%%%%")
    return string:gsub("%%N", "\\N"):gsub("%%pos", mp.get_property_number(
                                              "playlist-pos", 0) + 1):gsub(
               "%%plen", mp.get_property("playlist-count")):gsub("%%cursor",
                                                                 cursor + 1)
               :gsub("%%mediatitle", esc_title):gsub("%%filename", esc_file) -- undo name escape
        :gsub("%%%%", "%%")
end

function parse_filename(string, name, index)
    local base = tostring(plen):len()
    local esc_name = stripfilename(name):gsub("%%", "%%%%")
    return string:gsub("%%N", "\\N"):gsub("%%pos", string.format(
                                              "%0" .. base .. "d", index + 1))
               :gsub("%%name", esc_name) -- undo name escape
        :gsub("%%%%", "%%")
end

function parse_filename_by_index(index)
    local template = settings.normal_file

    local is_idle = mp.get_property_native('idle-active')
    local position = is_idle and -1 or pos

    if index == position then
        if index == cursor then
            if selection then
                template = settings.playing_selected_file
            else
                template = settings.playing_hovered_file
            end
        else
            template = settings.playing_file
        end
    elseif index == cursor then
        if selection then
            template = settings.selected_file
        else
            template = settings.hovered_file
        end
    end

    return parse_filename(template, get_name_from_index(index), index)
end

function draw_playlist()
    refresh_globals()
    local ass = assdraw.ass_new()
    ass:new_event()
    ass:pos(settings.text_padding_x, settings.text_padding_y)
    ass:append(settings.style_ass_tags)

    if settings.playlist_header ~= "" then
        ass:append(parse_header(settings.playlist_header) .. "\\N")
    end
    local start = cursor - math.floor(settings.showamount / 2)
    local showall = false
    local showrest = false
    if start < 0 then start = 0 end
    if plen <= settings.showamount then
        start = 0
        showall = true
    end
    if start > math.max(plen - settings.showamount - 1, 0) then
        start = plen - settings.showamount
        showrest = true
    end
    if start > 0 and not showall then
        ass:append(settings.playlist_sliced_prefix .. "\\N")
    end
    for index = start, start + settings.showamount - 1, 1 do
        if index == plen then break end

        ass:append(parse_filename_by_index(index) .. "\\N")
        if index == start + settings.showamount - 1 and not showall and
            not showrest then ass:append(settings.playlist_sliced_suffix) end
    end
    local w, h = mp.get_osd_size()
    if settings.scale_playlist_by_window then w, h = 0, 0 end
    mp.set_osd_ass(w, h, ass.text)
end

function toggle_playlist()
    if settings.open_toggles then
        if playlist_visible then
            remove_keybinds()
            return
        end
    end
    showplaylist()
end

function showplaylist(duration)
    refresh_globals()
    if plen == 0 then return end
    playlist_visible = true
    add_keybinds()

    draw_playlist()
    keybindstimer:kill()
    if duration then
        keybindstimer = mp.add_periodic_timer(duration, remove_keybinds)
    else
        keybindstimer:resume()
    end
end

selection = nil
function selectfile()
    refresh_globals()
    if plen == 0 then return end
    if not selection then
        selection = cursor
    else
        selection = nil
    end
    showplaylist()
end

function unselectfile()
    selection = nil
    showplaylist()
end

function removefile()
    refresh_globals()
    if plen == 0 then return end
    selection = nil
    if cursor == pos then
        mp.command(
            "script-message unseenplaylist mark true \"playlistmanager avoid conflict when removing file\"")
    end
    mp.commandv("playlist-remove", cursor)
    if cursor == plen - 1 then cursor = cursor - 1 end
    showplaylist()
end

function moveup()
    refresh_globals()
    if plen == 0 then return end
    if cursor ~= 0 then
        if selection then
            mp.commandv("playlist-move", cursor, cursor - 1)
        end
        cursor = cursor - 1
    elseif settings.loop_cursor then
        if selection then mp.commandv("playlist-move", cursor, plen) end
        cursor = plen - 1
    end
    showplaylist()
end

function movedown()
    refresh_globals()
    if plen == 0 then return end
    if cursor ~= plen - 1 then
        if selection then
            mp.commandv("playlist-move", cursor, cursor + 2)
        end
        cursor = cursor + 1
    elseif settings.loop_cursor then
        if selection then mp.commandv("playlist-move", cursor, 0) end
        cursor = 0
    end
    showplaylist()
end

function Watch_later()
    if mp.get_property_bool("save-position-on-quit") then
        mp.command("write-watch-later-config")
    end
end

function playfile()
    refresh_globals()
    if plen == 0 then return end
    selection = nil
    local is_idle = mp.get_property_native('idle-active')
    if cursor ~= pos or is_idle then
        mp.set_property("playlist-pos", cursor)
    else
        if cursor ~= plen - 1 then cursor = cursor + 1 end
        Watch_later()
        mp.commandv("playlist-next", "weak")
    end
    if settings.show_playlist_on_fileload ~= 2 then remove_keybinds() end
end

function get_files_windows(dir)
    local args = {
        'powershell', '-NoProfile', '-Command', [[& {
          Trap {
              Write-Error -ErrorRecord $_
              Exit 1
          }
          $path = "]] .. dir .. [["
          $escapedPath = [WildcardPattern]::Escape($path)
          cd $escapedPath

          $list = (Get-ChildItem -File | Sort-Object { [regex]::Replace($_.Name, '\d+', { $args[0].Value.PadLeft(20) }) }).Name
          $string = ($list -join "/")
          $u8list = [System.Text.Encoding]::UTF8.GetBytes($string)
          [Console]::OpenStandardOutput().Write($u8list, 0, $u8list.Length)
      }]]
    }
    local process = utils.subprocess({args = args, cancellable = false})
    return parse_files(process, '%/')
end

function get_files_linux(dir)
    local args = {'ls', '-1pv', dir}
    local process = utils.subprocess({args = args, cancellable = false})
    return parse_files(process, '\n')
end

function parse_files(res, delimiter)
    if not res.error and res.status == 0 then
        local valid_files = {}
        for line in res.stdout:gmatch("[^" .. delimiter .. "]+") do
            local ext = line:match("^.+%.(.+)$")
            if ext and filetype_lookup[ext:lower()] then
                table.insert(valid_files, line)
            end
        end
        return valid_files, nil
    else
        return nil, res.error
    end
end

-- Creates a playlist of all files in directory, will keep the order and position
-- For exaple, Folder has 12 files, you open the 5th file and run this, the remaining 7 are added behind the 5th file and prior 4 files before it
function playlist(force_dir)
    refresh_globals()
    if not directory and plen > 0 then return end
    local hasfile = true
    if plen == 0 then
        hasfile = false
        dir = mp.get_property('working-directory')
    else
        dir = directory
    end
    if force_dir then dir = force_dir end

    local files, error
    if settings.system == "linux" then
        files, error = get_files_linux(dir)
    else
        files, error = get_files_windows(dir)
    end

    local c, c2 = 0, 0
    if files then
        local cur = false
        local filename = mp.get_property("filename")
        for _, file in ipairs(files) do
            local appendstr = "append"
            if not hasfile then
                cur = true
                appendstr = "append-play"
                hasfile = true
            end
            if cur == true then
                mp.commandv("loadfile", utils.join_path(dir, file), appendstr)
                msg.info("Appended to playlist: " .. file)
                c2 = c2 + 1
            elseif file ~= filename then
                mp.commandv("loadfile", utils.join_path(dir, file), appendstr)
                msg.info("Prepended to playlist: " .. file)
                mp.commandv("playlist-move",
                            mp.get_property_number("playlist-count", 1) - 1, c)
                c = c + 1
            else
                cur = true
            end
        end
        if c2 > 0 or c > 0 then
            mp.osd_message("Added " .. c + c2 .. " files to playlist")
        else
            mp.osd_message("No additional files found")
        end
        cursor = mp.get_property_number('playlist-pos', 1)
    else
        msg.error("Could not scan for files: " .. (error or ""))
    end
    if sort_watching then
        msg.info("Ignoring directory structure and using playlist sort")
        sortplaylist()
    end
    refresh_globals()
    if playlist_visible then showplaylist() end
    return c + c2
end

function parse_home(path)
    if not path:find("^~") then return path end
    local home_dir = os.getenv("HOME") or os.getenv("USERPROFILE")
    if not home_dir then
        local drive = os.getenv("HOMEDRIVE")
        local path = os.getenv("HOMEPATH")
        if drive and path then
            home_dir = utils.join_path(drive, path)
        else
            msg.error("Couldn't find home dir.")
            return nil
        end
    end
    local result = path:gsub("^~", home_dir)
    return result
end

-- saves the current playlist into a m3u file
function save_playlist()
    local length = mp.get_property_number('playlist-count', 0)
    if length == 0 then return end

    -- get playlist save path
    local savepath
    if settings.playlist_savepath == nil or settings.playlist_savepath == "" then
        savepath = mp.command_native({"expand-path", "~~home/"}) .. "/playlists"
    else
        savepath = parse_home(settings.playlist_savepath)
        if savepath == nil then return end
    end

    -- create savepath if it doesn't exist
    if utils.readdir(savepath) == nil then
        local windows_args = {
            'powershell', '-NoProfile', '-Command', 'mkdir', savepath
        }
        local unix_args = {'mkdir', savepath}
        local args = settings.system == 'windows' and windows_args or unix_args
        local res = utils.subprocess({args = args, cancellable = false})
        if res.status ~= 0 then
            msg.error("Failed to create playlist save directory " .. savepath ..
                          ". Error: " .. (res.error or "unknown"))
            return
        end
    end

    local date = os.date("*t")
    local datestring = ("%02d-%02d-%02d_%02d-%02d-%02d"):format(date.year,
                                                                date.month,
                                                                date.day,
                                                                date.hour,
                                                                date.min,
                                                                date.sec)

    local savepath = utils.join_path(savepath,
                                     datestring .. "_playlist-size_" .. length ..
                                         ".m3u")
    local file, err = io.open(savepath, "w")
    if not file then
        msg.error(
            "Error in creating playlist file, check permissions. Error: " ..
                (err or "unknown"))
    else
        local i = 0
        while i < length do
            local pwd = mp.get_property("working-directory")
            local filename = mp.get_property('playlist/' .. i .. '/filename')
            local fullpath = filename
            if not filename:match("^%a%a+:%/%/") then
                fullpath = utils.join_path(pwd, filename)
            end
            local title = mp.get_property('playlist/' .. i .. '/title')
            if title then file:write("#EXTINF:," .. title .. "\n") end
            file:write(fullpath, "\n")
            i = i + 1
        end
        msg.info("Playlist written to: " .. savepath)
        file:close()
    end
end

function alphanumsort(a, b)
    local function padnum(d)
        local dec, n = string.match(d, "(%.?)0*(.+)")
        return #dec > 0 and ("%.12f"):format(d) or
                   ("%s%03d%s"):format(dec, #n, n)
    end
    return tostring(a):lower():gsub("%.?%d+", padnum) .. ("%3d"):format(#b) <
               tostring(b):lower():gsub("%.?%d+", padnum) .. ("%3d"):format(#a)
end

function dosort(a, b)
    if settings.alphanumsort then
        return alphanumsort(a, b)
    else
        return a < b
    end
end

function sortplaylist(startover)
    local length = mp.get_property_number('playlist-count', 0)
    if length < 2 then return end
    -- use insertion sort on playlist to make it easy to order files with playlist-move
    for outer = 1, length - 1, 1 do
        local outerfile = get_name_from_index(outer, true)
        local inner = outer - 1
        while inner >= 0 and dosort(outerfile, get_name_from_index(inner, true)) do
            inner = inner - 1
        end
        inner = inner + 1
        if outer ~= inner then mp.commandv('playlist-move', outer, inner) end
    end
    cursor = mp.get_property_number('playlist-pos', 0)
    if startover then mp.set_property('playlist-pos', 0) end
    if playlist_visible then showplaylist() end
end

function autosort(name, param)
    if param == 0 then return end
    if plen < param then
        msg.info("Playlistmanager autosorting playlist")
        refresh_globals()
        sortplaylist()
    end
end

function reverseplaylist()
    local length = mp.get_property_number('playlist-count', 0)
    if length < 2 then return end
    for outer = 1, length - 1, 1 do mp.commandv('playlist-move', outer, 0) end
    if playlist_visible then showplaylist() end
end

function shuffleplaylist()
    refresh_globals()
    if plen < 2 then return end
    mp.command("playlist-shuffle")
    math.randomseed(os.time())
    mp.commandv("playlist-move", pos, math.random(0, plen - 1))
    mp.set_property('playlist-pos', 0)
    refresh_globals()
    if playlist_visible then showplaylist() end
end

function bind_keys(keys, name, func, opts)
    if not keys then
        mp.add_forced_key_binding(keys, name, func, opts)
        return
    end
    local i = 1
    for key in keys:gmatch("[^%s]+") do
        local prefix = i == 1 and '' or i
        mp.add_forced_key_binding(key, name .. prefix, func, opts)
        i = i + 1
    end
end

function unbind_keys(keys, name)
    if not keys then
        mp.remove_key_binding(name)
        return
    end
    local i = 1
    for key in keys:gmatch("[^%s]+") do
        local prefix = i == 1 and '' or i
        mp.remove_key_binding(name .. prefix)
        i = i + 1
    end
end

function add_keybinds()
    bind_keys(settings.key_moveup, 'moveup', moveup, "repeatable")
    bind_keys(settings.key_movedown, 'movedown', movedown, "repeatable")
    bind_keys(settings.key_selectfile, 'selectfile', selectfile)
    bind_keys(settings.key_unselectfile, 'unselectfile', unselectfile)
    bind_keys(settings.key_playfile, 'playfile', playfile)
    bind_keys(settings.key_removefile, 'removefile', removefile, "repeatable")
    bind_keys(settings.key_closeplaylist, 'closeplaylist', remove_keybinds)
end

function remove_keybinds()
    keybindstimer:kill()
    keybindstimer = mp.add_periodic_timer(settings.playlist_display_timeout,
                                          remove_keybinds)
    keybindstimer:kill()
    mp.set_osd_ass(0, 0, "")
    playlist_visible = false
    if settings.dynamic_binds then
        unbind_keys(settings.key_moveup, 'moveup')
        unbind_keys(settings.key_movedown, 'movedown')
        unbind_keys(settings.key_selectfile, 'selectfile')
        unbind_keys(settings.key_unselectfile, 'unselectfile')
        unbind_keys(settings.key_playfile, 'playfile')
        unbind_keys(settings.key_removefile, 'removefile')
        unbind_keys(settings.key_closeplaylist, 'closeplaylist')
    end
end

keybindstimer = mp.add_periodic_timer(settings.playlist_display_timeout,
                                      remove_keybinds)
keybindstimer:kill()

if not settings.dynamic_binds then add_keybinds() end

if settings.loadfiles_on_start and mp.get_property_number('playlist-count', 0) ==
    0 then playlist() end

promised_sort_watch = false
if settings.sortplaylist_on_file_add then promised_sort_watch = true end

promised_sort = false
if settings.sortplaylist_on_start then promised_sort = true end

mp.observe_property('playlist-count', "number", function()
    if playlist_visible then showplaylist() end
    if settings.prefer_titles == 'none' then return end
    -- resolve titles
    resolve_titles()
end)

-- resolves url titles by calling youtube-dl
function resolve_titles()
    if not settings.resolve_titles then return end
    local length = mp.get_property_number('playlist-count', 0)
    if length < 2 then return end
    local i = 0
    -- loop all items in playlist because we can't predict how it has changed
    while i < length do
        local filename = mp.get_property('playlist/' .. i .. '/filename')
        local title = mp.get_property('playlist/' .. i .. '/title')
        if i ~= pos and filename and filename:match('^https?://') and not title and
            not url_table[filename] and not requested_urls[filename] then
            requested_urls[filename] = true

            local args = {
                'youtube-dl', '--no-playlist', '--flat-playlist', '-sJ',
                filename
            }
            local req = mp.command_native_async(
                            {
                    name = "subprocess",
                    args = args,
                    playback_only = false,
                    capture_stdout = true
                }, function(success, res)
                    if res.killed_by_us then
                        msg.verbose(
                            'Request to resolve url title ' .. filename ..
                                ' timed out')
                        return
                    end
                    if res.status == 0 then
                        local json, err = utils.parse_json(res.stdout)
                        if not err then
                            local is_playlist =
                                json['_type'] and json['_type'] == 'playlist'
                            local title =
                                (is_playlist and '[playlist]: ' or '') ..
                                    json['title']
                            msg.verbose(filename .. " resolved to '" .. title ..
                                            "'")
                            url_table[filename] = title
                            refresh_globals()
                            if playlist_visible then
                                showplaylist()
                            end
                            return
                        else
                            msg.error("Failed parsing json, reason: " ..
                                          (err or "unknown"))
                        end
                    else
                        msg.error("Failed to resolve url title " .. filename ..
                                      " Error: " .. (res.error or "unknown"))
                    end
                end)

            mp.add_timeout(5, function() mp.abort_async_command(req) end)

        end
        i = i + 1
    end
end

-- script message handler
function handlemessage(msg, value, value2)
    if msg == "show" and value == "playlist" then
        if value2 ~= "toggle" then
            showplaylist(value2)
            return
        else
            toggle_playlist()
            return
        end
    end
    if msg == "show" and value == "filename" and strippedname and value2 then
        mp.commandv('show-text', strippedname, tonumber(value2) * 1000);
        return
    end
    if msg == "show" and value == "filename" and strippedname then
        mp.commandv('show-text', strippedname);
        return
    end
    if msg == "sort" then
        sortplaylist(value);
        return
    end
    if msg == "shuffle" then
        shuffleplaylist();
        return
    end
    if msg == "reverse" then
        reverseplaylist();
        return
    end
    if msg == "loadfiles" then
        playlist(value);
        return
    end
    if msg == "save" then
        save_playlist();
        return
    end
end

mp.register_script_message("playlistmanager", handlemessage)

mp.add_key_binding("CTRL+p", "sortplaylist", sortplaylist)
mp.add_key_binding("CTRL+P", "shuffleplaylist", shuffleplaylist)
mp.add_key_binding("CTRL+R", "reverseplaylist", reverseplaylist)
mp.add_key_binding("P", "loadfiles", playlist)
mp.add_key_binding("p", "saveplaylist", save_playlist)
mp.add_key_binding("SHIFT+ENTER", "showplaylist", toggle_playlist)

mp.register_event("file-loaded", on_loaded)
mp.register_event("end-file", on_closed)