# Multiplayer
# ===========
#
# 1) Display chat messages from other aircraft to
#    the screen using screen.nas
#
# 2) Display a complete history of chat via dialog.
#
# 3) Allow chat messages to be written by the user.


var is_active = func getprop("/sim/multiplay/txport") or getprop("/sim/multiplay/rxport");


var lastmsg = {};

var check_messages = func {
    foreach (var mp; values(model.callsign)) {
        var msg = mp.node.getNode("sim/multiplay/chat", 1).getValue();
        if (msg and msg != lastmsg[mp.callsign])
            echo_message(mp.callsign, msg);
        lastmsg[mp.callsign] = msg;
    }
    settimer(check_messages, 3);
}



var echo_message = func(callsign, msg) {
    # Only prefix with the callsign if the message doesn't already include it.
    if (find(callsign, msg) < 0)
        msg = callsign ~ ": " ~ msg;

    msg = string.trim(string.replace(msg, "\n", " "));
    setprop("/sim/messages/mp-plane", msg);

    # Add the chat to the chat history.
    if (var history = getprop("/sim/multiplay/chat-history")) {
        history = string.trim(history, 0, string.isxspace);
        msg = history ~ "\n" ~ msg;
    }

    setprop("/sim/multiplay/chat-history", msg);
}



settimer(func {
    if (is_active()) {
        if (getprop("/sim/multiplay/write-message-log")) {
            var ac = getprop("/sim/aircraft");
            var cs = getprop("/sim/multiplay/callsign");
            var (date, time) =_= split("T", getprop("/sim/time/gmt"));
            var apt = airportinfo().id;
            var file = string.normpath(getprop("/sim/fg-home") ~ "/mp-message.log");
            var f = io.open(file, "a");
            io.write(f, sprintf("\n-- %s -- %s -- %s -- %s -- '%s' --\n", date, time, apt, ac, cs));
            setlistener("/sim/signals/exit", func io.write(f, "--END--\n") and io.close(f));
            setlistener("/sim/messages/mp-plane", func(n) {
                io.write(f, sprintf("%s: %s\n", getprop("/sim/time/gmt-string"), n.getValue()));
                io.flush(f);
            });
        }
        check_messages();
    }

    # Call-back to ensure we see our own messages.
    setlistener("/sim/multiplay/chat", func(n) {
        echo_message(getprop("/sim/multiplay/callsign"), n.getValue());
    });
}, 1);



# Message composition function, activated using the - key.
var prefix = "Chat Message:";
var input = "";
var kbdlistener = nil;

var compose_message = func(msg = "")
{
  input = prefix ~ msg;
  gui.popupTip(input, 1000000);

  kbdlistener = setlistener("/devices/status/keyboard/event", func (event) {
    var key = event.getNode("key");

    # Only check the key when pressed.
    if (!event.getNode("pressed").getValue())
      return;

    if (handle_key(key.getValue()))
      key.setValue(-1);           # drop key event
  });
}

var handle_key = func(key)
{
  if (key == `\n` or key == `\r`)
  {
    # CR/LF -> send the message

    # Trim off the prefix
    input = substr(input, size(prefix));
    # Send the message and switch off the listener.
    setprop("/sim/multiplay/chat", input);
    removelistener(kbdlistener);
    gui.popdown();
    return 1;
  }
  elsif (key == 8)
  {
    # backspace -> remove a character

    if (size(input) > size(prefix))
    {
      input = substr(input, 0, size(input) - 1);
      gui.popupTip(input, 1000000);
      return 1;
    }
  }
  elsif (key == 27)
  {
    # escape -> cancel
    removelistener(kbdlistener);
    gui.popdown();
    return 1;
  }
  elsif ((key > 31) and (key < 128))
  {
    # Normal character - add it to the input
    input ~= chr(key);
    gui.popupTip(input, 1000000);
    return 1;
  }
  else
  {
    # Unknown character - pass through
    return 0;
  }
}



# multiplayer.dialog.show() -- displays pilot list dialog
#
var PILOTSDLG_RUNNING = 0;

var dialog = {
    init: func(x = nil, y = nil) {
        me.x = x;
        me.y = y;
        me.bg = [0, 0, 0, 0.3];    # background color
        me.fg = [[0.9, 0.9, 0.2, 1], [1, 1, 1, 1], [1, 0.5, 0, 1]]; # alternative active & disabled color
        me.unit = 1;
        me.toggle_unit();          # set to imperial
        #
        # "private"
        var font = { name: "FIXED_8x13" };
        me.header = [" callsign", "model", "brg", func dialog.dist_hdr, func dialog.alt_hdr ~ " "];
        me.columns = [
            { property: "callsign",    format: " %s",    label: "-----------",    halign: "fill" },
            { property: "model-short", format: "%s",     label: "--------------", halign: "fill" },
            { property: "bearing-to",  format: " %3.0f", label: "----",           halign: "right", font: font },
            { property: func dialog.dist_node, format:" %8.2f", label: "---------", halign: "right", font: font },
            { property: func dialog.alt_node,  format:" %7.0f", label: "---------", halign: "right", font: font },
        ];
        me.name = "who-is-online";
        me.dialog = nil;
        me.loopid = 0;

        me.listeners=[];
        append(me.listeners, setlistener("/sim/startup/xsize", func me._redraw_()));
        append(me.listeners, setlistener("/sim/startup/ysize", func me._redraw_()));
        append(me.listeners, setlistener("/sim/signals/reinit-gui", func me._redraw_()));
        append(me.listeners, setlistener("/sim/signals/multiplayer-updated", func me._redraw_()));
    },
    create: func {
        if (me.dialog != nil)
            me.close();

        me.dialog = gui.dialog[me.name] = gui.Widget.new();
        me.dialog.set("name", me.name);
        me.dialog.set("dialog-name", me.name);
        if (me.x != nil)
            me.dialog.set("x", me.x);
        if (me.y != nil)
            me.dialog.set("y", me.y);

        me.dialog.set("layout", "vbox");
        me.dialog.set("default-padding", 0);

        me.dialog.setColor(me.bg[0], me.bg[1], me.bg[2], me.bg[3]);

        var titlebar = me.dialog.addChild("group");
        titlebar.set("layout", "hbox");

        var w = titlebar.addChild("button");
        w.node.setValues({ "pref-width": 16, "pref-height": 16, legend: me.unit_button, default: 0 });
        w.setBinding("nasal", "multiplayer.dialog.toggle_unit(); multiplayer.dialog._redraw_()");

        titlebar.addChild("empty").set("stretch", 1);
        titlebar.addChild("text").set("label", "Pilots: ");

        var p = titlebar.addChild("text");
        p.node.setValues({ label: "---", live: 1, format: "%d", property: "ai/models/num-players" });
        titlebar.addChild("empty").set("stretch", 1);

        var w = titlebar.addChild("button");
        w.node.setValues({ "pref-width": 16, "pref-height": 16, legend: "", default: 0 });
        w.setBinding("nasal", "multiplayer.dialog.del()");

        me.dialog.addChild("hrule");

        var content = me.dialog.addChild("group");
        content.set("layout", "table");
        content.set("default-padding", 0);

        var row = 0;
        var col = 0;
        foreach (var h; me.header) {
            var w = content.addChild("text");
            var l = typeof(h) == "func" ? h() : h;
            w.node.setValues({ "label": l, "row": row, "col": col, halign: me.columns[col].halign });
            w = content.addChild("hrule");
            w.node.setValues({ "row": row + 1, "col": col });
            col += 1;
        }
        row += 2;
        var odd = 1;
        foreach (var mp; model.list) {
            var col = 0;
            var color = mp.available ? me.fg[odd = !odd] : me.fg[2];
            foreach (var column; me.columns) {
                var w = content.addChild("text");
                w.node.setValues(column);
                var p = typeof(column.property) == "func" ? column.property() : column.property;
                w.node.setValues({ row: row, col: col, live: 1, property: mp.root ~ "/" ~ p });
                w.setColor(color[0], color[1], color[2], color[3]);
                col += 1;
            }
            row += 1;
        }
        me.update(me.loopid += 1);
        fgcommand("dialog-new", me.dialog.prop());
        fgcommand("dialog-show", me.dialog.prop());
    },
    update: func(id) {
        id == me.loopid or return;
        var self = geo.aircraft_position();
        foreach (var mp; model.list) {
            var n = mp.node;
            var x = n.getNode("position/global-x").getValue();
            var y = n.getNode("position/global-y").getValue();
            var z = n.getNode("position/global-z").getValue();
            var ac = geo.Coord.new().set_xyz(x, y, z);
            var distance = nil;
            call(func distance = self.distance_to(ac), nil, var err = []);
            if (size(err)) {
            #    debug.printerror(err);
            #    debug.dump(self, ac, mp);
            #    debug.tree(mp.node);
            }

            n.setValues({
                "model-short": mp.available ? mp.model : "[" ~ mp.model ~ "]",
                "bearing-to": self.course_to(ac),
                "distance-to-km": distance / 1000.0,
                "distance-to-nm": distance * M2NM,
                "position/altitude-m": n.getNode("position/altitude-ft").getValue() * FT2M,
            });
        }
        if (PILOTSDLG_RUNNING)
            settimer(func me.update(id), 1, 1);
    },
    _redraw_: func {
        if (me.dialog != nil) {
            me.close();
            me.create();
        }
    },
    toggle_unit: func {
        me.unit = !me.unit;
        if (me.unit) {
            me.alt_node = "position/altitude-m";
            me.alt_hdr = "alt-m";
            me.dist_hdr = "dist-km";
            me.dist_node = "distance-to-km";
            me.unit_button = "IM";
        } else {
            me.alt_node = "position/altitude-ft";
            me.dist_node = "distance-to-nm";
            me.alt_hdr = "alt-ft";
            me.dist_hdr = "dist-nm";
            me.unit_button = "SI";
        }
    },
    close: func {
        fgcommand("dialog-close", me.dialog.prop());
    },
    del: func {
        PILOTSDLG_RUNNING = 0;
        me.close();
        foreach (var l; me.listeners)
            removelistener(l);
        delete(gui.dialog, me.name);
    },
    show: func {
        if (!PILOTSDLG_RUNNING) {
            PILOTSDLG_RUNNING = 1;
            me.init(-2, -2);
            me.create();
            me.update(me.loopid += 1);
        }
    },
    toggle: func {
        if (!PILOTSDLG_RUNNING)
            me.show();
        else
            me.del();
    },
};



# Autonomous singleton class that monitors multiplayer aircraft,
# maintains data in various structures, and raises signal
# "/sim/signals/multiplayer-updated" whenever an aircraft
# joined or left. Available data containers are:
#
#   multiplayer.model.data:        hash, key := /ai/models/* path
#   multiplayer.model.callsign     hash, key := callsign
#   multiplayer.model.list         vector, sorted alphabetically (ASCII, case insensitive)
#   multiplayer.model.available    unsorted list of players with available models
#   multiplayer.model.unavailable  unsorted list of players with unavailable models
#
# All of them contain hash entries of this form:
#
# {
#    callsign: "BiMaus",
#    path: "Aircraft/bo105/Models/bo105.xml",      # relative file path
#    root: "/ai/models/multiplayer[4]",            # root property
#    node: {...},        # root property as props.Node hash
#    model: "bo105",     # model name (extracted from path)
#    available: 2,       # whether the model is installed (0: not inst, 1: AI, 2: regular)
#    sort: "bimaus",     # callsign in lower case (for sorting)
# }
#
var model = {
    init: func {
        me.L = [];
        me.warned = {};
        append(me.L, setlistener("ai/models/model-added", func(n) me.update(n.getValue())));
        append(me.L, setlistener("ai/models/model-removed", func(n) me.update(n.getValue())));
        me.update();
    },
    update: func(n = nil) {
        if (n != nil and props.globals.getNode(n, 1).getName() != "multiplayer")
            return;

        me.data = {};
        me.callsign = {};
        me.available = [];
        me.unavailable = [];

        var fg_root = string.normpath(getprop("/sim/fg-root")) ~ '/';
        foreach (var n; props.globals.getNode("ai/models", 1).getChildren("multiplayer")) {
            if (!n.getNode("valid", 1).getValue())
                continue;

            if ((var callsign = n.getNode("callsign")) == nil or !(callsign = callsign.getValue()))
                continue;

            var path = n.getNode("sim/model/path").getValue();
            var available = 0;
            if (io.stat(string.normpath(fg_root ~ "AI/" ~ path)) != nil)
                available = 1;
            elsif (io.stat(string.normpath(fg_root ~ path)) != nil)
                available = 2;
            elsif (!contains(me.warned, path))
                me.warned[path] = print(debug._error("=== MP model not installed: " ~ path));

            var model = split(".", split("/", path)[-1])[0];
            model = me.remove_suffix(model, "-model");
            model = me.remove_suffix(model, "-anim");

            var root = n.getPath();
            var data = { node: n, callsign: callsign, model: model, root: root,
                    sort: string.lc(callsign), available: available };

            me.data[root] = data;
            me.callsign[callsign] = data;
            append(available ? me.available : me.unavailable, data);
        }

        me.list = sort(keys(me.data), func(a, b) cmp(me.data[a].sort, me.data[b].sort));
        forindex (var i; me.list)
            me.list[i] = me.data[me.list[i]];

        setprop("ai/models/num-players", size(me.list));
        setprop("sim/signals/multiplayer-updated", 1);
    },
    remove_suffix: func(s, x) {
        var len = size(x);
        if (substr(s, -len) == x)
            return substr(s, 0, size(s) - len);
        return s;
    },
};


_setlistener("sim/signals/nasal-dir-initialized", func model.init());