// This script aims to bridge Minecraft to a guild of your choice by piping
// the Minecraft output into this script. RCON isrequired for messages to
// be sent to Minecraft.

// Running example - working directory: project root:
//  (cd ~/minecraft_server/ ; exec ~/minecraft_server/start.sh) | RCON_PASSWORD="your rcon password" node scripts/minecraft.js 

import fetch from "node-fetch";
import { WebSocket } from "ws";
import Rcon from "rcon";

const TOKEN = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6InN0YWdpbmctbWluZWNyYWZ0LWJyaWRnZSIsImF2YXRhclVSTCI6bnVsbCwiZGlzY29yZElEIjoiMCIsImd1aWxkQWNjZXNzIjpbIjczNjI5MjUwOTEzNDc0OTgwNyJdLCJpc1N1cGVyVG9rZW4iOnRydWUsImlhdCI6MTY0NDQ1MzM4MX0.-XIBl6VLnXVwve9iqhWs51ABZkm1i_v1tS6X01SPk3U"; // A supertoken is required to send messages from Minecraft.
const TARGET_GUILD_ID = "_";
const TARGET_CHANNEL_ID = "_";
const ORIGIN = "http://localhost:4050";
const GATEWAY_ORIGIN = "ws://localhost:4050/gateway";
const FRONTEND_ORIGIN = "http://localhost:4050/";
const messageSchema = { t: "number", d: "object" };
const messageTypes = {
    HELLO: 0,
    YOO: 1,
    READY: 2,
    EVENT: 3
};

const chatMessageRegex = /^\[(?:.*?)\]: \<(?<username>[a-zA-Z0-9]+)\> (?<message>.*)/;
const joinNotificationRegex = /^\[(?:.*?)\]: (?<username>[a-zA-Z0-9]+) joined the game/;
const leaveNotificationRegex = /^\[(?:.*?)\]: (?<username>[a-zA-Z0-9]+) left the game/;
const rconConnection = new Rcon("localhost", "25575", process.env.RCON_PASSWORD);

const pendingHandoffs = new Map();
const usernameToToken = new Map();

export default class GatewayClient {
    constructor(gatewayPath) {
        this.gatewayPath = gatewayPath;
        this.ws = null;
        this.token = null;
        this.user = null;
        this.onEvent = (e) => {};
    }

    connect(token) {
        if (!token)
            token = this.token;

        if (this.ws) {
            console.log("gateway: connect() but connection already exists, killing existing connection...");
            try {
                this.ws.removeAllListeners();
                this.ws.close();
                this.ws = null;
            } catch (e) {
                console.log("gateway: error while closing existing connection - it might not be established yet");
            }
        }

        console.log("gateway: connecting");

        this.ws = new WebSocket(this.gatewayPath);

        this.ws.on("message", (data, isBinary) => {
            if (isBinary) {
                console.warn("gateway: got binary data from server, ignoring...");
                return;
            }

            let message = data.toString();
            try {
                message = JSON.parse(data);
            } catch(e) {
                console.warn("gateway: got invalid JSON from server (failed to parse), ignoring...");
                return;
            }

            if (!this._checkMessageSchema(message)) {
                console.warn("gateway: got invalid JSON from server (does not match schema), ignoring...");
                return;
            }

            switch (message.t) {
                case messageTypes.HELLO: {
                    console.log("gateway: HELLO");
                    this.ws.send(JSON.stringify({
                        t: messageTypes.YOO,
                        d: {
                            token
                        }
                    }));
                    break;
                }
                case messageTypes.READY: {
                    console.log("gateway: READY");
                    this.user = message.d.user;
                    break;
                }
                case messageTypes.EVENT: {
                    this.onEvent(message.d);
                    break;
                }
                default: {
                    console.warn("gateway: got invalid JSON from server (invalid type), ignoring...");
                    return;
                }
            }
        });
        this.ws.on("open", () => {
            console.log("gateway: open");
        });
        this.ws.on("close", () => {
            console.log("gateway: closed, reconnecting in 4000ms");
            setTimeout(() => {
                console.log("gateway: reconnecting");
                this.connect(token);
            }, 4000);
        });
        this.ws.on("error", (e) => {
            console.error("gateway: error", e);
            console.log("gateway: reconnecting in 4000ms due to previous error");
            setTimeout(() => {
                console.log("gateway: reconnecting");
                this.connect(token);
            }, 4000);
        });
    }

    _checkMessageSchema(message) {
        for (const [key, value] of Object.entries(message)) {
            if (!messageSchema[key])
                return false;

            if (typeof value !== messageSchema[key])
                return false;
        }
        return true;
    }
}


async function sendBridgeMessageAs(guildId, channelId, content, username=undefined, avatarURL=undefined) {
    return await fetch(`${ORIGIN}/api/v1/guilds/${guildId}/channels/${channelId}/messages/create`, {
        method: "POST",
        body: JSON.stringify({
            content,
            username,
            avatarURL
        }),
        headers: {
            "content-type": "application/json",
            "authorization": TOKEN
        }
    });
}

async function sendMinecraftMessageAs(rcon, username, content, attachments, referencedMessage=null) {
    if (!attachments) {
        attachments = [];
    }    

    const tellrawPayload = [
        { text: "[" },
        { text: `${username}`, color: "gray" },
        { text: "]" },
        { text: " " },
    ];

    if (referencedMessage) {
        let trimmedContent = referencedMessage.content.substring(0, 50);
        if (trimmedContent !== referencedMessage.content) {
            trimmedContent += "...";
        }
        tellrawPayload.push({
            text: `<replying to ${referencedMessage.author.username}: ${trimmedContent}>`
        });
        tellrawPayload.push({
            text: " "
        });
    }

    attachments.forEach((e) => {
        tellrawPayload.push({
            text: `<open attachment: ${e.filename || "[unknown]"}>`,
            color: "gray",
            clickEvent: {
                action: "open_url",
                value: e.proxy_url
            }
        });
        tellrawPayload.push({
            text: " "
        });
    });

    tellrawPayload.push({ text: content });
    
    rcon.send(`tellraw @a ${JSON.stringify(tellrawPayload)}`);
}

async function startHandoffForUser(username) {
    const handoffRes = await fetch(`${ORIGIN}/api/v1/tokens/handoff/create`, {
        method: "POST",
        body: JSON.stringify({}),
        headers: {
            "content-type": "application/json",
            "authorization": TOKEN
        }
    });
    const { token: handoffToken, dispatchUUID } = (await handoffRes.json());

    pendingHandoffs.set(dispatchUUID, username);
    // TODO: probably not a good idea
    setTimeout(() => {
        pendingHandoffs.delete(dispatchUUID);
    }, 40000);

    return handoffToken;
}

async function main() {
    rconConnection.on("error", (e) => {
        console.error("rcon: got error", e);
        if (!rconConnection.hasAuthed) {
            console.log("rcon: reconnecting in 5000ms due to error before hasAuthed (server might not be up yet?)");
            setTimeout(() => {
                rconConnection.connect();
            }, 5000);
        }
    });

    const gateway = new GatewayClient(GATEWAY_ORIGIN);
    gateway.onEvent = (e) => {
        if (e.eventType === "$BRIDGE_HANDOFF_FULFILLMENT") {
            const username = pendingHandoffs.get(e.dispatchUUID);
            if (!username)
                return;

            usernameToToken.set(username, e.token);

            sendMinecraftMessageAs(rconConnection, "Minecraft Bridge System", `${username} has been successfully linked to a bridge token.`, null, null);
        } else if (e.eventType === "MESSAGE_CREATE" && e.message.channel_id === TARGET_CHANNEL_ID && e.message.guild_id === TARGET_GUILD_ID && !e.message.webhook_id) {
            sendMinecraftMessageAs(rconConnection, e.message.author.username, e.message.content, e.message.attachments, e.message.referenced_message);
        }
    };
    rconConnection.connect();
    gateway.connect(TOKEN);

    process.stdin.resume();
    process.stdin.on("data", async (rawDataBuffer) => {
        const stringData = rawDataBuffer.toString().trim();
        console.log(stringData);

        const joinResult = joinNotificationRegex.exec(stringData);
        if (joinResult) {
            await sendBridgeMessageAs(TARGET_GUILD_ID, TARGET_CHANNEL_ID, `**${joinResult.groups.username}** joined the game`, null, null);
            return;
        }

        const leaveResult = leaveNotificationRegex.exec(stringData);
        if (leaveResult) {
            await sendBridgeMessageAs(TARGET_GUILD_ID, TARGET_CHANNEL_ID, `**${leaveResult.groups.username}** left the game`, null, null);
            return;
        }

        const messageResult = chatMessageRegex.exec(stringData);
        if (messageResult) {
            if (messageResult.groups.message === "!:minecraft-link") {
                try {
                    const handoffToken = await startHandoffForUser(messageResult.groups.username);
                    const handoffLink = `${FRONTEND_ORIGIN}#token_handoff,,${handoffToken}`;
                    sendMinecraftMessageAs(
                        rconConnection,
                        "Minecraft Bridge System",
                        `${messageResult.groups.username}: Click on the attached link to finish linking your account. You have 40 seconds.`,
                        [
                            {
                                filename: `link account to ${messageResult.groups.username}`,
                                proxy_url: handoffLink
                            }
                        ]
                    );
                } catch(e) {
                    sendMinecraftMessageAs(rconConnection, "Minecraft Bridge System", `Failed to create link for ${messageResult.groups.username}.`, null, null);
                }
            } else {
                await sendBridgeMessageAs(TARGET_GUILD_ID, TARGET_CHANNEL_ID, messageResult.groups.message, messageResult.groups.username, null);
            }
        }
    });
}

await main();