import {
    CoercableComponent,
    persistent,
    PersistentRef,
    Replace,
    setDefault,
    StyleValue
} from "@/features/feature";
import { Link } from "@/features/links";
import {
    Computable,
    GetComputableType,
    GetComputableTypeWithDefault,
    processComputable,
    ProcessedComputable
} from "@/util/computed";
import { createProxy } from "@/util/proxies";
import { createNanoEvents, Emitter } from "nanoevents";
import { globalBus, LayerEvents } from "./events";
import player from "./player";

export const layers: Record<string, Readonly<GenericLayer>> = {};
window.layers = layers;

export interface Position {
    x: number;
    y: number;
}

export interface LayerOptions {
    id: string;
    color?: Computable<string>;
    display: Computable<CoercableComponent>;
    classes?: Computable<Record<string, boolean>>;
    style?: Computable<StyleValue>;
    name?: Computable<string>;
    minimizable?: Computable<boolean>;
    forceHideGoBack?: Computable<boolean>;
    minWidth?: Computable<number>;
    links?: Computable<Link[]>;
}

export interface BaseLayer {
    minimized: PersistentRef<boolean>;
    emitter: Emitter<LayerEvents>;
    on: OmitThisParameter<Emitter<LayerEvents>["on"]>;
    emit: <K extends keyof LayerEvents>(event: K, ...args: Parameters<LayerEvents[K]>) => void;
}

export type Layer<T extends LayerOptions> = Replace<
    T & BaseLayer,
    {
        color: GetComputableType<T["color"]>;
        display: GetComputableType<T["display"]>;
        classes: GetComputableType<T["classes"]>;
        style: GetComputableType<T["style"]>;
        name: GetComputableTypeWithDefault<T["name"], T["id"]>;
        minWidth: GetComputableTypeWithDefault<T["minWidth"], 600>;
        minimizable: GetComputableTypeWithDefault<T["minimizable"], true>;
        forceHideGoBack: GetComputableType<T["forceHideGoBack"]>;
        links: GetComputableType<T["links"]>;
    }
>;

export type GenericLayer = Replace<
    Layer<LayerOptions>,
    {
        name: ProcessedComputable<string>;
        minWidth: ProcessedComputable<number>;
        minimizable: ProcessedComputable<boolean>;
    }
>;

export function createLayer<T extends LayerOptions>(options: T): Layer<T> {
    const layer: T & Partial<BaseLayer> = options;

    const emitter = (layer.emitter = createNanoEvents<LayerEvents>());
    layer.on = emitter.on;
    layer.emit = emitter.emit;

    layer.minimized = persistent(false);

    processComputable(layer as T, "color");
    processComputable(layer as T, "display");
    processComputable(layer as T, "name");
    setDefault(layer, "name", options.id);
    processComputable(layer as T, "minWidth");
    setDefault(layer, "minWidth", 600);
    processComputable(layer as T, "minimizable");
    setDefault(layer, "minimizable", true);
    processComputable(layer as T, "links");

    const proxy = createProxy((layer as unknown) as Layer<T>);
    return proxy;
}

export function addLayer(
    layer: GenericLayer,
    player: { layers?: Record<string, Record<string, unknown>> }
): void {
    if (layer.id in layers) {
        console.error(
            "Attempted to add layer with same ID as existing layer",
            layer.id,
            layers[layer.id]
        );
        return;
    }

    setDefault(player, "layers", {});
    if (player.layers[layer.id] == null) {
        player.layers[layer.id] = {};
    }
    layers[layer.id] = layer;

    globalBus.emit("addLayer", layer, player.layers[layer.id]);
}

export function getLayer<T extends GenericLayer>(layerID: string): () => T {
    return () => layers[layerID] as T;
}

export function removeLayer(layer: GenericLayer): void {
    globalBus.emit("removeLayer", layer);

    delete layers[layer.id];
}

export function reloadLayer(layer: GenericLayer): void {
    removeLayer(layer);

    // Re-create layer
    addLayer(layer, player);
}