abstract class StellarPlugin {
  abstract readonly manifest: PluginManifest;
  abstract onEnable(context: PluginContext): Promise<void>;
  abstract onDisable(context: PluginContext): Promise<void>;
  
  getRoutes?(): PluginRoute[];
  onConfigUpdate?(
    context: PluginContext,
    oldConfig: Record<string, unknown>,
    newConfig: Record<string, unknown>
  ): Promise<void>;
  validateConfig?(config: Record<string, unknown>): string | null;
}

class PluginContext {
  // Properties
  readonly manifest: PluginManifest;
  readonly pluginId: string;
  readonly api: PluginAPI;
  readonly config: Record<string, unknown>;
  readonly log: Logger;
  
  // Methods
  updateConfig(updates: Record<string, unknown>): void;
  on(event: PluginHookEvent, handler: HookHandler, priority?: HookPriority): void;
  addFilter(name: string, filter: HookFilter, priority?: HookPriority): void;
}

class HookRegistry {
  on(event: PluginHookEvent, pluginId: string, handler: HookHandler, priority?: HookPriority): void;
  removePlugin(pluginId: string): void;
  addFilter(name: string, pluginId: string, filter: HookFilter, priority?: HookPriority): void;
  async emit(event: PluginHookEvent, context: Omit<HookContext, "event" | "timestamp">): Promise<void>;
  async applyFilters<T>(name: string, value: T, context: Omit<HookContext, "event" | "timestamp">): Promise<T>;
  getRegisteredHooks(): Record<string, string[]>;
  hasHooks(event: PluginHookEvent): boolean;
}

interface PluginManifest {
  id: string;
  name: string;
  version: string;
  description: string;
  author: string;
  license?: string;
  homepage?: string;
  repository?: string;
  icon?: string;
  minVersion?: string;
  category?: "game-management" | "modding" | "monitoring" | "automation" | "integration" | "security" | "utility" | "theme" | "other";
  gameTypes?: string[];
  permissions?: string[];
  hooks?: string[];
  ui?: PluginUIDefinition;
  configSchema?: Record<string, unknown>;
  defaultConfig?: Record<string, unknown>;
  actions?: ExtensionAction[];
}

type PluginStatus = "installed" | "enabled" | "disabled" | "error" | "updating";

type PluginHookEvent =
  // Server lifecycle
  | "server:beforeStart"
  | "server:afterStart"
  | "server:beforeStop"
  | "server:afterStop"
  | "server:beforeRestart"
  | "server:afterRestart"
  | "server:beforeInstall"
  | "server:afterInstall"
  | "server:statusChange"
  | "server:created"
  | "server:deleted"
  // Console
  | "server:console"
  // File operations
  | "server:file:beforeWrite"
  | "server:file:afterWrite"
  | "server:file:beforeDelete"
  | "server:file:afterDelete"
  // Backups
  | "server:backup:beforeCreate"
  | "server:backup:afterCreate"
  | "server:backup:beforeRestore"
  | "server:backup:afterRestore"
  // Schedules
  | "server:schedule:beforeExecute"
  | "server:schedule:afterExecute"
  // User actions
  | "user:login"
  | "user:created"
  // Plugin lifecycle
  | "plugin:enabled"
  | "plugin:disabled"
  | "plugin:configUpdated";

interface HookContext {
  event: PluginHookEvent;
  serverId?: string;
  userId?: string;
  data: Record<string, unknown>;
  timestamp: Date;
}

type HookHandler = (context: HookContext) => Promise<void> | void;

type HookFilter<T = unknown> = (value: T, context: HookContext) => Promise<T> | T;

type HookPriority = "low" | "normal" | "high" | "critical";

interface PluginAPI {
  servers: ServerAPI;
  files: FileAPI;
  storage: StorageAPI;
  http: HttpAPI;
  log: Logger;
  notify: NotificationAPI;
}

interface ServerAPI {
  get(serverId: string): Promise<ServerInfo>;
  list(): Promise<ServerInfo[]>;
  sendCommand(serverId: string, command: string): Promise<void>;
  getStatus(serverId: string): Promise<string>;
}

const server = await context.api.servers.get("srv_abc123");
console.log(server.name, server.status);

const servers = await context.api.servers.list();
servers.forEach(s => console.log(s.name));

await context.api.servers.sendCommand(serverId, "say Hello world!");

const status = await context.api.servers.getStatus(serverId);
// Returns: "running" | "stopped" | "starting" | "stopping" | "crashed"

interface FileAPI {
  list(serverId: string, path?: string): Promise<FileInfo[]>;
  read(serverId: string, path: string): Promise<string>;
  write(serverId: string, path: string, content: string): Promise<void>;
  create(serverId: string, path: string, type: "file" | "directory", content?: string): Promise<void>;
  delete(serverId: string, path: string): Promise<void>;
  downloadUrl(serverId: string, url: string, destPath: string): Promise<void>;
}

const files = await context.api.files.list(serverId, "plugins");
files.forEach(f => console.log(f.name, f.size));

const config = await context.api.files.read(serverId, "server.properties");
console.log(config);

await context.api.files.write(
  serverId,
  "server.properties",
  "motd=Welcome!\ndifficulty=hard"
);

await context.api.files.create(serverId, "backups", "directory");
await context.api.files.create(serverId, "config.yml", "file", "enabled: true");

await context.api.files.delete(serverId, "old-plugin.jar");

await context.api.files.downloadUrl(
  serverId,
  "https://example.com/plugin.jar",
  "plugins/plugin.jar"
);

interface StorageAPI {
  get<T = unknown>(key: string): Promise<T | null>;
  set<T = unknown>(key: string, value: T): Promise<void>;
  delete(key: string): Promise<void>;
  keys(): Promise<string[]>;
}

const lastSync = await context.api.storage.get<number>("lastSync");
if (lastSync === null) {
  console.log("Never synced");
}

await context.api.storage.set("lastSync", Date.now());
await context.api.storage.set("config", { enabled: true });

await context.api.storage.delete("lastSync");

const keys = await context.api.storage.keys();
console.log("Stored keys:", keys);

interface HttpAPI {
  get<T = unknown>(url: string, headers?: Record<string, string>): Promise<T>;
  post<T = unknown>(url: string, body?: unknown, headers?: Record<string, string>): Promise<T>;
  put<T = unknown>(url: string, body?: unknown, headers?: Record<string, string>): Promise<T>;
  delete<T = unknown>(url: string, headers?: Record<string, string>): Promise<T>;
}

interface ApiResponse {
  version: string;
  downloads: number;
}

const data = await context.api.http.get<ApiResponse>(
  "https://api.example.com/mod/123",
  { "X-API-Key": apiKey }
);

console.log(data.version);

const result = await context.api.http.post(
  "https://api.example.com/install",
  { modId: 123, serverId: "srv_abc" },
  { "Content-Type": "application/json" }
);

await context.api.http.put(
  "https://api.example.com/config",
  { enabled: true }
);

await context.api.http.delete(
  "https://api.example.com/mod/123",
  { "X-API-Key": apiKey }
);

interface Logger {
  info(message: string, ...args: unknown[]): void;
  warn(message: string, ...args: unknown[]): void;
  error(message: string, ...args: unknown[]): void;
  debug(message: string, ...args: unknown[]): void;
}

context.log.info("Server started", { serverId });
context.log.warn("Deprecated API used");
context.log.error("Failed to connect", error);
context.log.debug("Verbose debug info"); // Only in development

interface NotificationAPI {
  toast(serverId: string, message: string, type?: "success" | "error" | "warning" | "info"): void;
}

context.api.notify.toast(serverId, "Backup completed!", "success");
context.api.notify.toast(serverId, "Failed to start", "error");
context.api.notify.toast(serverId, "Server restarting...", "info");

interface ServerInfo {
  id: string;
  name: string;
  description?: string;
  status: string;
  memory: number;
  disk: number;
  cpu: number;
  nodeId: string;
  blueprintId: string;
  ownerId: string;
  blueprint?: {
    id: string;
    name: string;
    category?: string;
  };
}

interface FileInfo {
  name: string;
  path: string;
  type: "file" | "directory";
  size: number;
  modified: string;
}

interface ExtensionAction {
  id: string;
  label: string;
  description?: string;
  icon?: string;
  dangerous?: boolean;
  params?: ExtensionActionParam[];
  operations: ExtensionOperation[];
}

interface ExtensionActionParam {
  id: string;
  label: string;
  description?: string;
  type: "string" | "number" | "boolean" | "select";
  required?: boolean;
  default?: string | number | boolean;
  options?: Array<{ label: string; value: string }>;
}

type ExtensionOperation =
  | { type: "download-to-server"; url: string; directory: string; filename?: string; decompress?: boolean }
  | { type: "write-file"; path: string; content: string }
  | { type: "delete-file"; path: string }
  | { type: "send-command"; command: string }
  | { type: "restart-server" }
  | { type: "stop-server" }
  | { type: "start-server" }
  | { type: "create-backup"; name?: string };

interface ServerTabProps {
  serverId: string;
  server: ServerInfo;
  pluginConfig: Record<string, unknown>;
}

interface ServerWidgetProps {
  serverId: string;
  server: ServerInfo;
  pluginConfig: Record<string, unknown>;
}

interface AdminPageProps {
  pluginConfig: Record<string, unknown>;
}

interface SettingsPanelProps {
  config: Record<string, unknown>;
  onConfigChange: (config: Record<string, unknown>) => void;
}

const permissions = [
  "files.*",           // All file operations
  "files.read",        // Read files
  "files.write",       // Write/create files
  "files.delete",      // Delete files
  "console.send",      // Send console commands
  "console.read",      // Read console output
  "control.*",         // All server control
  "control.start",     // Start servers
  "control.stop",      // Stop servers
  "control.restart",   // Restart servers
  "backups.create",    // Create backups
  "backups.restore",   // Restore backups
  "backups.delete",    // Delete backups
  "activity.read",     // Read activity logs
  "users.read",        // Read user data
  "users.write",       // Modify user data
  "admin.*",           // Admin access (dangerous)
];

try {
  await context.api.servers.sendCommand(serverId, "say Hello");
} catch (error) {
  if (error.message.includes("permission")) {
    context.log.error("Missing permission: console.send");
  } else if (error.message.includes("not found")) {
    context.log.error("Server not found");
  } else {
    context.log.error("Unknown error", error);
  }
}

import { StellarPlugin, PluginContext } from "@stellarstack/plugin-sdk";

export default class BackupScheduler extends StellarPlugin {
  private intervals = new Map<string, NodeJS.Timeout>();

  manifest = {
    id: "backup-scheduler",
    name: "Backup Scheduler",
    version: "1.0.0",
    description: "Automatically create server backups on a schedule",
    author: "StellarStack",
    category: "automation" as const,
    permissions: ["backups.create", "console.send"],
    configSchema: {
      type: "object",
      properties: {
        intervalHours: {
          type: "number",
          title: "Backup Interval (hours)",
          minimum: 1,
          maximum: 168,
          default: 24,
        },
        warnPlayers: {
          type: "boolean",
          title: "Warn Players",
          default: true,
        },
      },
    },
    defaultConfig: {
      intervalHours: 24,
      warnPlayers: true,
    },
  };

  async onEnable(context: PluginContext): Promise<void> {
    context.log.info("Backup scheduler enabled");

    // Start backup schedule for all servers
    const servers = await context.api.servers.list();
    servers.forEach(server => {
      this.scheduleBackup(context, server.id);
    });

    // Schedule backups for newly created servers
    context.on("server:created", async (ctx) => {
      this.scheduleBackup(context, ctx.serverId!);
    });

    // Clean up schedule when server is deleted
    context.on("server:deleted", async (ctx) => {
      const interval = this.intervals.get(ctx.serverId!);
      if (interval) {
        clearInterval(interval);
        this.intervals.delete(ctx.serverId!);
      }
    });
  }

  async onDisable(context: PluginContext): Promise<void> {
    // Stop all backup schedules
    this.intervals.forEach(interval => clearInterval(interval));
    this.intervals.clear();
    context.log.info("Backup scheduler disabled");
  }

  private scheduleBackup(context: PluginContext, serverId: string): void {
    const hours = context.config.intervalHours as number;
    const interval = setInterval(async () => {
      await this.createBackup(context, serverId);
    }, hours * 60 * 60 * 1000);

    this.intervals.set(serverId, interval);
    context.log.info(`Scheduled backups every ${hours}h for ${serverId}`);
  }

  private async createBackup(context: PluginContext, serverId: string): Promise<void> {
    try {
      const warnPlayers = context.config.warnPlayers as boolean;

      if (warnPlayers) {
        await context.api.servers.sendCommand(
          serverId,
          "say Creating backup in 10 seconds..."
        );
        await new Promise(resolve => setTimeout(resolve, 10000));
      }

      const timestamp = new Date().toISOString().split("T")[0];
      const backupName = `auto-${timestamp}-${Date.now()}`;

      // Create backup through action execution would happen here
      // For now just log
      context.log.info(`Created backup: ${backupName}`);

      if (warnPlayers) {
        await context.api.servers.sendCommand(
          serverId,
          "say Backup complete!"
        );
      }

      await context.api.notify.toast(serverId, "Backup created", "success");
    } catch (error) {
      context.log.error(`Backup failed for ${serverId}`, error);
      await context.api.notify.toast(serverId, "Backup failed", "error");
    }
  }
}