// config/commands.ts
import { type PluginCommandInfo } from '@magickml/agent-plugin'
import { basePluginCommands } from '@magickml/agent-plugin'

const customCommand: PluginCommandInfo = {
  commandName: 'customCommand',
  displayName: 'Custom Command',
}

export const myPluginCommands: Record<string, PluginCommandInfo> = {
  // basePluginCommands has enable/disable/linkCredential/unlinkCredential/webhook
  ...basePluginCommands,
  customCommand,
}

// in main plugin file ex corePlugin.ts

// this is an abstract implementation and will get called in BasePlugin's init()
defineCommands() {
	const { enable, disable, linkCredential, unlinkCredential } =
	basePluginCommands
	this.registerCommand({
		...linkCredential,
		handler: this.handleEnable.bind(this),
	})
	this.registerCommand({
		...unlinkCredential,
		handler: this.handleDisable.bind(this),
	})

	this.registerCommand({ ...enable, handler: this.handleEnable.bind(this) })

	this.registerCommand({ ...disable, handler: this.handleDisable.bind(this) })
}

// define your handlers
async handleEnable() {} // ...

// anywhere else in the application
const command: AgentCommandData = {
  agentId,
  command: `plugin:${pluginName}:linkCredential`,
  data: {
    credential: 'my-plugins-token',
  },
}

await app.get('agentCommander').command(command)

// in config/state.ts
import type { PluginStateType } from '@magickml/agent-plugin-state'

// setup context with username from platofrm (ex: discord bot' username)
export type MyAgentContext = {
  username: string | undefined
}

export interface MyPluginState extends PluginStateType {
  enabled: boolean
  context: CoreAgentContext
}

export const myDefaultState: CorePluginState = {
  enabled: true,
  context: {
    username: '',
  },
}

// in main yourPlugin.ts file
export class MyPlugin extends CoreEventsPlugin<
  CorePluginEvents,
  EventPayload,
  Record<string, unknown>,
  Record<string, unknown>,
  MyPluginState, // Make sure to pass the type here so that we have a typesafety
  MyPluginCredentials
> {
  override defaultState = myDefaultState // Make sure to override the state

  // Updating the enabled state of a plugin, good to bind to a command
  async handleEnable() {
    // does not overwrite the other keys just new values, see the plugin-state-manager.ts.
    await this.updatePluginState({ enabled: true } as State)
    await this.initializeFunctionalities()
  }

  // Updating the our plugin specific context in state
  async updateContext() {
    const context = await this.getContext()
    await this.updatePluginState({ context } as Partial<State>)
  }

  // exmaple method of getting context, in this case the discord bot's username
  getContext() {
    const user = this.discord.user
    return {
      username: this.discord.user?.username,
    }
  }
}

// in config/credentials.ts
import { type ExtractPluginCredentialNames, type PluginCredential } from 'packages/server/credentials/src'
import { discordPluginName } from './constants'

export const discordPluginCredentials = [
  {
    name: 'discord-token',
    serviceType: 'discord',
    credentialType: 'plugin',
    initials: 'DC',
    clientName: 'Discord Token',
    icon: 'https://discord.com/assets/f8389ca1a741a115313bede9ac02e2c0.svg',
    helpLink: 'https://discord.com/developers/applications',
    description: 'Used to connect to Discord',
    available: true,
    pluginName: discordPluginName,
  },
] as const satisfies ReadonlyArray<PluginCredential> // make sure have this part

export type DiscordCredentialNames = ExtractPluginCredentialNames<typeof discordPluginCredentials>

export type DiscordCredentialsKeys = {
  [K in DiscordCredentialNames]: string | undefined
}

export type DiscordCredentials = Record<DiscordCredentialNames, string | undefined>

export class DiscordPlugin extends CoreEventsPlugin<
CorePluginEvents,
EventPayload,
Record<string, unknown>,
Record<string, unknown>,
DiscordPluginState,
DiscordCredentials // make sure to pass in here so you have typesafety
< {
	credentials = corePluginCredentials // set this as a constant
	...
}

// these methods are in BasePlugin.ts and can be used in your MyPlugin.ts file

// this will get all credentials for the plugin if they exist, getting them first if needed
async getCredentials() {
  return this.credentialsManager.getCredentials()
}

// this will get a specific credential for the plugin if it exists, fetching it first if needed
async getCredential(name: keyof Credentials) {
  return this.credentialsManager.getCredential(name)
}

// this will get a fresh copy always
async updateCredentials() {
  await this.credentialsManager.update()
}

// Usage
const creds = await this.getCredentials()
const token = getCredential('discord-token')
await updateCredentials()

// you can also access it directly
this.credentialsManager.someMethod()

// services/webhook-service.ts

// service
class WebhookService implements WebhookServiceMethods {
  app: Application

  // ...
  async create(data: BasePayload, params?: Params): Promise<unknown> {
    // ...
    const command: AgentCommandData = {
      agentId,
      command: `plugin:${pluginName}:webhook`,
      data,
    }

    await this.app.get('agentCommander').command(command)

    // ...
  }
}

// register
export const webhook = (app: Application): void => {
  app.use('/webhook/:agentid/:plugin', new WebhookService({}, app)),
    {
      methods: ['create'],
    }
}

//

import { EventPayload, WebhookPayload } from '@magickml/agent-plugin'
import { corePluginName } from './constants'

type ValidPayload = {
  content: string
  callback?: string
}
export type CoreWebhookPayload = WebhookPayload<ValidPayload>['payload']

export const validateCoreWebhookPayload = (payload: unknown): payload is ValidPayload => {
  return true
}

export type CoreWebhookEventPayload = EventPayload<ValidPayload, Record<string, unknown>>