import type {
  ChatInputCommandInteraction,
  CommandInteraction,
  UserContextMenuCommandInteraction,
  MessageContextMenuCommandInteraction,
} from "discord.js";
import type { Option, InferOptions } from "./options";

export class Subcommand {
  constructor(
    public name: string,
    public config: {
      description: string;
      options?: Record<string, Option<any, any>>;
      run: Function;
    },
  ) {}
}

export class SubcommandGroup<Ctx = {}> {
  public subcommands: Record<string, Subcommand> = {};

  constructor(
    public name: string,
    public description: string,
  ) {}

  subcommand<O extends Record<string, Option<any, any>>>(
    name: string,
    config: {
      description: string;
      options?: O;
      run: (
        interaction: ChatInputCommandInteraction,
        args: InferOptions<O>,
        ctx: Ctx,
      ) => Promise<void> | void;
    },
  ): this {
    this.subcommands[name] = new Subcommand(name, config);
    return this;
  }
}

export class SubcommandGroupBuilder<Ctx = {}> {
  public subcommands: Record<string, Subcommand> = {};
  public groups: Record<string, SubcommandGroup<Ctx>> = {};

  constructor(
    public name: string,
    public description: string,
    public middlewares: Function[] = [],
  ) {}

  subcommand<O extends Record<string, Option<any, any>>>(
    name: string,
    config: {
      description: string;
      options?: O;
      run: (
        interaction: ChatInputCommandInteraction,
        args: InferOptions<O>,
        ctx: Ctx,
      ) => Promise<void> | void;
    },
  ): this {
    this.subcommands[name] = new Subcommand(name, config);
    return this;
  }

  group(
    name: string,
    config: { description: string },
    setup: (group: SubcommandGroup<Ctx>) => void,
  ): this {
    const group = new SubcommandGroup<Ctx>(name, config.description);
    setup(group);
    this.groups[name] = group;
    return this;
  }
}

export class Command {
  constructor(
    public name: string,
    public config: {
      description: string;
      options?: Record<string, Option<any, any>>;
      run: Function;
    },
    public middlewares: Function[] = [],
  ) {}
}

export class ContextMenuCommand {
  constructor(
    public name: string,
    public type: "user" | "message",
    public run: Function,
    public middlewares: Function[] = [],
  ) {}
}

export class CommandBuilder<Ctx = {}> {
  constructor(private middlewares: Function[] = []) {}

  use<NewCtx extends Record<string, any>>(
    mw: (interaction: CommandInteraction, ctx: Ctx) => Promise<NewCtx | void> | NewCtx | void,
  ): CommandBuilder<Ctx & NewCtx> {
    return new CommandBuilder<Ctx & NewCtx>([...this.middlewares, mw]);
  }

  command<O extends Record<string, Option<any, any>>>(
    name: string,
    config: {
      description: string;
      options?: O;
      run: (
        interaction: ChatInputCommandInteraction,
        args: InferOptions<O>,
        ctx: Ctx,
      ) => Promise<void> | void;
    },
  ): Command;

  command(name: string, config: { description: string }): SubcommandGroupBuilder<Ctx>;

  command(name: string, config: any): any {
    if (config.run) {
      return new Command(name, config, this.middlewares);
    }
    return new SubcommandGroupBuilder<Ctx>(name, config.description, this.middlewares);
  }

  userContextMenu(
    name: string,
    run: (interaction: UserContextMenuCommandInteraction, ctx: Ctx) => Promise<void> | void,
  ): ContextMenuCommand {
    return new ContextMenuCommand(name, "user", run, this.middlewares);
  }

  messageContextMenu(
    name: string,
    run: (interaction: MessageContextMenuCommandInteraction, ctx: Ctx) => Promise<void> | void,
  ): ContextMenuCommand {
    return new ContextMenuCommand(name, "message", run, this.middlewares);
  }
}