from langchain.tools import BaseTool
from langchain.agents import initialize_agent, Tool
from langchain.llms import OpenAI
import requests
import json

class AbbabaSearchTool(BaseTool):
    name = "abbababa_product_search"
    description = """
    Search for products on the Abbababa B2A marketplace.
    Use this when you need to find products for purchase recommendations.
    Input should be a search query string.
    """

    def __init__(self, api_key: str):
        super().__init__()
        self.api_key = api_key
        self.base_url = "https://abbababa.com/api/v1"

    def _run(self, query: str) -> str:
        headers = {
            "X-API-Key": self.api_key,
            "Content-Type": "application/json"
        }

        payload = {
            "query": query,
            "filters": {"inStock": True, "minQualityScore": 0.7},
            "limit": 5,
            "sortBy": "quality_score"
        }

        try:
            response = requests.post(
                f"{self.base_url}/search",
                headers=headers,
                json=payload
            )
            response.raise_for_status()

            data = response.json()
            products = data.get("products", [])

            if not products:
                return f"No products found for '{query}'"

            result = f"Found {len(products)} products for '{query}':\n"
            for i, product in enumerate(products, 1):
                result += f"{i}. {product['name']} - ${product['price']} "
                result += f"(Quality: {product['dataQualityScore']:.1%}) "
                result += f"from {product['merchantName']}\n"
                result += f"   Link: {product['referralUrl']}\n"

            return result

        except Exception as e:
            return f"Error searching for products: {str(e)}"

    def _arun(self, query: str):
        raise NotImplementedError("Async not supported")

# Initialize the tool and agent
abbababa_tool = AbbabaSearchTool("aba_your_api_key")

tools = [abbababa_tool]

llm = OpenAI(temperature=0)
agent = initialize_agent(
    tools,
    llm,
    agent="zero-shot-react-description",
    verbose=True
)

# Example usage
response = agent.run("I need wireless earbuds for running under $100")
print(response)

// Robust error handling with retry logic
class AbbabaClientWithRetry {
  constructor(apiKey, options = {}) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://abbababa.com/api/v1';
    this.maxRetries = options.maxRetries || 3;
    this.retryDelay = options.retryDelay || 1000;
  }

  async makeRequest(endpoint, options = {}) {
    const url = `${this.baseUrl}${endpoint}`;
    const config = {
      headers: {
        'X-API-Key': this.apiKey,
        'Content-Type': 'application/json',
        ...options.headers
      },
      ...options
    };

    for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
      try {
        const response = await fetch(url, config);

        if (response.ok) {
          return await response.json();
        }

        const error = await response.json().catch(() => ({}));

        // Don't retry on client errors (4xx)
        if (response.status >= 400 && response.status < 500) {
          throw new Error(`API Error (${response.status}): ${error.message || response.statusText}`);
        }

        // Retry on server errors (5xx) or network issues
        if (attempt === this.maxRetries) {
          throw new Error(`API Error after ${this.maxRetries} attempts: ${error.message || response.statusText}`);
        }

        console.warn(`Request failed (attempt ${attempt}/${this.maxRetries}), retrying in ${this.retryDelay}ms...`);
        await this.sleep(this.retryDelay * attempt); // Exponential backoff

      } catch (error) {
        if (attempt === this.maxRetries || error.name === 'TypeError') {
          throw error;
        }

        console.warn(`Network error (attempt ${attempt}/${this.maxRetries}), retrying...`);
        await this.sleep(this.retryDelay * attempt);
      }
    }
  }

  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  async search(query, options = {}) {
    return this.makeRequest('/search', {
      method: 'POST',
      body: JSON.stringify({
        query,
        filters: options.filters || { inStock: true },
        limit: options.limit || 10,
        sortBy: options.sortBy || 'quality_score'
      })
    });
  }
}

// Usage with error handling
const client = new AbbabaClientWithRetry('aba_your_api_key', {
  maxRetries: 3,
  retryDelay: 1000
});

try {
  const results = await client.search('laptop computers');
  console.log(`Found ${results.total} products`);
} catch (error) {
  console.error('Search failed:', error.message);

  if (error.message.includes('401')) {
    console.error('Invalid API key - please check your credentials');
  } else if (error.message.includes('403')) {
    console.error('Rate limit exceeded - please try again later');
  } else {
    console.error('Unexpected error - please contact support');
  }
}