import Logging from "@proxnet/undead-logging";
import * as fs from "node:fs";

const log = new Logging("Config");

type RedisConfiguration = {
    host: string;
    port: number;
    username: string;
    password: string;
    db: number;
};

type WebConfiguration = {
    port: number;
    host: string;
    publichost: string;
    securepublichost: boolean;
};

type PublicConfiguration = {
    serverName: string;
    serverId: string;
    owner: string;
    motd: string;
    levelScale: number;
    maxLevels: number;
    patches: string[];
};

type LoggingConfiguration = {
    notfound: boolean;
    debug: boolean;
    network: boolean;
};

type DiscordConfiguration = {
    token: string;
    clientId: string;
    guildId: string;
};

type AuthConfiguration = {
    secret: string;
    /**
     * In Hours
     */
    timeout: number;
};

export type GalvanicConfiguration = {
    redis: RedisConfiguration;
    web: WebConfiguration;
    public: PublicConfiguration;
    logging: LoggingConfiguration;
    discord: DiscordConfiguration | null;
    auth: AuthConfiguration;
};

export const defaultConfig: GalvanicConfiguration = {
    redis: {
        host: "127.0.0.1",
        port: 6379,
        username: "",
        password: "",
        db: 0,
    },
    web: {
        port: 3000,
        host: "127.0.0.1",
        publichost: "127.0.0.1:3000",
        securepublichost: false,
    },
    public: {
        serverName: "Galvanic Corrosion",
        serverId: "galvanic-corrosion-default",
        owner: "John Doe",
        motd: "A Galvanic Corrosion server.",
        levelScale: 1,
        maxLevels: 30,
        patches: [],
    },
    logging: {
        notfound: false,
        debug: false,
        network: false,
    },
    discord: null,
    auth: {
        secret: "CHANGE-ME-PLEASE",
        timeout: 3,
    },
};

/** The current configuration. Read and parsed only during startup. */
let config: GalvanicConfiguration;
try {
    if (!configurationExists()) generateDefaultConfig();
    config = JSON.parse(fs.readFileSync("./config.json").toString());
} catch (err) {
    log.e(`Could not get config: ${err}`);
    Deno.exit(1);
}

/** Does the configuration file exist on the disk? */
export function configurationExists() {
    return fs.existsSync("./config.json");
}

/** Place [or overwrite] the [existing] default configuration in the current directory */
export function generateDefaultConfig() {
    fs.writeFileSync(
        "./config.json",
        JSON.stringify(defaultConfig, undefined, "    "),
    );
}

/** Get current server configuration */
export function getConfig() {
    return config;
}

export const devMode = Deno.args.includes("--dev");

export * as Config from "./config.ts";