// bookmark-manager.js - Thoughtfully designed bookmark tool
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import Database from 'better-sqlite3';
import fetch from 'node-fetch';
import { JSDOM } from 'jsdom';
import path from 'path';
import os from 'os';

class BookmarkManager {
  constructor() {
    // Store in user's home directory
    const dbPath = path.join(os.homedir(), '.mcp-bookmarks.db');
    this.db = new Database(dbPath);
    this.initDatabase();
  }
  
  initDatabase() {
    this.db.exec(`
      CREATE TABLE IF NOT EXISTS bookmarks (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        url TEXT UNIQUE NOT NULL,
        title TEXT,
        description TEXT,
        tags TEXT,
        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
        accessed_count INTEGER DEFAULT 0,
        last_accessed DATETIME,
        is_archived BOOLEAN DEFAULT 0
      )
    `);
  }
  
  // Smart extraction of metadata
  async extractMetadata(url) {
    try {
      const response = await fetch(url, { timeout: 5000 });
      const html = await response.text();
      const dom = new JSDOM(html);
      const doc = dom.window.document;
      
      // Try various metadata sources
      const title = 
        doc.querySelector('meta[property="og:title"]')?.content ||
        doc.querySelector('title')?.textContent ||
        new URL(url).hostname;
        
      const description =
        doc.querySelector('meta[property="og:description"]')?.content ||
        doc.querySelector('meta[name="description"]')?.content ||
        '';
      
      // Auto-generate tags from URL and content
      const autoTags = [];
      const urlParts = new URL(url).hostname.split('.');
      autoTags.push(urlParts[urlParts.length - 2]); // Domain name
      
      if (url.includes('github.com')) autoTags.push('code', 'github');
      if (url.includes('youtube.com')) autoTags.push('video', 'youtube');
      if (url.includes('arxiv.org')) autoTags.push('research', 'paper');
      
      return {
        title: title.trim().substring(0, 200),
        description: description.trim().substring(0, 500),
        suggestedTags: autoTags
      };
    } catch (error) {
      console.error('Failed to extract metadata:', error);
      return {
        title: new URL(url).hostname,
        description: '',
        suggestedTags: []
      };
    }
  }
  
  // Tool implementations
  async addBookmark(url, { title, description, tags = [] } = {}) {
    // Extract metadata if not provided
    if (!title || !description) {
      const metadata = await this.extractMetadata(url);
      title = title || metadata.title;
      description = description || metadata.description;
      tags = [...tags, ...metadata.suggestedTags];
    }
    
    try {
      const stmt = this.db.prepare(`
        INSERT INTO bookmarks (url, title, description, tags)
        VALUES (?, ?, ?, ?)
      `);
      
      const result = stmt.run(
        url,
        title,
        description,
        [...new Set(tags)].join(',')  // Unique tags
      );
      
      return {
        id: result.lastInsertRowid,
        url,
        title,
        description,
        tags: [...new Set(tags)]
      };
    } catch (error) {
      if (error.code === 'SQLITE_CONSTRAINT_UNIQUE') {
        // Update existing bookmark
        const updateStmt = this.db.prepare(`
          UPDATE bookmarks 
          SET accessed_count = accessed_count + 1,
              last_accessed = CURRENT_TIMESTAMP
          WHERE url = ?
        `);
        updateStmt.run(url);
        
        const existing = this.db.prepare('SELECT * FROM bookmarks WHERE url = ?').get(url);
        return { ...existing, tags: existing.tags.split(','), updated: true };
      }
      throw error;
    }
  }
  
  searchBookmarks({ query, tags = [], limit = 20 }) {
    let sql = `
      SELECT * FROM bookmarks 
      WHERE is_archived = 0
    `;
    const params = [];
    
    if (query) {
      sql += ` AND (title LIKE ? OR description LIKE ? OR url LIKE ?)`;
      const searchTerm = `%${query}%`;
      params.push(searchTerm, searchTerm, searchTerm);
    }
    
    if (tags.length > 0) {
      const tagConditions = tags.map(() => `tags LIKE ?`).join(' AND ');
      sql += ` AND (${tagConditions})`;
      tags.forEach(tag => params.push(`%${tag}%`));
    }
    
    sql += ` ORDER BY accessed_count DESC, created_at DESC LIMIT ?`;
    params.push(limit);
    
    const results = this.db.prepare(sql).all(...params);
    
    return results.map(bookmark => ({
      ...bookmark,
      tags: bookmark.tags ? bookmark.tags.split(',') : []
    }));
  }
  
  getSmartSuggestions() {
    // Get recently accessed
    const recent = this.db.prepare(`
      SELECT * FROM bookmarks
      WHERE last_accessed IS NOT NULL
      ORDER BY last_accessed DESC
      LIMIT 5
    `).all();
    
    // Get frequently accessed
    const frequent = this.db.prepare(`
      SELECT * FROM bookmarks
      WHERE accessed_count > 2
      ORDER BY accessed_count DESC
      LIMIT 5
    `).all();
    
    // Get by time of day
    const hour = new Date().getHours();
    const timeBasedTags = hour < 12 ? ['news', 'morning'] : 
                         hour < 17 ? ['work', 'reference'] :
                         ['entertainment', 'leisure'];
    
    const timeBased = this.db.prepare(`
      SELECT * FROM bookmarks
      WHERE ${timeBasedTags.map(() => 'tags LIKE ?').join(' OR ')}
      LIMIT 3
    `).all(...timeBasedTags.map(tag => `%${tag}%`));
    
    return {
      recent: recent.map(b => ({ ...b, tags: b.tags?.split(',') || [] })),
      frequent: frequent.map(b => ({ ...b, tags: b.tags?.split(',') || [] })),
      recommended: timeBased.map(b => ({ ...b, tags: b.tags?.split(',') || [] }))
    };
  }
}

// MCP Server setup
const server = new Server(
  {
    name: 'bookmark-manager',
    version: '1.0.0',
  },
  {
    capabilities: {
      tools: {},
    },
  }
);

const bookmarks = new BookmarkManager();

server.setRequestHandler('tools/call', async (request) => {
  const { name, arguments: args } = request.params;
  
  switch (name) {
    case 'add_bookmark': {
      const result = await bookmarks.addBookmark(args.url, {
        title: args.title,
        description: args.description,
        tags: args.tags
      });
      
      return {
        content: [{
          type: 'text',
          text: result.updated 
            ? `Updated existing bookmark: ${result.title}`
            : `Added bookmark: ${result.title}\nTags: ${result.tags.join(', ')}`
        }]
      };
    }
    
    case 'search_bookmarks': {
      const results = bookmarks.searchBookmarks({
        query: args.query,
        tags: args.tags,
        limit: args.limit
      });
      
      if (results.length === 0) {
        return {
          content: [{
            type: 'text',
            text: 'No bookmarks found matching your search.'
          }]
        };
      }
      
      const response = results.map(b => 
        `**${b.title}**\n${b.url}\n${b.description || 'No description'}\nTags: ${b.tags.join(', ')}\n`
      ).join('\n---\n\n');
      
      return {
        content: [{
          type: 'text',
          text: `Found ${results.length} bookmarks:\n\n${response}`
        }]
      };
    }
    
    case 'get_bookmark_suggestions': {
      const suggestions = bookmarks.getSmartSuggestions();
      
      const response = `# Bookmark Suggestions

## Recently Used
${suggestions.recent.map(b => `- **${b.title}** - ${b.url}`).join('\n') || 'None yet'}

## Frequently Accessed  
${suggestions.frequent.map(b => `- **${b.title}** (${b.accessed_count} times)`).join('\n') || 'None yet'}

## Recommended for This Time
${suggestions.recommended.map(b => `- **${b.title}** - ${b.tags.join(', ')}`).join('\n') || 'None yet'}`;
      
      return {
        content: [{
          type: 'text',
          text: response
        }]
      };
    }
    
    default:
      throw new Error(`Unknown tool: ${name}`);
  }
});

server.setRequestHandler('tools/list', async () => {
  return {
    tools: [
      {
        name: 'add_bookmark',
        description: 'Add or update a bookmark with automatic metadata extraction',
        inputSchema: {
          type: 'object',
          properties: {
            url: {
              type: 'string',
              description: 'URL to bookmark'
            },
            title: {
              type: 'string',
              description: 'Optional title (auto-extracted if not provided)'
            },
            description: {
              type: 'string',
              description: 'Optional description (auto-extracted if not provided)'
            },
            tags: {
              type: 'array',
              items: { type: 'string' },
              description: 'Tags for categorization'
            }
          },
          required: ['url']
        }
      },
      {
        name: 'search_bookmarks',
        description: 'Search bookmarks by text or tags',
        inputSchema: {
          type: 'object',
          properties: {
            query: {
              type: 'string',
              description: 'Search in title, description, and URL'
            },
            tags: {
              type: 'array',
              items: { type: 'string' },
              description: 'Filter by tags (AND operation)'
            },
            limit: {
              type: 'number',
              description: 'Maximum results to return',
              default: 20
            }
          }
        }
      },
      {
        name: 'get_bookmark_suggestions',
        description: 'Get smart bookmark suggestions based on usage patterns',
        inputSchema: {
          type: 'object',
          properties: {}
        }
      }
    ]
  };
});

const transport = new StdioServerTransport();
await server.connect(transport);
console.error('Bookmark Manager Server running...');