import commander from 'commander';
import { EventEmitter } from 'node:events';
import * as utils from '@fesjs/utils';

/**
 * 插件类型枚举
 */
declare enum PluginType {
    preset = "preset",
    plugin = "plugin",
    builder = "builder"
}
/**
 * 服务阶段枚举
 */
declare enum ServiceStage {
    uninitialized = 0,
    constructor = 1,
    init = 2,
    initPresets = 3,
    initPlugins = 4,
    initHooks = 5,
    pluginReady = 6,
    getConfig = 7,
    getPaths = 8,
    run = 9
}
/**
 * 配置变更类型枚举
 */
declare enum ConfigChangeType {
    reload = "reload",
    regenerateTmpFiles = "regenerateTmpFiles"
}
/**
 * 应用插件类型枚举
 */
declare enum ApplyPluginsType {
    add = "add",
    modify = "modify",
    event = "event"
}
/**
 * 启用方式枚举
 */
declare enum EnableBy {
    register = "register",
    config = "config"
}

interface PluginAPIOptions {
    id: string;
    key: string;
    service: ServiceInstance;
}
interface DescribeOptions {
    id?: string;
    key?: string;
    config?: PluginConfig;
    enableBy?: EnableBy | (() => boolean);
}
declare class PluginAPI {
    id: string;
    key: string;
    service: ServiceInstance;
    utils: typeof utils;
    logger: typeof utils.logger;
    constructor(opts: PluginAPIOptions);
    describe({ id, key, config, enableBy }?: DescribeOptions): void;
    register(hook: Hook): void;
    registerCommand(commandOption: CommandOption): void;
    registerPlugins(plugins: (string | Plugin)[]): Promise<void>;
    registerPresets(presets: (string | Plugin)[]): Promise<void>;
    registerMethod({ name, fn, exitsError }: {
        name: string;
        fn?: (...args: any[]) => any;
        exitsError: boolean;
    }): void;
    registerBuilder(builder: Record<string, any>): void;
    skipPlugins(pluginIds: string[]): void;
}

interface ServiceOptions {
    cwd?: string;
    pkg?: Record<string, any>;
    env?: string;
    fesPkg?: Record<string, any>;
    presets?: string[];
    plugins?: string[];
}
interface SetupOptions {
    presets?: string[];
    plugins?: string[];
}
interface ApplyAPIOptions {
    apply: () => Promise<any> | any;
    api: any;
}
interface ApplyPluginsOptionsExtended extends ApplyPluginsOptions {
    args?: any;
}
interface RunOptions {
    rawArgv?: Record<string, any>;
    args?: Record<string, any>;
}
interface RunCommandOptions {
    rawArgv?: Record<string, any>;
    args?: Record<string, any>;
}
declare class Service extends EventEmitter {
    cwd: string;
    pkg: Record<string, any>;
    skipPluginIds: Set<string>;
    stage: ServiceStage;
    commands: Record<string, CommandOption>;
    plugins: Record<string, Plugin>;
    builder: Record<string, any>;
    pluginMethods: Record<string, () => void>;
    initialPresets: Plugin[];
    initialPlugins: Plugin[];
    _extraPresets: Plugin[];
    _extraPlugins: Plugin[];
    userConfig: UserConfig;
    configInstance: ConfigInstance;
    config: UserConfig | null;
    hooksByPluginId: Record<string, Hook[]>;
    hooks: Record<string, Hook[]>;
    paths: Paths;
    env: string;
    ApplyPluginsType: typeof ApplyPluginsType;
    EnableBy: typeof EnableBy;
    ConfigChangeType: typeof ConfigChangeType;
    ServiceStage: typeof ServiceStage;
    args: Record<string, any> | undefined;
    fesPkg: Record<string, any>;
    program: commander.Command;
    ready: Promise<boolean>;
    constructor(opts: ServiceOptions);
    setup(opts: SetupOptions): Promise<boolean>;
    setStage(stage: ServiceStage): void;
    resolvePackage(): Record<string, any>;
    loadEnv(): void;
    init(): Promise<void>;
    setConfig(): Promise<void>;
    initPresetsAndPlugins(): Promise<void>;
    getPluginAPI(opts: {
        id: string;
        key: string;
        service: Service;
    }): PluginAPI;
    applyAPI(opts: ApplyAPIOptions): Promise<any>;
    initPreset(preset: Plugin): Promise<void>;
    initPlugin(plugin: Plugin): Promise<void>;
    getPluginOptsWithKey(key: string): any;
    registerPlugin(plugin: Plugin): void;
    isPluginEnable(pluginId: string): boolean;
    hasPresets(presetIds: string[]): boolean;
    hasPlugins(pluginIds: string[]): boolean;
    applyPlugins<T>(opts: ApplyPluginsOptionsExtended): Promise<T>;
    initCommand(): commander.Command;
    run({ rawArgv, args }: RunOptions): Promise<any>;
    runCommand({ rawArgv, args }: RunCommandOptions): Promise<any>;
    parseCommand(): Promise<any>;
}

type ConfigInstance = InstanceType<typeof Config>;
type ServiceInstance = InstanceType<typeof Service>;
type PluginAPIInstance = InstanceType<typeof PluginAPI>;

interface UserConfig {
    [key: string]: any;
}
interface Paths {
    tmpDir: string;
    cwd: string;
    absNodeModulesPath: string;
    absOutputPath: string;
    absSrcPath: string;
    absPagesPath: string;
    absTmpPath: string;
}
interface Plugin {
    id: string;
    key: string;
    path: string;
    apply: () => Promise<any> | any;
    config?: PluginConfig;
    enableBy?: EnableBy | (() => boolean);
    isPreset?: boolean;
    defaultConfig: any;
}
interface PluginConfig {
    schema?: (joi: any) => any;
    default?: any;
}
interface Hook {
    key: string;
    fn: (...args: any[]) => any;
    pluginId?: string;
    stage?: number;
    before?: string;
}
interface CommandOption {
    command: string;
    description: string;
    options?: CommandOptionConfig[];
    fn?: (args: CommandArgs) => Promise<void> | void;
}
interface CommandOptionConfig {
    name: string;
    description: string;
    default?: any;
    choices?: string[];
}
interface CommandArgs {
    rawArgv: Record<string, any>;
    args: Record<string, any>;
    options: Record<string, any>;
    program: any;
}
interface ApplyPluginsOptions {
    key: string;
    type: ApplyPluginsType;
    initialValue?: any;
    args?: any;
}

interface ConfigOptions {
    cwd?: string;
    service: ServiceInstance;
    localConfig?: boolean;
}
interface WatchOptions {
    userConfig: UserConfig;
    onChange: (params: {
        userConfig: UserConfig;
        pluginChanged: Array<{
            key: string;
            pluginId: string;
        }>;
        valueChanged: Array<{
            key: string;
            pluginId: string;
        }>;
    }) => void;
}
declare class Config {
    cwd: string;
    service: ServiceInstance;
    config: any;
    localConfig: boolean;
    configFile: string[];
    constructor(opts: ConfigOptions);
    getDefaultConfig(): Promise<Record<string, any>>;
    getConfig(defaultConfig: Record<string, any>): Promise<UserConfig>;
    getUserConfig(): Promise<UserConfig>;
    addAffix(file: string, affix: string): string;
    requireConfigs(configFiles: string[]): Promise<any[]>;
    mergeConfig(configs: any[]): UserConfig;
    getConfigFile(): string[];
    getWatchFilesAndDirectories(): string[];
    watch(opts: WatchOptions): () => void;
}

export { Config as C, PluginType as P, Service as S, type ConfigInstance as a, type PluginAPIInstance as b, type ServiceInstance as c };