import { Client, Message, Interaction, Collection } from 'discord.js';

/**
 * Script metadata interface
 */
interface ScriptMetadata {
  author: string;
  createdAt: string;
  uploaderId: string;
  enabled?: boolean;
}

/**
 * Script entry interface
 */
interface ScriptEntry {
  name: string;
  path: string;
  module: Function;
  metadata: ScriptMetadata;
  enabled: boolean;
}

/**
 * Script Manager Configuration Options
 */
interface ScriptManagerOptions {
  client: Client;
  scriptFolder: string;
  allowedUsers?: string[];
  maxScriptSize?: number;
  debug?: boolean;
  maxExecutionTime?: number;
  onError?: (error: Error, fileName: string, message?: Message) => void;
}

/**
 * Script Manager Class
 */
declare class ScriptManager {
  constructor(options: ScriptManagerOptions);
  
  client: Client;
  scripts: Collection<string, ScriptEntry>;
  commands: Collection<string, any>;

  loadScripts(options?: { channel?: any }): Promise<{ total: number, loaded: number }>;
  reloadScript(fileName: string, options?: { channel?: any }): Promise<boolean>;
  addScript(fileName: string, scriptContent: string, metadata: ScriptMetadata, options?: { channel?: any }): Promise<boolean>;
  executeScript(scriptName: string, context?: any): Promise<any>;
  isUserAllowed(userId: string): boolean;
}

/**
 * Message Handler Configuration
 */
interface MessageHandlerOptions {
  timeout?: number;
  maxRetries?: number;
  cacheSize?: number;
  debug?: boolean;
}

/**
 * Message Handler Class
 */
declare class MessageHandler {
  constructor(message: Message, options?: MessageHandlerOptions);
  
  reply(content: string | object, mentionUser?: boolean): Promise<Message>;
  send(content: string | object): Promise<Message>;
  sendEmbed(embed: object): Promise<Message>;
  edit(content: string | object): Promise<Message>;
  delete(timeout?: number): Promise<void>;
}

export interface EventHandlerOptions {
  client: Client;
  scriptFolder: string;
  debug?: boolean;
}

export interface DependencyVersionInfo {
  current: string;
  latest: string;
  outdated: boolean;
}

export interface DependencyConflictInfo {
  hasConflicts: boolean;
  conflicts: string[];
}

export interface DependencySecurityInfo {
  isSafe: boolean;
  vulnerabilities: any[];
}

export interface DependencyInfo {
  name: string;
  description: string;
  version: string;
  author?: {
    name: string;
    email?: string;
    url?: string;
  };
  license?: string;
  repository?: {
    type: string;
    url: string;
  };
}

export class EventHandler {
  constructor(options: EventHandlerOptions);
  registerEvent(eventName: string, handler: Function): void;
  registerScriptEvent(eventName: string, handler: Function): void;
  triggerScriptEvent(eventName: string, ...args: any[]): Promise<void>;
  removeEvent(eventName: string): void;
  removeScriptEvent(eventName: string): void;
  cleanup(): void;
}

export function createScriptManager(options: ScriptManagerOptions): ScriptManager;
export function createMessageHandler(message: Message, options?: MessageHandlerOptions): MessageHandler;
export function createEventHandler(options: EventHandlerOptions): EventHandler;

export function installDependency(packageName: string, version?: string): Promise<void>;
export function loadModule(modulePath: string): Promise<any>;
export function checkDependencyVersion(packageName: string): Promise<string>;
export function checkDependencyConflicts(packageName: string): Promise<boolean>;
export function checkDependencySecurity(packageName: string): Promise<boolean>;
export function getDependencyInfo(packageName: string): Promise<{
  version: string;
  dependencies: string[];
  devDependencies: string[];
}>;

export {
  ScriptManager,
  MessageHandler,
  ScriptMetadata,
  ScriptEntry,
  ScriptManagerOptions,
  MessageHandlerOptions
};