require wisp from git "https://github.com/yourusername/wisp" @ "main"

import Wisp

def main : IO Unit := do
  -- Initialize curl (call once at startup)
  Wisp.FFI.globalInit

  let client := Wisp.HTTP.Client.new

  -- Simple GET request
  let task ← client.get "https://api.example.com/data"
  let result := task.get

  match result with
  | .ok response =>
    IO.println s!"Status: {response.status}"
    IO.println s!"Body: {response.bodyTextLossy}"
  | .error e =>
    IO.println s!"Error: {e}"

  -- Cleanup
  Wisp.FFI.globalCleanup
  Wisp.HTTP.Client.shutdown

-- Simple requests
let req := Wisp.Request.get "https://example.com"
let req := Wisp.Request.post "https://example.com"
let req := Wisp.Request.put "https://example.com"
let req := Wisp.Request.delete "https://example.com"
let req := Wisp.Request.head "https://example.com"
let req := Wisp.Request.patch "https://example.com"
let req := Wisp.Request.options "https://example.com"

-- JSON body
let req := Wisp.Request.post url |>.withJson """{"key": "value"}"""

-- Form-encoded body
let req := Wisp.Request.post url |>.withForm #[("field", "value")]

-- Plain text
let req := Wisp.Request.post url |>.withText "Hello, World!"

-- Raw bytes with content type
let req := Wisp.Request.post url |>.withBody bytes "application/octet-stream"

-- Multipart form (file uploads)
let parts : Array Wisp.MultipartPart := #[
  { name := "file", filename := some "data.txt", data := contents.toUTF8 }
]
let req := Wisp.Request.post url |>.withMultipart parts

let req := Wisp.Request.get url
  |>.withHeader "X-Custom-Header" "value"
  |>.withHeader "Accept" "application/json"

-- Basic auth
let req := Wisp.Request.get url |>.withBasicAuth "username" "password"

-- Bearer token
let req := Wisp.Request.get url |>.withBearerToken "your-token"

-- Digest auth
let req := Wisp.Request.get url |>.withDigestAuth "username" "password"

-- Request timeout (milliseconds)
let req := Wisp.Request.get url |>.withTimeout 5000

-- Connection timeout (milliseconds)
let req := Wisp.Request.get url |>.withConnectTimeout 3000

-- Disable redirect following
let req := Wisp.Request.get url |>.withFollowRedirects false

-- Limit redirects
let req := Wisp.Request.get url |>.withFollowRedirects true 5

-- Disable SSL verification (use with caution!)
let req := Wisp.Request.get url |>.withInsecure

-- Custom SSL options
let req := Wisp.Request.get url |>.withSsl {
  verifyPeer := true,
  verifyHost := true,
  caCertPath := some "/path/to/ca-bundle.crt"
}

let client := Wisp.HTTP.Client.new

-- Async execution (returns Task)
let task ← client.execute req
let result := task.get

-- Convenience methods
let task ← client.get "https://example.com"
let task ← client.postJson "https://example.com" """{"key": "value"}"""
let task ← client.postForm "https://example.com" #[("field", "value")]
let task ← client.putJson "https://example.com" """{"key": "value"}"""
let task ← client.delete "https://example.com"
let task ← client.head "https://example.com"

match result with
| .ok response =>
  -- Status code
  let status := response.status  -- UInt32

  -- Status helpers
  let _ := response.isSuccess     -- 2xx
  let _ := response.isRedirect    -- 3xx
  let _ := response.isClientError -- 4xx
  let _ := response.isServerError -- 5xx
  let _ := response.isError       -- 4xx or 5xx
  let _ := response.statusText    -- "OK", "Not Found", etc.

  -- Body access
  let text := response.bodyText      -- Option String (strict UTF-8)
  let text := response.bodyTextLossy -- String (replaces invalid bytes)
  let bytes := response.body         -- ByteArray
  let size := response.bodySize      -- Nat
  let empty := response.isEmpty      -- Bool

  -- Headers
  let ct := response.contentType           -- Option String
  let val := response.header "X-Custom"    -- Option String
  let headers := response.headers          -- Array (String × String)

  -- Metadata
  let time := response.totalTime      -- Float (seconds)
  let url := response.effectiveUrl    -- String (after redirects)

| .error e =>
  IO.println s!"Error: {e}"

inductive WispError where
  | curlError (msg : String)
  | httpError (status : UInt32) (msg : String)
  | timeoutError (msg : String)
  | connectionError (msg : String)
  | sslError (msg : String)
  | ioError (msg : String)

let client := Wisp.HTTP.Client.new
let req := Wisp.Request.get "https://example.com/large-file"

-- Execute with streaming
let task ← client.executeStreaming req
match task.get with
| .ok stream =>
  -- Status and headers available immediately
  IO.println s!"Status: {stream.status}"
  IO.println s!"Content-Type: {stream.contentType}"

  -- Process chunks as they arrive
  stream.forEachChunk fun chunk => do
    IO.print (String.fromUTF8! chunk)

  -- Or read all at once
  let body ← stream.readAllBody
  let text ← stream.readAllBodyText

| .error e =>
  IO.println s!"Error: {e}"

let client := Wisp.HTTP.Client.new

-- Make streaming request to SSE endpoint
let req := Wisp.Request.post "https://api.openai.com/v1/chat/completions"
  |>.withBearerToken apiKey
  |>.withJson """{"model": "gpt-4", "messages": [...], "stream": true}"""

let task ← client.executeStreaming req
match task.get with
| .ok streamResp =>
  -- Create SSE stream from response
  let sse ← Wisp.HTTP.SSE.Stream.fromStreaming streamResp

  -- Process events as they arrive
  sse.forEachEvent fun event => do
    IO.println s!"Event type: {event.event}"
    IO.println s!"Data: {event.data}"
    if let some id := event.id then
      IO.println s!"ID: {id}"

  -- Or read one event at a time
  let event? ← sse.recv
  match event? with
  | some event => IO.println event.data
  | none => IO.println "Stream ended"

  -- Track last event ID (for reconnection)
  let lastId ← sse.getLastEventId

| .error e =>
  IO.println s!"Error: {e}"

structure SSE.Event where
  event : String := "message"  -- Event type
  data : String                -- Event data (multiple lines joined)
  id : Option String           -- Event ID
  retry : Option Nat           -- Retry interval (ms)