dependencies: [
    .package(url: "https://github.com/roncuevas/ScrapingFish.git", from: "2.0.0")
]

import ScrapingFish

let client = ScrapingFishClient(apiKey: "your-api-key")

// Scrape a page
let response = try await client.scrape(url: "https://example.com")
print(response.body) // HTML string

let client = ScrapingFishClient(apiKey: "your-api-key")

// Simple scrape
let response = try await client.scrape(url: "https://example.com")
print(response.body)
print(response.metadata.statusCode)

// With configuration
let response = try await client.scrape(url: "https://example.com") { req in
    req.renderJS = true
    req.session = "my-session"
    req.totalTimeoutMs = 120_000
}

struct Product: Decodable, Sendable {
    let name: String
    let price: Double
}

let response = try await client.scrape(url: "https://shop.com/api", as: [Product].self) { req in
    req.extractRules = ExtractionRules([
        "items": ExtractionRule(selector: ".product", type: .all, output: .text)
    ])
}

for product in response.body {
    print(product.name)
}

let response = try await client.scrape(url: "https://spa.com") { req in
    req.renderJS = true
    req.renderJSTimeoutMs = 10_000
    req.browserType = "chrome"
}

let response = try await client.scrape(url: "https://spa.com") { req in
    req.renderJS = true
    req.jsScenario = JSScenario {
        JSStep.waitFor(selector: "#content", timeout: 5000)
        JSStep.click(selector: "#load-more")
        JSStep.wait(.milliseconds(2000))
    }
}

req.jsScenario = JSScenario(steps: [
    .waitFor(selector: "#content", timeout: 5000),
    .click(selector: "#load-more"),
    .wait(.milliseconds(2000)),
])

let needsLogin = true

req.jsScenario = JSScenario {
    if needsLogin {
        JSStep.input(selector: "#email", value: "[email protected]")
        JSStep.click(selector: "#login")
    }
    JSStep.waitFor(selector: "#dashboard")
}

let response = try await client.scrape(url: "https://example.com") { req in
    req.extractRules = ExtractionRules([
        "title": ExtractionRule(selector: "h1", output: .text),
        "links": ExtractionRule(selector: "a", type: .all, attribute: "href"),
        "table": ExtractionRule(selector: "table", output: .tableJSON),
    ])
}

let inner = ExtractionRules([
    "name": ExtractionRule(selector: ".name", output: .text),
    "price": ExtractionRule(selector: ".price", output: .text),
])

req.extractRules = ExtractionRules([
    "products": ExtractionRule(selector: ".product", type: .all, nested: inner)
])

let jsonData = Data(#"{"query": "search term"}"#.utf8)

let response = try await client.scrape(url: "https://api.com/search") { req in
    req.method = .post
    req.body = jsonData
    req.bodyContentType = "application/json"
}

// Default dimensions
let response = try await client.scrape(url: "https://example.com") { req in
    req.renderJS = true
    req.screenshot = .enabled
}

// Custom dimensions
let response = try await client.scrape(url: "https://example.com") { req in
    req.renderJS = true
    req.screenshot = .custom(width: 1920, height: 1080)
    req.screenshotBase64 = true
}

let response = try await client.scrape(url: "https://example.com") { req in
    req.cookies = [
        Cookie(name: "session", value: "abc123", secure: true),
        Cookie(name: "pref", value: "dark", domain: ".example.com"),
    ]
}

let response = try await client.scrape(url: "https://example.com") { req in
    req.headers = [
        "Authorization": "Bearer token",
        "Accept-Language": "en-US",
    ]
}

let response = try await client.scrape(url: "https://example.com")

response.metadata.statusCode          // HTTP status code
response.metadata.resolvedURL         // Final URL after redirects
response.metadata.originalStatusCode  // Original status from target site
response.metadata.cookies             // Cookies set by target site

let usage = try await client.usage()
print(usage.creditsUsed)
print(usage.creditsRemaining)
print(usage.creditsLimit)

var request = ScrapeRequest()
request.renderJS = true
request.session = "my-session"
request.totalTimeoutMs = 120_000

let response = try await client.scrape(url: "https://example.com", request: request)

do {
    let response = try await client.scrape(url: "https://example.com")
} catch let error as ScrapingFishError {
    switch error {
    case .httpError(let statusCode, let body):
        print("HTTP \(statusCode): \(body)")
    case .timeout:
        print("Request timed out")
    case .decodingError(let underlying):
        print("Failed to decode: \(underlying)")
    case .networkError(let underlying):
        print("Network error: \(underlying)")
    case .invalidURL(let url):
        print("Invalid URL: \(url)")
    case .unknown(let underlying):
        print("Unknown: \(underlying)")
    }
}

class MockHTTPClient: HTTPClientProtocol {
    var responseToReturn: HTTPResponse?

    func send(url: URL, method: String, headers: [String: String]?, body: Data?, timeoutInterval: TimeInterval) async throws -> HTTPResponse {
        return responseToReturn!
    }
}

let mock = MockHTTPClient()
mock.responseToReturn = HTTPResponse(data: Data("ok".utf8), statusCode: 200, headers: [:])
let client = ScrapingFishClient(apiKey: "test", httpClient: mock)