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: 48
    }
}

/** 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';