import type {Bud, Modules} from '@roots/bud-framework'
import type {Compiler} from '@roots/bud-framework/config'
import type {ApplyPluginConstructor} from '@roots/bud-framework/extension/decorators/plugin'

import {type Logger} from '@roots/bud-support/logger'
import DynamicOption from '@roots/bud-support/value'

export type OptionsInterface<T = Record<string, any>> = {
  [K in keyof T as `${K & string}`]?: T[K]
}

export type InternalOptions<T extends OptionsInterface> = {
  [K in keyof T as `${K & string}`]:
    | DynamicOption<(app: Bud) => T[K]>
    | T[K]
}

export type OptionCallback<
  T extends OptionsInterface,
  K extends `${keyof OptionsInterface & string}`,
> = ((value: T[K]) => T[K]) | T[K]

export type OptionCallbackValue<
  T extends OptionsInterface,
  K extends `${keyof OptionsInterface & string}`,
> = ((value: T[K]) => T[K]) | InternalOptions<T>[K]

export type Setter<
  Extension,
  OptionsInterface,
  Property extends `${keyof OptionsInterface & string}`,
> = (value: OptionCallbackValue<OptionsInterface, Property>) => Extension

export type Getter<
  Options extends OptionsInterface = OptionsInterface,
  Property extends
    `${keyof OptionsInterface & string}` = `${keyof OptionsInterface & string}`,
> = () => Options[Property]

export type Accessor<
  Options extends OptionsInterface,
  Property extends `${keyof OptionsInterface & string}`,
> = Options[Property]

export type Option<
  Extension,
  Options extends OptionsInterface,
  Property extends `${keyof Options & string}`,
> = {
  get: Getter<Options, Property>
  set: Setter<Extension, Options, Property>
  value: Accessor<Options, Property>
}

export interface Meta {
  boot: boolean
  buildAfter: boolean
  buildBefore: boolean
  compilerDone: boolean
  configAfter: boolean
  register: boolean
}

export interface Constructor {
  new (...args: any[]): BudExtension
}

export type WithOptions<Context, Options> = {
  [K in keyof Options as `${K & string}`]: Options[K]
} & {
  [Prop in keyof Options as `get${Capitalize<
    Prop & string
  >}`]: () => Options[Prop]
} & {
  [Prop in keyof Options as `set${Capitalize<Prop & string>}`]: (
    value: OptionCallbackValue<Options, `${Prop & string}`>,
  ) => Context
}

export type ExtensionApi<
  Context,
  Options extends OptionsInterface,
> = BudExtension<Options> & WithOptions<Context, Options>

/**
 * Webpack plugin.
 */
export interface ApplyPlugin {
  /**
   * @see {@link https://webpack.js.org/contribute/writing-a-plugin/#basic-plugin-architecture}
   */
  apply(...args: any[]): unknown
}

export interface BudExtension<
  Options extends OptionsInterface = OptionsInterface,
  Plugin extends ApplyPlugin = ApplyPlugin,
> {
  _app: () => Bud
  _options: Partial<InternalOptions<Options>>

  /**
   * Extension.app
   */
  app: Bud

  /**
   * {@link ApplyPlugin.apply} callback
   */
  apply?(compiler: Compiler): unknown | void

  /**
   * `boot` callback
   */
  boot?(app: Bud): Promise<unknown | void>

  /**
   * `buildAfter` callback
   */
  buildAfter?(app: Bud): Promise<unknown | void>

  /**
   * `buildBefore` callback
   */
  buildBefore?(app: Bud): Promise<unknown | void>

  /**
   * Error handler
   */
  catch(error: Error | string): never

  /**
   * `configAfter` callback
   */
  configAfter?(app: Bud): Promise<unknown | void>

  /**
   * Depends on
   */
  dependsOn?: Set<keyof Modules & string>

  /**
   * Depends on (optional)
   */
  dependsOnOptional?: Set<`${keyof Modules & string}`>

  /**
   * Disable extension
   * @deprecated pass `false` to {@link Extension.enable}
   */
  disable(): void

  /**
   * Return to bud instance from extension
   */
  done(): Bud

  /**
   * Enable extension
   */
  enable(enabled?: boolean | Bud): this

  /**
   * Extension.enabled
   *
   * @remarks
   * If `true`, the extension is enabled.
   */
  enabled: boolean
  execute(key: `${keyof Meta & string}` | `make`): Promise<unknown>

  /**
   * Get an option value
   */
  get: BudExtension['getOption']

  /**
   * Get option
   */
  getOption<K extends string>(key: K): Options[K]

  /**
   * Get options
   */
  getOptions(): Options

  /**
   * Extension.import
   */
  import<T = any>(
    signifier: string,
    context: string,
    options?: {bustCache?: boolean; raw?: boolean},
  ): Promise<T | undefined>

  /**
   * Is extension enabled?
   */
  isEnabled(): boolean

  /**
   * The module name
   */
  label?: `${keyof Modules & string}`

  /**
   * Logger instance
   */
  logger: Logger

  /**
   * `make` callback
   */
  make?(app: Bud, options?: Options): Promise<Plugin>

  /**
   * Extension.meta
   *
   * @remarks
   * Tracks which extension methods have been executed to prevent
   * duplicate execution in race conditions, etc.
   */
  meta: Meta

  /**
   * Extension.options
   *
   * @readonly
   */
  options: Options

  /**
   * Plugin constructor
   */
  plugin?: ApplyPluginConstructor

  /**
   * {@link Extension.register}
   */
  register?(app: Bud): Promise<any>

  /**
   * Resolve module using `import.meta.resolve` api
   */
  resolve(signifier: string, context: string): Promise<false | string>

  /**
   * Set option
   */
  set: BudExtension['setOption']

  /**
   * Set option
   */
  setOption<K extends string>(
    key: K,
    valueOrCallback: OptionCallbackValue<Options, K>,
  ): BudExtension

  /**
   * Set options
   */
  setOptions(value: Partial<InternalOptions<Options>>): BudExtension

  /**
   * Extension.when
   *
   * Function returning a boolean indicating if the {@link Extension} should be utilized.
   *
   * @remarks
   * If set this takes precedence over {@link Extension.enabled}.
   */
  when?(bud: Bud, options?: Options): boolean
}