import type { McpMePlugin, PluginResource, PluginTool, PluginPrompt } from "mcp-me";

export interface McpMePlugin {
  // Unique identifier, e.g. "goodreads"
  name: string;

  // Human-readable description
  description: string;

  // Semver version string
  version: string;

  // Called once with user config from .mcp-me.yaml
  initialize(config: Record<string, unknown>): Promise<void>;

  // MCP Resources this plugin exposes
  getResources(): PluginResource[];

  // MCP Tools this plugin provides
  getTools(): PluginTool[];

  // Optional: MCP Prompts
  getPrompts?(): PluginPrompt[];

  // Optional: cleanup on server shutdown
  destroy?(): Promise<void>;
}

// src/schema.ts
import { z } from "zod";

export const goodreadsConfigSchema = z.object({
  enabled: z.boolean().optional().default(true),
  user_id: z.string().describe("Your Goodreads user ID"),
  api_key_env: z.string().optional().describe("Env var for Goodreads API key"),
});

export type GoodreadsConfig = z.infer<typeof goodreadsConfigSchema>;

// src/index.ts
import { z } from "zod";
import type { McpMePlugin, PluginResource, PluginTool } from "mcp-me";
import { goodreadsConfigSchema, type GoodreadsConfig } from "./schema.js";

class GoodreadsPlugin implements McpMePlugin {
  name = "goodreads";
  description = "Shows reading list and book reviews from Goodreads.";
  version = "0.1.0";

  private config!: GoodreadsConfig;

  async initialize(rawConfig: Record<string, unknown>): Promise<void> {
    this.config = goodreadsConfigSchema.parse(rawConfig);
  }

  getResources(): PluginResource[] {
    return [
      {
        name: "goodreads-reading-list",
        uri: "me://goodreads/reading-list",
        title: "Reading List",
        description: "Current reading list from Goodreads",
        read: async () => {
          // Fetch from Goodreads API or scrape
          const books = await this.fetchReadingList();
          return JSON.stringify(books, null, 2);
        },
      },
    ];
  }

  getTools(): PluginTool[] {
    return [
      {
        name: "get_goodreads_books",
        title: "Get Books",
        description: "Get books from a specific shelf",
        inputSchema: z.object({
          shelf: z.string().optional().describe("Shelf name, e.g. 'read', 'to-read'"),
        }),
        annotations: { readOnlyHint: true },
        execute: async (input) => {
          const shelf = (input.shelf as string) ?? "read";
          const books = await this.fetchShelf(shelf);
          return JSON.stringify(books, null, 2);
        },
      },
    ];
  }

  private async fetchReadingList() {
    // Your implementation here
    return [];
  }

  private async fetchShelf(_shelf: string) {
    // Your implementation here
    return [];
  }
}

// IMPORTANT: Export a default factory function
export default function createPlugin(): McpMePlugin {
  return new GoodreadsPlugin();
}

// ✅ Correct
export default function createPlugin(): McpMePlugin {
  return new MyPlugin();
}

// ✅ Also correct
export function createPlugin(): McpMePlugin {
  return new MyPlugin();
}

// ❌ Wrong — don't export a class or instance directly
export default new MyPlugin();

interface PluginResource {
  name: string;           // Unique name, e.g. "goodreads-reading-list"
  uri: string;            // URI pattern: "me://<plugin>/<resource>"
  title: string;          // Human-readable title
  description: string;    // What this resource provides
  mimeType?: string;      // Default: "application/json"
  read: () => Promise<string>;  // Returns the resource content
}

interface PluginTool {
  name: string;           // Unique name, e.g. "get_goodreads_books"
  title: string;          // Human-readable title
  description: string;    // What this tool does
  inputSchema: z.ZodType; // Zod schema for input validation
  annotations?: {         // Behavioral hints
    readOnlyHint?: boolean;
    destructiveHint?: boolean;
    idempotentHint?: boolean;
  };
  execute: (input: Record<string, unknown>) => Promise<string>;
}

interface PluginPrompt {
  name: string;
  title: string;
  description: string;
  argsSchema?: z.ZodType;
  generate: (args: Record<string, unknown>) => { role: "user" | "assistant"; content: string }[];
}