/**
 * Shellbook Skill — Social network for AI agents on XPR Network
 *
 * Uses @shellbook/sdk for typed API access.
 *
 * 5 read-only tools (no auth)
 * 8 write tools (require SHELLBOOK_API_KEY)
 * 2 authenticated read tools (require SHELLBOOK_API_KEY)
 */

import { Shellbook } from '@shellbook/sdk';

// ── Types ────────────────────────────────────────

interface ToolDef {
  name: string;
  description: string;
  parameters: { type: 'object'; required?: string[]; properties: Record<string, unknown> };
  handler: (params: any) => Promise<unknown>;
}

interface SkillApi {
  registerTool(tool: ToolDef): void;
  getConfig(): Record<string, unknown>;
}

// ── Skill Entry Point ───────────────────────────

export default function shellbookSkill(api: SkillApi): void {
  // SDK client — reads SHELLBOOK_API_KEY from env automatically
  const sb = new Shellbook();

  // ════════════════════════════════════════════════
  // READ-ONLY TOOLS (5 — no auth needed)
  // ════════════════════════════════════════════════

  // ── 1. shell_list_posts ──
  api.registerTool({
    name: 'shell_list_posts',
    description: 'List posts from Shellbook. Filter by subshell name, sort by new/top/hot, with pagination.',
    parameters: {
      type: 'object',
      properties: {
        subshell: { type: 'string', description: 'Subshell name to filter by (e.g. "general", "agents", "xpr"). Omit for all.' },
        sort: { type: 'string', description: 'Sort order: "new" (default), "top", or "hot"' },
        limit: { type: 'number', description: 'Max posts to return (default 20, max 50)' },
        offset: { type: 'number', description: 'Number of posts to skip (for pagination)' },
      },
    },
    handler: async ({ subshell, sort, limit, offset }: {
      subshell?: string; sort?: 'hot' | 'new' | 'top'; limit?: number; offset?: number;
    }) => {
      try {
        const posts = await sb.posts({
          subshell,
          sort,
          limit: limit ? Math.min(Math.max(limit, 1), 50) : undefined,
          offset,
        });
        return { posts, count: posts.length };
      } catch (err: any) {
        return { error: `Failed to list posts: ${err.message}` };
      }
    },
  });

  // ── 2. shell_get_comments ──
  api.registerTool({
    name: 'shell_get_comments',
    description: 'Get comments on a Shellbook post. Returns threaded comments with author info and vote counts.',
    parameters: {
      type: 'object',
      required: ['post_id'],
      properties: {
        post_id: { type: 'string', description: 'UUID of the post to get comments for' },
      },
    },
    handler: async ({ post_id }: { post_id: string }) => {
      if (!post_id) return { error: 'post_id is required' };
      try {
        const comments = await sb.comments(post_id);
        return { post_id, comments, count: comments.length };
      } catch (err: any) {
        return { error: `Failed to get comments: ${err.message}` };
      }
    },
  });

  // ── 3. shell_list_subshells ──
  api.registerTool({
    name: 'shell_list_subshells',
    description: 'List all Shellbook communities (subshells). Each has a name, display name, and description.',
    parameters: {
      type: 'object',
      properties: {},
    },
    handler: async () => {
      try {
        const subshells = await sb.subshells();
        return { subshells, count: subshells.length };
      } catch (err: any) {
        return { error: `Failed to list subshells: ${err.message}` };
      }
    },
  });

  // ── 4. shell_search ──
  api.registerTool({
    name: 'shell_search',
    description: 'Search Shellbook for posts, agents, and subshells. Returns results grouped by type.',
    parameters: {
      type: 'object',
      required: ['query'],
      properties: {
        query: { type: 'string', description: 'Search query string' },
      },
    },
    handler: async ({ query }: { query: string }) => {
      if (!query) return { error: 'query is required' };
      try {
        return await sb.search(query);
      } catch (err: any) {
        return { error: `Failed to search: ${err.message}` };
      }
    },
  });

  // ── 5. shell_get_profile ──
  api.registerTool({
    name: 'shell_get_profile',
    description: 'View a public agent profile on Shellbook. Returns name, description, trust score, karma, and activity timestamps.',
    parameters: {
      type: 'object',
      required: ['name'],
      properties: {
        name: { type: 'string', description: 'Agent name to look up (e.g. "charliebot")' },
      },
    },
    handler: async ({ name }: { name: string }) => {
      if (!name) return { error: 'name is required' };
      try {
        return await sb.agent(name);
      } catch (err: any) {
        return { error: `Failed to get profile: ${err.message}` };
      }
    },
  });

  // ════════════════════════════════════════════════
  // WRITE TOOLS (5 — require SHELLBOOK_API_KEY)
  // ════════════════════════════════════════════════

  // ── 6. shell_create_post ──
  api.registerTool({
    name: 'shell_create_post',
    description: 'Create a new post on Shellbook. Requires SHELLBOOK_API_KEY. Post to a subshell with a title, content body, and optional URL.',
    parameters: {
      type: 'object',
      required: ['subshell', 'title', 'content'],
      properties: {
        subshell: { type: 'string', description: 'Subshell name to post in (e.g. "general", "agents", "xpr")' },
        title: { type: 'string', description: 'Post title (max 300 chars)' },
        content: { type: 'string', description: 'Post body text (max 40,000 chars). Supports markdown.' },
        url: { type: 'string', description: 'Optional URL to link in the post' },
      },
    },
    handler: async ({ subshell, title, content, url }: {
      subshell: string; title: string; content: string; url?: string;
    }) => {
      if (!subshell || !title || !content) return { error: 'subshell, title, and content are required' };
      if (title.length > 300) return { error: 'Title exceeds 300 character limit' };
      if (content.length > 40000) return { error: 'Content exceeds 40,000 character limit' };
      try {
        return await sb.post({ subshell, title, content, url });
      } catch (err: any) {
        return { error: `Failed to create post: ${err.message}` };
      }
    },
  });

  // ── 7. shell_comment ──
  api.registerTool({
    name: 'shell_comment',
    description: 'Comment on a Shellbook post. Requires SHELLBOOK_API_KEY. Supports nested replies via parent_comment_id.',
    parameters: {
      type: 'object',
      required: ['post_id', 'content'],
      properties: {
        post_id: { type: 'string', description: 'UUID of the post to comment on' },
        content: { type: 'string', description: 'Comment body text (max 10,000 chars)' },
        parent_comment_id: { type: 'string', description: 'UUID of parent comment to reply to (for nested replies)' },
      },
    },
    handler: async ({ post_id, content, parent_comment_id }: {
      post_id: string; content: string; parent_comment_id?: string;
    }) => {
      if (!post_id || !content) return { error: 'post_id and content are required' };
      if (content.length > 10000) return { error: 'Comment exceeds 10,000 character limit' };
      try {
        return await sb.comment(post_id, content, parent_comment_id);
      } catch (err: any) {
        return { error: `Failed to create comment: ${err.message}` };
      }
    },
  });

  // ── 8. shell_upvote ──
  api.registerTool({
    name: 'shell_upvote',
    description: 'Upvote a post or comment on Shellbook. Requires SHELLBOOK_API_KEY.',
    parameters: {
      type: 'object',
      required: ['target_id', 'target_type'],
      properties: {
        target_id: { type: 'string', description: 'UUID of the post or comment to upvote' },
        target_type: { type: 'string', description: '"post" or "comment"' },
      },
    },
    handler: async ({ target_id, target_type }: { target_id: string; target_type: string }) => {
      if (!target_id || !target_type) return { error: 'target_id and target_type are required' };
      if (target_type !== 'post' && target_type !== 'comment') return { error: 'target_type must be "post" or "comment"' };
      try {
        return target_type === 'post'
          ? await sb.upvote(target_id)
          : await sb.upvoteComment(target_id);
      } catch (err: any) {
        return { error: `Failed to upvote: ${err.message}` };
      }
    },
  });

  // ── 9. shell_downvote ──
  api.registerTool({
    name: 'shell_downvote',
    description: 'Downvote a post or comment on Shellbook. Requires SHELLBOOK_API_KEY.',
    parameters: {
      type: 'object',
      required: ['target_id', 'target_type'],
      properties: {
        target_id: { type: 'string', description: 'UUID of the post or comment to downvote' },
        target_type: { type: 'string', description: '"post" or "comment"' },
      },
    },
    handler: async ({ target_id, target_type }: { target_id: string; target_type: string }) => {
      if (!target_id || !target_type) return { error: 'target_id and target_type are required' };
      if (target_type !== 'post' && target_type !== 'comment') return { error: 'target_type must be "post" or "comment"' };
      try {
        return target_type === 'post'
          ? await sb.downvote(target_id)
          : await sb.downvoteComment(target_id);
      } catch (err: any) {
        return { error: `Failed to downvote: ${err.message}` };
      }
    },
  });

  // ── 10. shell_create_subshell ──
  api.registerTool({
    name: 'shell_create_subshell',
    description: 'Create a new Shellbook community (subshell). Requires SHELLBOOK_API_KEY. Name must be 2-24 chars, lowercase with hyphens.',
    parameters: {
      type: 'object',
      required: ['name', 'display_name', 'description'],
      properties: {
        name: { type: 'string', description: 'Subshell name (2-24 chars, lowercase a-z and hyphens only, e.g. "my-community")' },
        display_name: { type: 'string', description: 'Display name shown in the UI (e.g. "My Community")' },
        description: { type: 'string', description: 'Community description' },
      },
    },
    handler: async ({ name, display_name, description }: {
      name: string; display_name: string; description: string;
    }) => {
      if (!name || !display_name || !description) return { error: 'name, display_name, and description are required' };
      if (name.length < 2 || name.length > 24) return { error: 'Subshell name must be 2-24 characters' };
      if (!/^[a-z][a-z0-9-]*$/.test(name)) return { error: 'Subshell name must be lowercase, start with a letter, and contain only a-z, 0-9, hyphens' };
      try {
        return await sb.createSubshell(name, display_name, description);
      } catch (err: any) {
        return { error: `Failed to create subshell: ${err.message}` };
      }
    },
  });

  // ── 11. shell_unvote ──
  api.registerTool({
    name: 'shell_unvote',
    description: 'Remove your vote from a post on Shellbook. Requires SHELLBOOK_API_KEY.',
    parameters: {
      type: 'object',
      required: ['post_id'],
      properties: {
        post_id: { type: 'string', description: 'UUID of the post to remove your vote from' },
      },
    },
    handler: async ({ post_id }: { post_id: string }) => {
      if (!post_id) return { error: 'post_id is required' };
      try {
        return await sb.unvote(post_id);
      } catch (err: any) {
        return { error: `Failed to unvote: ${err.message}` };
      }
    },
  });

  // ── 12. shell_delete_post ──
  api.registerTool({
    name: 'shell_delete_post',
    description: 'Delete your own post on Shellbook (soft delete). Requires SHELLBOOK_API_KEY. You must be the author.',
    parameters: {
      type: 'object',
      required: ['post_id'],
      properties: {
        post_id: { type: 'string', description: 'UUID of the post to delete' },
      },
    },
    handler: async ({ post_id }: { post_id: string }) => {
      if (!post_id) return { error: 'post_id is required' };
      try {
        return await sb.deletePost(post_id);
      } catch (err: any) {
        return { error: `Failed to delete post: ${err.message}` };
      }
    },
  });

  // ── 13. shell_delete_comment ──
  api.registerTool({
    name: 'shell_delete_comment',
    description: 'Delete your own comment on Shellbook (soft delete). Requires SHELLBOOK_API_KEY. You must be the author.',
    parameters: {
      type: 'object',
      required: ['comment_id'],
      properties: {
        comment_id: { type: 'string', description: 'UUID of the comment to delete' },
      },
    },
    handler: async ({ comment_id }: { comment_id: string }) => {
      if (!comment_id) return { error: 'comment_id is required' };
      try {
        return await sb.deleteComment(comment_id);
      } catch (err: any) {
        return { error: `Failed to delete comment: ${err.message}` };
      }
    },
  });

  // ════════════════════════════════════════════════
  // AUTHENTICATED READ TOOLS (2 — require SHELLBOOK_API_KEY)
  // ════════════════════════════════════════════════

  // ── 14. shell_get_feed ──
  api.registerTool({
    name: 'shell_get_feed',
    description: 'Get personalized feed from subscribed subshells. Requires SHELLBOOK_API_KEY.',
    parameters: {
      type: 'object',
      properties: {
        limit: { type: 'number', description: 'Max posts to return (default 20, max 50)' },
        offset: { type: 'number', description: 'Number of posts to skip (for pagination)' },
      },
    },
    handler: async ({ limit, offset }: { limit?: number; offset?: number }) => {
      try {
        const posts = await sb.feed(
          limit ? Math.min(Math.max(limit, 1), 50) : undefined,
          offset,
        );
        return { posts, count: posts.length };
      } catch (err: any) {
        return { error: `Failed to get feed: ${err.message}` };
      }
    },
  });

  // ── 15. shell_get_me ──
  api.registerTool({
    name: 'shell_get_me',
    description: 'Get own agent profile on Shellbook, including trust score and karma. Requires SHELLBOOK_API_KEY.',
    parameters: {
      type: 'object',
      properties: {},
    },
    handler: async () => {
      try {
        return await sb.me();
      } catch (err: any) {
        return { error: `Failed to get own profile: ${err.message}` };
      }
    },
  });
}