"use strict";
(function main_default_js(g) {
// - g is the global object.
// - User callbacks called without 'this', global only if callee is non-strict.
// - The names of function expressions are not required, but are used in stack
//   traces. We name them where useful to show up (fname:#line always shows).

mp.msg = { log: mp.log };
mp.msg.verbose = mp.log.bind(null, "v");
var levels = ["fatal", "error", "warn", "info", "debug", "trace"];
levels.forEach(function(l) { mp.msg[l] = mp.log.bind(null, l) });

// same as {} but without inherited stuff, e.g. o["toString"] doesn't exist.
// used where we try to fetch items by keys which we don't absolutely trust.
function new_cache() {
    return Object.create(null, {});
}

/**********************************************************************
 *  event handlers, property observers, idle, client messages, hooks, async
 *********************************************************************/
var ehandlers = new_cache() // items of event-name: array of {maybe cb: fn}

mp.register_event = function(name, fn) {
    if (!ehandlers[name])
        ehandlers[name] = [];
    ehandlers[name] = ehandlers[name].concat([{cb: fn}]);  // replaces the arr
    return mp._request_event(name, true);
}

mp.unregister_event = function(fn) {
    for (var name in ehandlers) {
        ehandlers[name] = ehandlers[name].filter(function(h) {
                              if (h.cb != fn)
                                  return true;
                              delete h.cb;  // dispatch could have a ref to h
                          });  // replacing, not mutating the array
        if (!ehandlers[name].length) {
            delete ehandlers[name];
            mp._request_event(name, false);
        }
    }
}

// call only pre-registered handlers, but not ones which got unregistered
function dispatch_event(e) {
    var handlers = ehandlers[e.event];
    if (handlers) {
        for (var len = handlers.length, i = 0; i < len; i++) {
            var cb = handlers[i].cb;  // 'handlers' won't mutate, but unregister
            if (cb)                   // could remove cb from some items
                cb(e);
        }
    }
}

//  ----- idle observers -----
var iobservers = [],  // array of callbacks
    ideleted = false;

mp.register_idle = function(fn) {
    iobservers.push(fn);
}

mp.unregister_idle = function(fn) {
    iobservers.forEach(function(f, i) {
        if (f == fn)
             delete iobservers[i];  // -> same length but [more] sparse
    });
    ideleted = true;
}

function notify_idle_observers() {
    // forEach and filter skip deleted items and newly added items
    iobservers.forEach(function(f) { f() });
    if (ideleted) {
        iobservers = iobservers.filter(function() { return true });
        ideleted = false;
    }
}

//  ----- property observers -----
var next_oid = 1,
    observers = new_cache();  // items of id: fn

mp.observe_property = function(name, format, fn) {
    var id = next_oid++;
    observers[id] = fn;
    return mp._observe_property(id, name, format || undefined);  // allow null
}

mp.unobserve_property = function(fn) {
    for (var id in observers) {
        if (observers[id] == fn) {
            delete observers[id];
            mp._unobserve_property(id);
        }
    }
}

function notify_observer(e) {
    var cb = observers[e.id];
    if (cb)
        cb(e.name, e.data);
}

//  -----  Client messages -----
var messages = new_cache();  // items of name: fn

// overrides name. no libmpv API to reg/unreg specific messages.
mp.register_script_message = function(name, fn) {
    messages[name] = fn;
}

mp.unregister_script_message = function(name) {
    delete messages[name];
}

function dispatch_message(ev) {
    var cb = ev.args.length ? messages[ev.args[0]] : false;
    if (cb)
        cb.apply(null, ev.args.slice(1));
}

//  ----- hooks -----
var hooks = [];  // array of callbacks, id is index+1

function run_hook(ev) {
    var state = 0;  // 0:initial, 1:deferred, 2:continued
    function do_cont() { return state = 2, mp._hook_continue(ev.hook_id) }

    function err() { return mp.msg.error("hook already continued"), undefined }
    function usr_defer() { return state == 2 ? err() : (state = 1, true) }
    function usr_cont()  { return state == 2 ? err() : do_cont() }

    var cb = ev.id > 0 && hooks[ev.id - 1];
    if (cb)
        cb({ defer: usr_defer, cont: usr_cont });
    return state == 0 ? do_cont() : true;
}

mp.add_hook = function add_hook(name, pri, fn) {
    hooks.push(fn);
    // 50 (scripting docs default priority) maps to 0 (default in C API docs)
    return mp._hook_add(name, pri - 50, hooks.length);
}

// ----- async commands -----
var async_callbacks = new_cache();  // items of id: fn
var async_next_id = 1;

mp.command_native_async = function command_native_async(node, cb) {
    var id = async_next_id++;
    cb = cb || function dummy() {};
    if (!mp._command_native_async(id, node)) {
        var le = mp.last_error();
        setTimeout(cb, 0, false, undefined, le);  /* callback async */
        mp._set_last_error(le);
        return undefined;
    }
    async_callbacks[id] = cb;
    return id;
}

function async_command_handler(ev) {
    var cb = async_callbacks[ev.id];
    delete async_callbacks[ev.id];
    if (ev.error)
        cb(false, undefined, ev.error);
    else
        cb(true, ev.result, "");
}

mp.abort_async_command = function abort_async_command(id) {
    // cb will be invoked regardless, possibly with the abort result
    if (async_callbacks[id])
        mp._abort_async_command(id);
}

// osd-ass
var next_assid = 1;
mp.create_osd_overlay = function create_osd_overlay(format) {
    return {
        format: format || "ass-events",
        id: next_assid++,
        data: "",
        res_x: 0,
        res_y: 720,
        z: 0,

        update: function ass_update() {
            var cmd = {};  // shallow clone of `this', excluding methods
            for (var k in this) {
                if (typeof this[k] != "function")
                    cmd[k] = this[k];
            }

            cmd.name = "osd-overlay";
            cmd.res_x = Math.round(this.res_x);
            cmd.res_y = Math.round(this.res_y);

            return mp.command_native(cmd);
        },

        remove: function ass_remove() {
            mp.command_native({
                name: "osd-overlay",
                id: this.id,
                format: "none",
                data: "",
            });
            return mp.last_error() ? undefined : true;
        },
    };
}

// osd-ass legacy API
mp.set_osd_ass = function set_osd_ass(res_x, res_y, data) {
    if (!mp._legacy_overlay)
        mp._legacy_overlay = mp.create_osd_overlay("ass-events");

    var lo = mp._legacy_overlay;
    if (lo.res_x == res_x && lo.res_y == res_y && lo.data == data)
        return true;

    mp._legacy_overlay.res_x = res_x;
    mp._legacy_overlay.res_y = res_y;
    mp._legacy_overlay.data = data;
    return mp._legacy_overlay.update();
}

// the following return undefined on error, null passthrough, or legacy object
mp.get_osd_size = function get_osd_size() {
    var d = mp.get_property_native("osd-dimensions");
    return d && {width: d.w, height: d.h, aspect: d.aspect};
}
mp.get_osd_margins = function get_osd_margins() {
    var d = mp.get_property_native("osd-dimensions");
    return d && {left: d.ml, right: d.mr, top: d.mt, bottom: d.mb};
}

/**********************************************************************
 *  key bindings
 *********************************************************************/
// binds: items of (binding) name which are objects of:
// {cb: fn, forced: bool, maybe input: str, repeatable: bool, complex: bool}
var binds = new_cache();

function dispatch_key_binding(name, state, key_name, key_text) {
    var cb = binds[name] ? binds[name].cb : false;
    if (cb)  // "script-binding [<script_name>/]<name>" command was invoked
        cb(state, key_name, key_text);
}

var binds_tid = 0;  // flush timer id. actual id's are always true-thy
mp.flush_key_bindings = function flush_key_bindings() {
    function prioritized_inputs(arr) {
        return arr.sort(function(a, b) { return a.id - b.id })
                  .map(function(bind) { return bind.input });
    }

    var def = [], forced = [];
    for (var n in binds)
        if (binds[n].input)
            (binds[n].forced ? forced : def).push(binds[n]);
    // newer bindings for the same key override/hide older ones
    def = prioritized_inputs(def);
    forced = prioritized_inputs(forced);

    var sect = "input_" + mp.script_name;
    mp.commandv("define-section", sect, def.join("\n"), "default");
    mp.commandv("enable-section", sect, "allow-hide-cursor+allow-vo-dragging");

    sect = "input_forced_" + mp.script_name;
    mp.commandv("define-section", sect, forced.join("\n"), "force");
    mp.commandv("enable-section", sect, "allow-hide-cursor+allow-vo-dragging");

    clearTimeout(binds_tid);  // cancel future flush if called directly
    binds_tid = 0;
}

function sched_bindings_flush() {
    if (!binds_tid)
        binds_tid = setTimeout(mp.flush_key_bindings, 0);  // fires on idle
}

// name/opts maybe omitted. opts: object with optional bool members: repeatable,
// complex, forced, or a string str which is evaluated as object {str: true}.
var next_bid = 1;
function add_binding(forced, key, name, fn, opts) {
    if (typeof name == "function") {  // as if "name" is not part of the args
        opts = fn;
        fn = name;
        name = false;
    }
    var key_data = {forced: forced};
    switch (typeof opts) {  // merge opts into key_data
        case "string": key_data[opts] = true; break;
        case "object": for (var o in opts) key_data[o] = opts[o];
    }
    key_data.id = next_bid++;
    if (!name)
        name = "__keybinding" + key_data.id;  // new unique binding name

    if (key_data.complex) {
        mp.register_script_message(name, function msg_cb() {
            fn({event: "press", is_mouse: false});
        });
        var KEY_STATES = { u: "up", d: "down", r: "repeat", p: "press" };
        key_data.cb = function key_cb(state, key_name, key_text) {
            fn({
                event: KEY_STATES[state[0]] || "unknown",
                is_mouse: state[1] == "m",
                key_name: key_name || undefined,
                key_text: key_text || undefined
            });
        }
    } else {
        mp.register_script_message(name, fn);
        key_data.cb = function key_cb(state) {
            // Emulate the semantics at input.c: mouse emits on up, kb on down.
            // Also, key repeat triggers the binding again.
            var e = state[0],
                emit = (state[1] == "m") ? (e == "u") : (e == "d");
            if (emit || e == "p" || e == "r" && key_data.repeatable)
                fn();
        }
    }

    if (key)
        key_data.input = key + " script-binding " + mp.script_name + "/" + name;
    binds[name] = key_data;  // used by user and/or our (key) script-binding
    sched_bindings_flush();
}

mp.add_key_binding = add_binding.bind(null, false);
mp.add_forced_key_binding = add_binding.bind(null, true);

mp.remove_key_binding = function(name) {
    mp.unregister_script_message(name);
    delete binds[name];
    sched_bindings_flush();
}

/**********************************************************************
 Timers: compatible HTML5 WindowTimers - set/clear Timeout/Interval
 - Spec: https://www.w3.org/TR/html5/webappapis.html#timers
 - Guaranteed to callback a-sync to [re-]insertion (event-loop wise).
 - Guaranteed to callback by expiration order, or, if equal, by insertion order.
 - Not guaranteed schedule accuracy, though intervals should have good average.
 *********************************************************************/

// pending 'timers' ordered by expiration: latest at index 0 (top fires first).
// Earlier timers are quicker to handle - just push/pop or fewer items to shift.
var next_tid = 1,
    timers = [],  // while in process_timers, just insertion-ordered (push)
    tset_is_push = false,  // signal set_timer that we're in process_timers
    tcanceled = false,  // or object of items timer-id: true
    now = mp.get_time_ms;  // just an alias

function insert_sorted(arr, t) {
    for (var i = arr.length - 1; i >= 0 && t.when >= arr[i].when; i--)
        arr[i + 1] = arr[i];  // move up timers which fire earlier than t
    arr[i + 1] = t;  // i is -1 or fires later than t
}

// args (is "arguments"): fn_or_str [,duration [,user_arg1 [, user_arg2 ...]]]
function set_timer(repeat, args) {
    var fos = args[0],
        duration = Math.max(0, (args[1] || 0)),  // minimum and default are 0
        t = {
            id: next_tid++,
            when: now() + duration,
            interval: repeat ? duration : -1,
            callback: (typeof fos == "function") ? fos : Function(fos),
            args: (args.length < 3) ? false : [].slice.call(args, 2),
        };

    if (tset_is_push) {
        timers.push(t);
    } else {
        insert_sorted(timers, t);
    }
    return t.id;
}

g.setTimeout  = function setTimeout()  { return set_timer(false, arguments) };
g.setInterval = function setInterval() { return set_timer(true,  arguments) };

g.clearTimeout = g.clearInterval = function(id) {
    if (id < next_tid) {  // must ignore if not active timer id.
        if (!tcanceled)
            tcanceled = {};
        tcanceled[id] = true;
    }
}

// arr: ordered timers array. ret: -1: no timers, 0: due, positive: ms to wait
function peek_wait(arr) {
    return arr.length ? Math.max(0, arr[arr.length - 1].when - now()) : -1;
}

function peek_timers_wait() {
    return peek_wait(timers);  // must not be called while in process_timers
}

// Callback all due non-canceled timers which were inserted before calling us.
// Returns wait in ms till the next timer (possibly 0), or -1 if nothing pends.
function process_timers() {
    var wait = peek_wait(timers);
    if (wait != 0)
        return wait;

    var actives = timers;  // only process those already inserted by now
    timers = [];  // we'll handle added new timers at the end of processing.
    tset_is_push = true;  // signal set_timer to just push-insert

    do {
        var t = actives.pop();
        if (tcanceled && tcanceled[t.id])
            continue;

        if (t.args) {
            t.callback.apply(null, t.args);
        } else {
            (0, t.callback)();  // faster, nicer stack trace than t.cb.call()
        }

        if (t.interval >= 0) {
            // allow 20 ms delay/clock-resolution/gc before we skip and reset
            t.when = Math.max(now() - 20, t.when + t.interval);
            timers.push(t);  // insertion order only
        }
    } while (peek_wait(actives) == 0);

    // new 'timers' are insertion-ordered. remains of actives are fully ordered
    timers.forEach(function(t) { insert_sorted(actives, t) });
    timers = actives;  // now we're fully ordered again, and with all timers
    tset_is_push = false;
    if (tcanceled) {
        timers = timers.filter(function(t) { return !tcanceled[t.id] });
        tcanceled = false;
    }
    return peek_wait(timers);
}

/**********************************************************************
 CommonJS module/require

 Spec: http://wiki.commonjs.org/wiki/Modules/1.1.1
 - All the mandatory requirements are implemented, all the unit tests pass.
 - The implementation makes the following exception:
   - Allows the chars [~@:\\] in module id for meta-dir/builtin/dos-drive/UNC.

 Implementation choices beyond the specification:
 - A module may assign to module.exports (rather than only to exports).
 - A module's 'this' is the global object, also if it sets strict mode.
   - No 'global'/'self'. Users can do "this.global = this;" before require(..)
   - A module has "privacy of its top scope", runs in its own function context.
 - No id identity with symlinks - a valid choice which others make too.
 - require("X") always maps to "X.js" -> require("foo.js") is file "foo.js.js".
 - Global modules search paths are 'scripts/modules.js/' in mpv config dirs.
 - A main script could e.g. require("./abc") to load a non-global module.
 - Module id supports mpv path enhancements, e.g. ~/foo, ~~/bar, ~~desktop/baz
 *********************************************************************/

mp.module_paths = [];  // global modules search paths
if (mp.script_path !== undefined)  // loaded as a directory
    mp.module_paths.push(mp.utils.join_path(mp.script_path, "modules"));

// Internal meta top-dirs. Users should not rely on these names.
var MODULES_META = "~~modules",
    SCRIPTDIR_META = "~~scriptdir",  // relative script path -> meta absolute id
    main_script = mp.utils.split_path(mp.script_file);  // -> [ path, file ]

function resolve_module_file(id) {
    var sep = id.indexOf("/"),
        base = id.substring(0, sep),
        rest = id.substring(sep + 1) + ".js";

    if (base == SCRIPTDIR_META)
        return mp.utils.join_path(main_script[0], rest);

    if (base == MODULES_META) {
        for (var i = 0; i < mp.module_paths.length; i++) {
            try {
                var f = mp.utils.join_path(mp.module_paths[i], rest);
                mp.utils.read_file(f, 1);  // throws on any error
                return f;
            } catch (e) {}
        }
        throw(Error("Cannot find module file '" + rest + "'"));
    }

    return id + ".js";
}

// Delimiter '/', remove redundancies, prefix with modules meta-root if needed.
// E.g. c:\x -> c:/x, or ./x//y/../z -> ./x/z, or utils/x -> ~~modules/utils/x .
function canonicalize(id) {
    var path = id.replace(/\\/g,"/").split("/"),
        t = path[0],
        base = [];

    // if not strictly relative then must be top-level. figure out base/rest
    if (t != "." && t != "..") {
        // global module if it's not fs-root/home/dos-drive/builtin/meta-dir
        if (!(t == "" || t == "~" || t[1] == ":" ||  t == "@" || t.match(/^~~/)))
            path.unshift(MODULES_META);  // add an explicit modules meta-root

        if (id.match(/^\\\\/))  // simple UNC handling, preserve leading \\srv
            path = ["\\\\" + path[2]].concat(path.slice(3));  // [ \\srv, shr..]

        if (t[1] == ":" && t.length > 2) {  // path: [ "c:relative", "path" ]
            path[0] = t.substring(2);
            path.unshift(t[0] + ":.");  //  ->  [ "c:.", "relative", "path" ]
        }
        base = [path.shift()];
    }

    // path is now logically relative. base, if not empty, is its [meta] root.
    // normalize the relative part - always id-based (spec Module Id, 1.3.6).
    var cr = [];  // canonicalized relative
    for (var i = 0; i < path.length; i++) {
        if (path[i] == "." || path[i] == "")
            continue;
        if (path[i] == ".." && cr.length && cr[cr.length - 1] != "..") {
            cr.pop();
            continue;
        }
        cr.push(path[i]);
    }

    if (!base.length && cr[0] != "..")
        base = ["."];  // relative and not ../<stuff> so must start with ./
    return base.concat(cr).join("/");
}

function resolve_module_id(base_id, new_id) {
    new_id = canonicalize(new_id);
    if (!new_id.match(/^\.\/|^\.\.\//))  // doesn't start with ./ or ../
        return new_id;  // not relative, we don't care about base_id

    var combined = mp.utils.join_path(mp.utils.split_path(base_id)[0], new_id);
    return canonicalize(combined);
}

var req_cache = new_cache();  // global for all instances of require

// ret: a require function instance which uses base_id to resolve relative id's
function new_require(base_id) {
    return function require(id) {
        id = resolve_module_id(base_id, id);  // id is now top-level
        if (req_cache[id])
            return req_cache[id].exports;

        var new_module = {id: id, exports: {}};
        req_cache[id] = new_module;
        try {
            var filename = resolve_module_file(id);
            // we need dedicated free vars + filename in traces + allow strict
            var str = "mp._req = function(require, exports, module) {" +
                          mp.utils.read_file(filename) +
                      "\n;}";
            mp.utils.compile_js(filename, str)();  // only runs the assignment
            var tmp = mp._req;  // we have mp._req, or else we'd have thrown
            delete mp._req;
            tmp.call(g, new_require(id), new_module.exports, new_module);
        } catch (e) {
            delete req_cache[id];
            throw(e);
        }

        return new_module.exports;
    };
}

g.require = new_require(SCRIPTDIR_META + "/" + main_script[1]);

/**********************************************************************
 *  mp.options
 *********************************************************************/
function read_options(opts, id, on_update, conf_override) {
    id = String(id ? id : mp.get_script_name());
    mp.msg.debug("reading options for " + id);

    var conf, fname = "~~/script-opts/" + id + ".conf";
    try {
        conf = arguments.length > 3 ? conf_override : mp.utils.read_file(fname);
    } catch (e) {
        mp.msg.verbose(fname + " not found.");
    }

    // data as config file lines array, or empty array
    var data = conf ? conf.replace(/\r\n/g, "\n").split("\n") : [],
        conf_len = data.length;  // before we append script-opts below

    // Append relevant script-opts as <key-sans-id>=<value> to data
    var sopts = mp.get_property_native("options/script-opts"),
        prefix = id + "-";
    for (var key in sopts) {
        if (key.indexOf(prefix) == 0)
            data.push(key.substring(prefix.length) + "=" + sopts[key]);
    }

    // Update opts from data
    data.forEach(function(line, i) {
        if (line[0] == "#" || line.trim() == "")
            return;

        var key = line.substring(0, line.indexOf("=")),
            val = line.substring(line.indexOf("=") + 1),
            type = typeof opts[key],
            info = i < conf_len ? fname + ":" + (i + 1)  // 1-based line number
                                : "script-opts:" + prefix + key;

        if (!opts.hasOwnProperty(key))
            mp.msg.warn(info, "Ignoring unknown key '" + key + "'");
        else if (type == "string")
            opts[key] = val;
        else if (type == "boolean" && (val == "yes" || val == "no"))
            opts[key] = (val == "yes");
        else if (type == "number" && val.trim() != "" && !isNaN(val))
            opts[key] = Number(val);
        else
            mp.msg.error(info, "Error: can't convert '" + val + "' to " + type);
    });

    if (on_update) {
        mp.observe_property("options/script-opts", "native", function(_n, _v) {
            var saved = JSON.parse(JSON.stringify(opts));  // clone
            var changelist = {}, changed = false;
            read_options(opts, id, 0, conf);  // re-apply orig-file + script-opts
            for (var key in opts) {
                if (opts[key] != saved[key])  // type always stays the same
                    changelist[key] = changed = true;
            }
            if (changed)
                on_update(changelist);
        });
    }
}

mp.options = { read_options: read_options };

/**********************************************************************
*  input
*********************************************************************/
mp.input = {
    get: function(t) {
        mp.commandv("script-message-to", "console", "get-input", mp.script_name,
                    JSON.stringify({
                        prompt: t.prompt,
                        default_text: t.default_text,
                        cursor_position: t.cursor_position,
                        id: t.id,
                    }));

        mp.register_script_message("input-event", function (type, text, cursor_position) {
            if (t[type]) {
                var result = t[type](text, cursor_position);

                if (type == "complete" && result) {
                    mp.commandv("script-message-to", "console", "complete",
                                JSON.stringify(result[0]), result[1]);
                }
            }

            if (type == "closed") {
                mp.unregister_script_message("input-event");
            }
        })

        return true;
    },
    terminate: function () {
        mp.commandv("script-message-to", "console", "disable");
    },
    log: function (message, style, terminal_style) {
        mp.commandv("script-message-to", "console", "log", JSON.stringify({
                        text: message,
                        style: style,
                        terminal_style: terminal_style,
                   }));
    },
    log_error: function (message) {
        mp.commandv("script-message-to", "console", "log",
                    JSON.stringify({ text: message, error: true }));
    },
    set_log: function (log) {
        mp.commandv("script-message-to", "console", "set-log",
                    JSON.stringify(log));
    }
}

/**********************************************************************
 *  various
 *********************************************************************/
g.print = mp.msg.info;  // convenient alias
mp.get_script_name = function() { return mp.script_name };
mp.get_script_file = function() { return mp.script_file };
mp.get_script_directory = function() { return mp.script_path };
mp.get_time = function() { return mp.get_time_ms() / 1000 };
mp.utils.getcwd = function() { return mp.get_property("working-directory") };
mp.utils.getpid = function() { return mp.get_property_number("pid") }
mp.utils.get_user_path =
    function(p) { return mp.command_native(["expand-path", String(p)]) };
mp.get_mouse_pos = function() { return mp.get_property_native("mouse-pos") };
mp.utils.write_file = mp.utils._write_file.bind(null, false);
mp.utils.append_file = mp.utils._write_file.bind(null, true);
mp.dispatch_event = dispatch_event;
mp.process_timers = process_timers;
mp.notify_idle_observers = notify_idle_observers;
mp.peek_timers_wait = peek_timers_wait;

mp.get_opt = function(key, def) {
    var v = mp.get_property_native("options/script-opts")[key];
    return (typeof v != "undefined") ? v : def;
}

mp.osd_message = function osd_message(text, duration) {
    mp.commandv("show_text", text, Math.round(1000 * (duration || -1)));
}

mp.utils.subprocess = function subprocess(t) {
    var cmd = { name: "subprocess", capture_stdout: true };
    var new_names = { cancellable: "playback_only", max_size: "capture_size" };
    for (var k in t)
        cmd[new_names[k] || k] = t[k];

    var rv = mp.command_native(cmd);
    if (mp.last_error())  /* typically on missing/incorrect args */
        rv = { error_string: mp.last_error(), status: -1 };
    if (rv.error_string)
        rv.error = rv.error_string;
    return rv;
}

mp.utils.subprocess_detached = function subprocess_detached(t) {
    return mp.commandv.apply(null, ["run"].concat(t.args));
}


// ----- dump: like print, but expands objects/arrays recursively -----
function replacer(k, v) {
    var t = typeof v;
    if (t == "function" || t == "undefined")
        return "<" + t + ">";
    if (Array.isArray(this) && t == "object" && v !== null) {  // "safe" mode
        if (this.indexOf(v) >= 0)
            return "<VISITED>";
        this.push(v);
    }
    return v;
}

function obj2str(v) {
    try {  // can process objects more than once, but throws on cycles
        return JSON.stringify(v, replacer.bind(null), 2);
    } catch (e) { // simple safe: exclude visited objects, even if not cyclic
        return JSON.stringify(v, replacer.bind([]), 2);
    }
}

g.dump = function dump() {
    var toprint = [];
    for (var i = 0; i < arguments.length; i++) {
        var v = arguments[i];
        toprint.push((typeof v == "object") ? obj2str(v) : replacer(0, v));
    }
    print.apply(null, toprint);
}

/**********************************************************************
 *  main listeners and event loop
 *********************************************************************/
mp.keep_running = true;
g.exit = function() { mp.keep_running = false };  // user-facing too
mp.register_event("shutdown", g.exit);
mp.register_event("property-change", notify_observer);
mp.register_event("hook", run_hook);
mp.register_event("command-reply", async_command_handler);
mp.register_event("client-message", dispatch_message);
mp.register_script_message("key-binding", dispatch_key_binding);

g.mp_event_loop = function mp_event_loop() {
    var wait = 0;  // seconds
    do {  // distapch events as long as they arrive, then do the timers/idle
        var e = mp.wait_event(wait);
        if (e.event != "none") {
            dispatch_event(e);
            wait = 0;  // poll the next one
        } else {
            wait = process_timers() / 1000;
            if (wait != 0 && iobservers.length) {
                notify_idle_observers();  // can add timers -> recalculate wait
                wait = peek_timers_wait() / 1000;
            }
        }
    } while (mp.keep_running);
};


// let the user extend us, e.g. by adding items to mp.module_paths
var initjs = mp.find_config_file("init.js");  // ~~/init.js
if (initjs)
    require(initjs.slice(0, -3));  // remove ".js"
else if ((initjs = mp.find_config_file(".init.js")))
    mp.msg.warn("Use init.js instead of .init.js (ignoring " + initjs + ")");

})(this)