import {readdir} from 'node:fs/promises';
import {isDeepStrictEqual} from 'node:util';
import type {BasePlugin, PluginContext, base_define, bot_config_plugin, plugin} from '../../types/bot/plugins/plugin.ts';
import type {data_type} from '../../types/bot/instance/bot_runtime.ts';
import {PluginError} from './error.ts';
import {plain_plugin_object, valid_plugin_config, valid_plugin_name, valid_plugin_path} from '../../utils/plugin_validation.ts';
export {PluginError} from './error.ts';

const valid_name = valid_plugin_name;
const data_types = new Set<data_type>(['string', 'boolean', 'number', 'datetime', 'string-select', 'number-select',
    'string-multi-select', 'number-multi-select', 'string-array', 'number-array']);
const valid_i18n = (value: unknown): boolean => Array.isArray(value) && value.length > 0 && value.every(item =>
    item && typeof item.lang === 'string' && item.lang.length > 0 && typeof item.name === 'string' && typeof item.description === 'string');

function valid_value(value: unknown, type: data_type): boolean {
    switch (type) {
        case 'string': case 'string-select': return typeof value === 'string';
        case 'number': case 'number-select': return typeof value === 'number' && Number.isFinite(value);
        case 'boolean': return typeof value === 'boolean';
        case 'datetime': return typeof value === 'string' && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/.test(value) && Number.isFinite(Date.parse(value));
        case 'string-array': case 'string-multi-select': return Array.isArray(value) && Array.from(value).every(item => typeof item === 'string');
        case 'number-array': case 'number-multi-select': return Array.isArray(value) && Array.from(value).every(item => typeof item === 'number' && Number.isFinite(item));
    }
}

function validate_item(item: bot_config_plugin<unknown>) {
    if (!plain_plugin_object(item) || !valid_name(item.name) || !valid_plugin_path(item.path)
        || item.config !== undefined && !valid_plugin_config(item.config)) {
        throw new PluginError('INVALID_CONFIG');
    }
}

async function import_module(url: URL): Promise<Record<string, unknown>> {
    url.searchParams.set('t', `${Date.now()}-${process.hrtime.bigint()}`);
    return import(url.href);
}

function instantiate(module: Record<string, unknown>, name: string): BasePlugin {
    if (typeof module.init !== 'function') throw new Error(`Plugin ${name} must export an init class`);
    const instance = new (module.init as new () => BasePlugin)();
    const template = instance.config_template;
    if (instance.name !== name || template?.name !== name || !valid_i18n(template.i18n)
        || typeof template.version !== 'string' || !template.version.length || !Array.isArray(template.config)
        || typeof instance.init !== 'function' || typeof instance.get_status !== 'function'
        || typeof instance.on_states_update !== 'function' || typeof instance.dispose !== 'function') {
        throw new Error(`Invalid plugin metadata: ${name}`);
    }
    const names = new Set<string>();
    for (const field of template.config) {
        if (!field || !valid_name(field.name) || names.has(field.name) || !valid_i18n(field.i18n)
            || typeof field.required !== 'boolean' || !data_types.has(field.type) || !Object.hasOwn(field, 'default')
            || field.default != null && !valid_value(field.default, field.type)) throw new Error(`Invalid plugin config metadata: ${name}`);
        names.add(field.name);
    }
    return instance;
}

function resolve_config(template: plugin, input: Record<string, unknown>): Record<string, unknown> {
    const names = new Set(template.config.map(field => field.name));
    for (const key of Object.keys(input)) if (!names.has(key)) throw new PluginError('INVALID_CONFIG');
    const config: Record<string, unknown> = {};
    for (const field of template.config) {
        const value = Object.hasOwn(input, field.name) ? input[field.name] : field.default;
        if (value == null ? field.required : !valid_value(value, field.type)) throw new PluginError('INVALID_CONFIG');
        Object.defineProperty(config, field.name, {value: structuredClone(value), enumerable: true, writable: true, configurable: true});
    }
    return config;
}

export interface PluginSnapshot {
    name: string;
    path: string;
    config: Record<string, unknown>;
    enabled: boolean;
    lifecycle: 'initializing' | 'enabled' | 'disabling' | 'disabled' | 'error';
    /** Last observed internal state; disabled records retain the final disposal snapshot. */
    states: unknown;
    error?: {code: string; message: string};
}

type Entry = {instance: BasePlugin; path: string; config: Record<string, unknown>; unsubscribe?: () => void; quarantined?: boolean};

export class PluginManager {
    private readonly entries = new Map<string, Entry>();
    private readonly records = new Map<string, PluginSnapshot>();
    private readonly listeners = new Set<(event: PluginSnapshot) => void>();
    private tail: Promise<void> = Promise.resolve();
    private disposed = false;
    private dispose_task?: Promise<void>;

    constructor(private readonly context: PluginContext) {}

    on_update(callback: (event: PluginSnapshot) => void): () => void {
        this.check_active();
        const listener = (event: PluginSnapshot) => callback(event);
        this.listeners.add(listener);
        return () => { this.listeners.delete(listener); };
    }

    private publish(record: PluginSnapshot) {
        this.records.set(record.name, structuredClone(record));
        for (const listener of Array.from(this.listeners)) {
            if (!this.listeners.has(listener)) continue;
            try { listener(structuredClone(record)); } catch {}
        }
    }

    private capture(entry: Entry): unknown {
        try { return structuredClone(entry.instance.get_status()); }
        catch { return null; }
    }

    private transition(entry: Entry, lifecycle: PluginSnapshot['lifecycle']) {
        this.publish({name: entry.instance.name, path: entry.path, config: entry.config,
            enabled: lifecycle === 'enabled', lifecycle, states: this.capture(entry),
            ...(entry.quarantined ? {error: {code: 'DISPOSE_FAILED', message: 'Plugin disposal failed'}} : {})});
    }

    private check_active() {
        if (this.disposed) throw new PluginError('MANAGER_DISPOSED');
    }

    private enqueue(operation: () => Promise<void>): Promise<void> {
        if (this.disposed) return Promise.reject(new PluginError('MANAGER_DISPOSED'));
        const task = this.tail.then(async () => { this.check_active(); await operation(); });
        this.tail = task.catch(() => {});
        return task;
    }

    private async prepare(item: bot_config_plugin<unknown>): Promise<Entry> {
        validate_item(item);
        if (this.entries.get(item.name)?.quarantined) throw new PluginError('DISPOSE_FAILED');
        let instance: BasePlugin;
        try {
            const module = await import_module(new URL(`./${item.path}/${item.name}.ts`, import.meta.url));
            this.check_active();
            instance = instantiate(module, item.name);
        } catch (error) {
            if (error instanceof PluginError) throw error;
            throw new PluginError('LOAD_FAILED');
        }
        return {instance, path: item.path, config: resolve_config(instance.config_template, (item.config ?? {}) as Record<string, unknown>)};
    }

    private async install(entry: Entry) {
        try {
            this.check_active();
            this.transition(entry, 'initializing');
            entry.unsubscribe = entry.instance.on_states_update(() => {
                const record = this.records.get(entry.instance.name);
                if (record) this.transition(entry, record.lifecycle);
            });
            this.check_active();
            await entry.instance.init(this.context, structuredClone(entry.config));
            this.check_active();
            this.entries.set(entry.instance.name, entry);
            this.transition(entry, 'enabled');
        } catch (error) {
            this.entries.delete(entry.instance.name);
            this.transition(entry, 'disabling');
            let cleanup_failed = false;
            try { await entry.instance.dispose(); }
            catch { cleanup_failed = true; }
            finally {
                try { entry.unsubscribe?.(); } catch { cleanup_failed = true; }
                if (cleanup_failed) {
                    entry.quarantined = true;
                    this.entries.set(entry.instance.name, entry);
                }
                this.transition(entry, 'error');
            }
            if (cleanup_failed) throw new PluginError('DISPOSE_FAILED');
            throw error instanceof PluginError ? error : new PluginError('INIT_FAILED');
        }
    }

    apply_desired(plugins: bot_config_plugin<unknown>[]): Promise<void> {
        return this.enqueue(async () => {
            if (!Array.isArray(plugins)) throw new PluginError('INVALID_CONFIG');
            const desired = new Map<string, bot_config_plugin<unknown>>();
            for (const item of plugins) {
                validate_item(item);
                if (desired.has(item.name)) throw new PluginError('ALREADY_INSTALLED');
                const current = this.entries.get(item.name);
                if (current && current.path !== item.path) throw new PluginError('INVALID_CONFIG');
                desired.set(item.name, structuredClone(item));
            }
            for (const entry of this.entries.values()) {
                if (entry.quarantined) throw new PluginError('DISPOSE_FAILED');
            }
            const candidates = new Map<string, Entry>();
            // Constructors own no resources. Prepare every replacement before disposing live plugins.
            for (const item of desired.values()) {
                const current = this.entries.get(item.name);
                if (current && isDeepStrictEqual(current.config,
                    resolve_config(current.instance.config_template, (item.config ?? {}) as Record<string, unknown>))) continue;
                try { candidates.set(item.name, await this.prepare(item)); }
                catch (error) {
                    if (!current && error instanceof PluginError && error.reason === 'LOAD_FAILED') {
                        this.publish({name: item.name, path: item.path, config: (item.config ?? {}) as Record<string, unknown>,
                            enabled: false, lifecycle: 'error', states: null});
                    }
                    throw error;
                }
            }
            this.check_active();
            for (const name of Array.from(this.entries.keys())) {
                if (!desired.has(name) || candidates.has(name)) await this.remove(name);
                this.check_active();
            }
            for (const candidate of candidates.values()) await this.install(candidate);
        });
    }

    init(plugins: bot_config_plugin<unknown>[]): Promise<void> {
        return this.enqueue(async () => {
            const names = new Set(this.entries.keys());
            for (const item of plugins) {
                validate_item(item);
                if (names.has(item.name)) throw new PluginError('ALREADY_INSTALLED');
                names.add(item.name);
            }
            const installed: string[] = [];
            try {
                for (const item of plugins) {
                    let candidate: Entry;
                    try { candidate = await this.prepare(item); }
                    catch (error) {
                        if (error instanceof PluginError && error.reason === 'LOAD_FAILED') {
                            this.publish({name: item.name, path: item.path, config: (item.config ?? {}) as Record<string, unknown>,
                                enabled: false, lifecycle: 'error', states: null});
                        }
                        throw error;
                    }
                    await this.install(candidate);
                    installed.push(item.name);
                }
            } catch (error) {
                const errors = [error];
                for (const name of installed.reverse()) {
                    try { await this.remove(name); } catch (cleanup) { errors.push(cleanup); }
                }
                if (errors.length > 1) throw new PluginError('DISPOSE_FAILED');
                throw error;
            }
        });
    }

    get_plugin(name: string): PluginSnapshot | undefined {
        const record = this.records.get(name);
        return record && structuredClone(record);
    }

    get_all_plugins(): PluginSnapshot[] {
        return Array.from(this.records.values(), record => structuredClone(record));
    }

    inject(item: bot_config_plugin<unknown>): Promise<void> { return this.init([item]); }

    re_inject(item: bot_config_plugin<unknown>): Promise<void> {
        return this.enqueue(async () => {
            const candidate = await this.prepare(item);
            await this.remove(item.name);
            await this.install(candidate);
        });
    }

    update_config(name: string, config: Record<string, unknown>): Promise<void> {
        return this.enqueue(async () => {
            if (!valid_name(name) || !valid_plugin_config(config)) throw new PluginError('INVALID_CONFIG');
            const previous = this.entries.get(name);
            if (!previous || !this.records.get(name)?.enabled) throw new PluginError('NOT_INSTALLED');
            const candidate = await this.prepare({name, path: previous.path, config});
            this.check_active();
            await this.remove(name);
            await this.install(candidate);
        });
    }

    private async remove(name: string) {
        const entry = this.entries.get(name);
        if (!entry) return;
        if (entry.quarantined) throw new PluginError('DISPOSE_FAILED');
        this.transition(entry, 'disabling');
        let failed = false;
        try { await entry.instance.dispose(); }
        catch { failed = true; }
        finally {
            try { entry.unsubscribe?.(); } catch { failed = true; }
            if (failed) entry.quarantined = true;
            else this.entries.delete(name);
            this.transition(entry, failed ? 'error' : 'disabled');
        }
        if (failed) throw new PluginError('DISPOSE_FAILED');
    }

    uninject(name: string): Promise<void> { return this.enqueue(() => this.remove(name)); }

    dispose(): Promise<void> {
        if (this.dispose_task) return this.dispose_task;
        this.disposed = true;
        this.dispose_task = this.tail.then(async () => {
            const errors: unknown[] = [];
            for (const name of Array.from(this.entries.keys()).reverse()) {
                try { await this.remove(name); } catch (error) { errors.push(error); }
            }
            this.listeners.clear();
            if (errors.length) throw new PluginError('DISPOSE_FAILED');
        });
        return this.dispose_task;
    }
}

export async function create_plugin_manager(context: PluginContext, plugins: bot_config_plugin<unknown>[]): Promise<PluginManager> {
    const manager = new PluginManager(context);
    try { await manager.init(plugins); return manager; }
    catch (error) {
        try { await manager.dispose(); } catch { throw new PluginError('DISPOSE_FAILED'); }
        throw error;
    }
}

export async function get_plugin_list(): Promise<{path: string; name: string; path_config: base_define; plugin_config_template: plugin}[]> {
    const result: Awaited<ReturnType<typeof get_plugin_list>> = [];
    const directories = [''];
    const names = new Set<string>();
    for (const path of directories) {
        const directory = new URL(path ? `./${path}/` : './', import.meta.url);
        const entries = (await readdir(directory, {withFileTypes: true})).sort((a, b) => a.name.localeCompare(b.name));
        for (const entry of entries) if (entry.isDirectory() && valid_name(entry.name)) directories.push(path ? `${path}/${entry.name}` : entry.name);
        if (!path || !entries.some(entry => entry.isFile() && entry.name === 'define.ts')) continue;
        const {define} = await import_module(new URL('define.ts', directory)) as {define: base_define};
        if (define?.path !== path || !valid_i18n(define.i18n)) throw new Error(`Invalid plugin category: ${path}`);
        for (const entry of entries) {
            if (!entry.isFile() || entry.name === 'define.ts' || !/^[a-zA-Z0-9_-]+\.ts$/.test(entry.name)) continue;
            const module = await import_module(new URL(entry.name, directory));
            if (!Object.hasOwn(module, 'init')) continue;
            const name = entry.name.slice(0, -3);
            const instance = instantiate(module, name);
            if (names.has(name)) throw new Error(`Duplicate plugin: ${name}`);
            names.add(name);
            result.push({path, name, path_config: structuredClone(define), plugin_config_template: structuredClone(instance.config_template)});
        }
    }
    return result.sort((a, b) => a.path.localeCompare(b.path) || a.name.localeCompare(b.name));
}