interface Command {
  readonly name: string;
  readonly aliases: string[];
  readonly description: string;
  readonly adminOnly?: boolean;
  execute(context: CommandContext): Promise<CommandResult>;
}

interface CommandContext {
  message: Message;        // WhatsApp message object
  args: string[];          // Command arguments (split by space)
  whatsappId: string;      // Sender's WhatsApp ID
  displayName: string;     // Sender's display name
}

interface CommandResult {
  success: boolean;
  reply?: string;          // Message to send to WhatsApp
  error?: string;          // Error message (if any)
}

const isAdmin = config.whatsapp.adminIds.includes(context.whatsappId);

if (command.adminOnly && !isAdmin) {
  await message.reply('This command is admin only');
  return;
}

throw new CommandError(
  'Failed to undo beer',           // Technical message (logged)
  'UNDO_FAILED',                   // Error code
  'Failed to undo beer. Please try again'  // User message (sent to WhatsApp)
);

import type { Command, CommandContext, CommandResult } from './types';
import { logger } from '../utils/logger';
import { CommandError } from '../types/statistics';

export class MyCommand implements Command {
	readonly name = 'mycommand';
	readonly aliases = ['mc', 'mycmd'];
	readonly description = 'Description of my command';
	readonly adminOnly = false;

	async execute(context: CommandContext): Promise<CommandResult> {
		try {
			logger.debug(
				{ whatsappId: context.whatsappId, args: context.args },
				'Executing mycommand',
			);

			// Command logic here
			const result = await doSomething(context.args);

			return {
				success: true,
				reply: `Command result: ${result}`,
			};
		} catch (error) {
			logger.error({ error, context }, 'My command failed');

			throw new CommandError(
				'Failed to execute command',
				'MY_COMMAND_FAILED',
				'Failed to execute command. Please try again',
			);
		}
	}
}

import { UndoCommand } from './undoCommand';
import { LeaderbaordCommand } from './leaderboardCommand';
import { RemoveLastCommand } from './removeLastCommand';
import { MyCommand } from './myCommand';  // Add import

export function registerCommands(): void {
	commandRegistry.register(new UndoCommand());
	commandRegistry.register(new LeaderbaordCommand());
	commandRegistry.register(new RemoveLastCommand());
	commandRegistry.register(new MyCommand());  // Register command
}

import { MyCommand } from '../../../src/commands/myCommand';
import type { CommandContext } from '../../../src/commands/types';

describe('MyCommand', () => {
	let command: MyCommand;
	let mockContext: CommandContext;

	beforeEach(() => {
		command = new MyCommand();
		mockContext = {
			message: {} as any,
			args: [],
			whatsappId: '[email protected]',
			displayName: 'Test User',
		};
	});

	it('should execute successfully', async () => {
		const result = await command.execute(mockContext);

		expect(result.success).toBe(true);
		expect(result.reply).toBeDefined();
	});

	it('should handle errors gracefully', async () => {
		mockContext.args = ['invalid'];

		await expect(command.execute(mockContext)).rejects.toThrow();
	});
});

// User sends: !command arg1 arg2 arg3
context.args = ['arg1', 'arg2', 'arg3']

async execute(context: CommandContext): Promise<CommandResult> {
	const [firstArg, secondArg] = context.args;

	if (!firstArg) {
		return {
			success: false,
			reply: 'Usage: !mycommand <arg1> <arg2>',
		};
	}

	// Use arguments
	const result = await processCommand(firstArg, secondArg);

	return {
		success: true,
		reply: result,
	};
}

async execute(context: CommandContext): Promise<CommandResult> {
	// Get mentioned users
	const mentions = await context.message.getMentions();

	// Get message timestamp
	const timestamp = context.message.timestamp;

	// Get chat information
	const chat = await context.message.getChat();

	// Reply with formatting
	return {
		success: true,
		reply: '*Bold text*\n_Italic text_\n~Strikethrough~',
	};
}

commandRegistry.register(new MyCommand());

const command = commandRegistry.get('mycommand');
// Also works with aliases:
const command = commandRegistry.get('mc');

if (commandRegistry.has('mycommand')) {
	// Command exists
}

const allCommands = commandRegistry.getAllCommands();
// Returns array of unique Command objects

messageHandler.handleMessage(message)

if (message.body && commandHandler.isCommand(message.body)) {
	await commandHandler.handleCommand(message);
	return;
}

const parts = message.body.slice(1).split(/\s+/);
const commandName = parts[0].toLowerCase();
const args = parts.slice(1);

const command = commandRegistry.get(commandName);
if (!command) {
	await message.reply('Unknown command');
	return;
}

if (command.adminOnly && !isAdmin) {
	await message.reply('This command is admin only');
	return;
}

const context: CommandContext = {
	message,
	args,
	whatsappId: contact.id._serialized,
	displayName: contact.pushname || contact.name || 'Unknown',
};

const result = await command.execute(context);

if (result.reply) {
	await message.reply(result.reply);
}

class CommandError extends Error {
	constructor(
		message: string,        // Technical message (logged)
		code: string,           // Error code (UPPER_SNAKE_CASE)
		userMessage?: string,   // User-facing message
	) {
		super(message);
		this.name = 'CommandError';
	}
}

throw new CommandError(
	'Database query failed',
	'DATABASE_ERROR',
	'Failed to load data. Please try again',
);