channel.uc

import * as struct from "struct";
import * as crypto from "crypto.crypto";

const meshtasticChannelPresets = [
    "ShortTurbo AQ==",
    "ShortSlow AQ==",
    "ShortFast AQ==",
    "MediumSlow AQ==",
    "MediumFast AQ==",
    "LongSlow AQ==",
    "LongFast AQ==",
    "LongMod AQ==",
    "LongTurbo AQ=="
];
const meshcorePublicNamekey = "MeshCore izOH6cXN6mrJ5e26oRXNcg==";
const arednChannelPostfix = " og==";
const arednPublicChannel = `AREDN${arednChannelPostfix}`;

global.channelByNameKey = {};
global.channelsByMeshtasticHash = {};
global.channelsByMeshcoreHash = {};
global.localChannelByNameKey = {};
let meshtasticChannel;

function expandSymmetricKey(key)
{
    key = b64dec(key);
    if (length(key) === 1) {
        return [ 0xd4, 0xf1, 0xbb, 0x3a, 0x20, 0x29, 0x07, 0x59, 0xf0, 0xbc, 0xff, 0xab, 0xcf, 0x4e, 0x69, ord(key, 0) ];
    }
    else {
        const crypto = [];
        for (let i = 0; i < length(key); i++) {
            crypto[i] = ord(key, i);
        }
        return crypto;
    }
}

function getMeshtasticHash(name, crypto)
{
    let hash = 0;
    for (let i = 0; i < length(name); i++) {
        hash ^= ord(name, i);
    }
    for (let i = 0; i < length(crypto); i++) {
        hash ^= crypto[i];
    }
    return hash;
}

function getMeshcoreHash(key)
{
    return crypto.sha256hash(struct.pack(`${length(key)}B`, ...key))[0];
}

export function isAREDNPreset(namekey)
{
    return namekey === arednPublicChannel;
};

export function isAREDNOnly(namekey)
{
    return rindex(namekey, arednChannelPostfix) !== -1;
};

export function isMeshtasticPreset(namekey)
{
    return !namekey || index(meshtasticChannelPresets, namekey) !== -1;
};

export function isMeshcorePreset(namekey)
{
    return namekey === meshcorePublicNamekey;
};

function addMessageNameKey(namekey)
{
    if (channelByNameKey[namekey]) {
        return channelByNameKey[namekey];
    }
    const nk = split(namekey, " ");
    const skey = expandSymmetricKey(nk[1]);
    const meshtastichash = getMeshtasticHash(nk[0], skey);
    const meshcorehash = getMeshcoreHash(skey);
    const chan = { namekey: namekey, symmetrickey: skey, meshtastichash: meshtastichash, meshcorehash: meshcorehash, telemetry: false };
    channelByNameKey[namekey] = chan;
    // The channelsBy... lists are used to speed packet decoding at the edge, so no point including channels in these
    // lists if they can never decode the specific meshtasticore type.
    if (!isAREDNOnly(namekey)) {
        if (!isMeshcorePreset(namekey)) {
            push(channelsByMeshtasticHash[meshtastichash] ?? (channelsByMeshtasticHash[meshtastichash] = []), chan);
        }
        if (!isMeshtasticPreset(namekey)) {
            push(channelsByMeshcoreHash[meshcorehash] ?? (channelsByMeshcoreHash[meshcorehash] = []), chan);
        }
    }
    return chan;
}

function removeMessageNameKey(namekey)
{
    const chan = channelByNameKey[namekey];
    if (chan) {
        let idx = index(channelsByMeshtasticHash[chan.meshtastichash], chan);
        if (idx >= 0) {
            splice(channelsByMeshtasticHash[chan.meshtastichash], idx, 1);
        }
        idx = index(channelsByMeshcoreHash[chan.meshcorehash], chan);
        if (idx >= 0) {
            splice(channelsByMeshcoreHash[chan.meshcorehash], idx, 1);
        }
        delete channelByNameKey[namekey];
    }
}

function setLocalChannel(config)
{
    const namekey = config.namekey;
    // Validate
    const nk = split(namekey, " ");
    // Two parts, separated by space
    if (length(nk) !== 2) {
        return false;
    }
    // Name cannot be more than 13 characters
    if (length(nk[0]) > 13) {
        return false;
    }
    try {
        // Valid key sizes: 1, 16, 32
        const lkey = length(b64dec(nk[1]));
        if (!(lkey === 1 || lkey === 16 || lkey === 32)) {
            return false;
        }
    }
    catch (_) {
        return false;
    }

    const chan = addMessageNameKey(namekey);
    if (isMeshtasticPreset(namekey)) {
        chan.telemetry = true;
        meshtasticChannel = chan;
    }
    if (isAREDNPreset(namekey)) {
        chan.telemetry = true;
    }
    if (config.telemetry !== null) {
        chan.telemetry = config.telemetry;
    }
    localChannelByNameKey[namekey] = chan;
    return true;
};

export function getChannelsByMeshtasticHash(hash)
{
    if (!hash && meshtasticChannel) {
        return [ meshtasticChannel ];
    }
    return channelsByMeshtasticHash[hash];
};

export function getChannelsByMeshcoreHash(hash)
{
    return channelsByMeshcoreHash[hash];
};

export function getLocalChannelByNameKey(namekey)
{
    if (!namekey) {
        return meshtasticChannel;
    }
    return localChannelByNameKey[namekey];
};

export function getChannelByNameKey(namekey)
{
    if (!namekey) {
        return meshtasticChannel;
    }
    return channelByNameKey[namekey];
};

export function getAllChannelNamekeys()
{
    return keys(channelByNameKey);
};

export function getAllLocalChannels()
{
    return values(localChannelByNameKey);
};

export function getTelemetryChannels()
{
    const telemetry = [];
    for (let namekey in channelByNameKey) {
        const chan = channelByNameKey[namekey];
        if (chan.telemetry) {
            push(telemetry, chan);
        }
    }
    return telemetry;
};

export function updateLocalChannels(channels)
{
    const oldLocalChannelByNameKey = localChannelByNameKey;
    localChannelByNameKey = {};
    for (let i = 0; i < length(channels); i++) {
        setLocalChannel(channels[i]);
    }
    const newchannels = [];
    for (let namekey in localChannelByNameKey) {
        if (!oldLocalChannelByNameKey[namekey]) {
            push(newchannels, namekey);
        }
        else {
            delete oldLocalChannelByNameKey[namekey];
        }
    }
    return { newchannels: newchannels, oldchannels: keys(oldLocalChannelByNameKey) };
};

export function updateRemoteNameKeys(namekeys)
{
    const remotekeys = {};
    for (let nk in channelByNameKey) {
        if (!localChannelByNameKey[nk]) {
            remotekeys[nk] = true;
        }
    }
    for (let i = 0; i < length(namekeys); i++) {
        const namekey = namekeys[i];
        if (!remotekeys[namekey]) {
            addMessageNameKey(namekey);
        }
        else {
            delete remotekeys[namekey];
        }
    }
    for (let nk in remotekeys) {
        removeMessageNameKey(nk);
    }
};

export function isDirect(namekey)
{
    return index(namekey, "DirectMessages ") === 0;
};

export function setup(config)
{
    const channels = config.channels;
    if (channels) {
        for (let i = 0; i < length(channels); i++) {
            setLocalChannel(channels[i]);
        }
    }
};

export function tick()
{
};

export function process(msg)
{
};

export function cmd(msg, reply)
{
};