import Raggle from 'raggle';

// Initialize the client
const raggle = new Raggle('your-api-key');

// Extract structured data from a URL
const result = await raggle.fetch({
  url: 'https://news.ycombinator.com/',
  schema: {
    id: 'hn-extractor',
    name: 'Hacker News Extractor',
    description: 'Extract top stories from Hacker News',
    fields: [
      {
        name: 'top_stories',
        extractionType: 'ai',
        description: 'List the top 5 stories with their titles and points'
      }
    ],
    system_message: 'Extract information from the Hacker News homepage'
  }
});

console.log(result);

// Use the match method for flexible data analysis
const matchResult = await raggle.match({
  instructions: "Analyze the sentiment of these headlines",
  input_data: [{
    description: "news headlines",
    metadata: result.top_stories
  }],
  fields: {
    sentiment: "positive/negative/neutral",
    summary: "brief analysis"
  }
});

console.log(matchResult);

// Search for information
const searchResults = await raggle.search({
  query: "Hacker News alternatives",
  max_results: 5
});

// Get the best result
const bestResult = await raggle.luckySearch({
  query: "What is Hacker News?"
});

// Direct extraction (recommended)
const result = await raggle.fetch({
  url: 'https://example.com',
  schema: {
    id: 'product-extractor',
    name: 'Product Extractor',
    description: 'Extract product information',
    fields: [
      {
        name: 'title',
        extractionType: 'ai',
        description: 'Product title'
      },
      {
        name: 'price',
        extractionType: 'ai',
        description: 'Product price'
      }
    ]
  }
});

// Use existing schema by ID
const result = await raggle.fetch({
  url: 'https://example.com',
  schema_id: 'existing-schema-id'
});

// Extract with content instead of URL
const result = await raggle.fetch({
  content: 'extract data from this url https://example.com',
  schema_id: 'existing-schema-id'
});

// Match and analyze data
const result = await raggle.match({
  instructions: "You're an analyst of news items and trends",
  input_data: [
    {
      description: "list of trends to match against",
      metadata: [
        { id: 1, headline: "AI continues to transform industries" },
        { id: 2, headline: "Climate tech investment surges" }
      ]
    }
  ],
  fields: {
    trends: [{ id: "trend ID", confidence: "high/medium/low" }],
    reasoning: "explanation of why these trends match"
  },
  url: "https://news.example.com" // Optional URL to fetch additional data
});

// Search - returns multiple results
const results = await raggle.search({
  query: "machine learning tutorials",
  max_results: 10
});

// Lucky search - returns single best result
const result = await raggle.luckySearch({
  query: "latest AI news"
});

// Create extraction job
const job = await raggle.jobs.create({
  url: 'https://example.com',
  schema_id: 'schema-id'
});

// List all jobs
const jobs = await raggle.jobs.list({
  skip: 0,
  limit: 10
});

// Get job status
const jobDetails = await raggle.jobs.get(job.id);

// Cancel a job
await raggle.jobs.cancel(job.id);

// Create new schema
const schema = await raggle.extractions.create({
  name: 'E-commerce Product Schema',
  description: 'Extract product information from e-commerce sites',
  fields: [
    {
      name: 'title',
      extractionType: 'ai',
      description: 'Product title'
    },
    {
      name: 'price',
      extractionType: 'ai',
      description: 'Current price'
    },
    {
      name: 'availability',
      extractionType: 'ai',
      description: 'Stock availability'
    }
  ],
  system_message: 'Extract product information accurately'
});

// List all schemas
const schemas = await raggle.extractions.list({
  skip: 0,
  limit: 10
});

// Get schema details
const schemaDetails = await raggle.extractions.get(schema.id);

// Update schema
const updated = await raggle.extractions.update(schema.id, {
  name: 'Updated Product Schema',
  fields: [/* updated fields */]
});

// Delete schema
await raggle.extractions.delete(schema.id);

// List public template schemas
const templates = await raggle.extractions.listPublic();

// Basic health check
const health = await raggle.health.check();

// Detailed health status
const detailed = await raggle.health.detailed();

const raggle = new Raggle('api-key');

// Direct methods (simplified API)
raggle.fetch(options)         // Extract data from URL
raggle.match(options)         // Match data with custom instructions
raggle.search(options)         // Search with multiple results
raggle.luckySearch(options)   // Search single best result

// Resource APIs (for advanced use)
raggle.extract.fetch(options) // Same as raggle.fetch()
raggle.jobs.create(params)    // Create extraction job
raggle.jobs.list(params)      // List jobs
raggle.jobs.get(id)          // Get job details
raggle.jobs.cancel(id)       // Cancel job

raggle.extractions.create(schema)     // Create schema
raggle.extractions.list(params)       // List schemas
raggle.extractions.get(id)           // Get schema
raggle.extractions.update(id, data)  // Update schema
raggle.extractions.delete(id)        // Delete schema
raggle.extractions.listPublic()      // List public templates

raggle.search.lucky(params)   // Same as raggle.luckySearch()
raggle.search.query(params)   // Same as raggle.search()

raggle.health.check()         // Basic health check
raggle.health.detailed()      // Detailed status

// API Key
const raggle = new Raggle('your-api-key');

// Bearer Token
const raggle = new Raggle({
  type: 'bearer',
  token: 'your-bearer-token'
});

// OAuth2
const raggle = new Raggle({
  type: 'oauth2',
  accessToken: 'your-access-token'
});

const raggle = new Raggle('your-api-key', {
  baseUrl: 'https://api.raggle.co',
  timeout: 60000,
  maxRetries: 3,
  debug: true
});