dependencies: [
    .package(url: "https://github.com/SeeYouSwift/SugarNetwork", from: "1.0.0")
],
targets: [
    .target(
        name: "YourTarget",
        dependencies: ["SugarNetwork"]
    ),
    // For test targets — add the mock library:
    .testTarget(
        name: "YourTargetTests",
        dependencies: [
            "YourTarget",
            .product(name: "SugarNetworkMocks", package: "SugarNetwork")
        ]
    )
]

import SugarNetwork

// 1. Create a client
let network = SugarNetwork(
    requestInterceptors: [
        BearerTokenInterceptor { await tokenStore.accessToken },
        LoggingInterceptor(verbose: true)
    ],
    retryPolicy: .default   // 3 retries, exponential backoff starting at 0.5s
)

// 2. Define an endpoint
let endpoint = Endpoint(baseURL: "https://api.example.com", path: "/users")

// 3. Decode directly into your model
let users: [User] = try await network.request(endpoint)

// 4. Or get the full HTTP response
let response: NetworkResponse<[User]> = try await network.response(endpoint)
print(response.statusCode)                         // 200
print(response.header("X-Request-Id") ?? "none")  // request-id header

// Simple GET
let list = Endpoint(baseURL: "https://api.example.com", path: "/dogs")

// POST with JSON body
let create = try Endpoint.json(
    baseURL: "https://api.example.com",
    path: "/dogs",
    method: .post,
    body: NewDog(name: "Rex", breed: "Husky")
)

// POST with form body
let login = Endpoint.form(
    baseURL: "https://api.example.com",
    path: "/auth/login",
    fields: ["username": "user@example.com", "password": "secret"]
)

let endpoint = try RequestBuilder(baseURL: "https://api.example.com")
    .path("/search")
    .method(.get)
    .query("q", value: "labrador")
    .query("page", value: "2")
    .header("Accept-Language", value: "en")
    .bearer(accessToken)
    .build()

let response: NetworkResponse<Dog> = try await network.response(endpoint)

print(response.value)                   // Dog model
print(response.statusCode)              // 200
print(response.header("ETag") ?? "-")  // response header
print(response.data)                    // raw bytes

let raw: RawResponse = try await network.raw(endpoint)
print(raw.statusCode)
// process raw.data yourself

// Raw data
let pngData: Data = ...
let result: UploadResponse = try await network.upload(
    data: pngData,
    to: Endpoint(baseURL: "https://api.example.com", path: "/photos", method: .post),
    mimeType: "image/png"
)

// Multipart form-data
let result: UploadResponse = try await network.uploadMultipart(
    parts: [
        .jpeg(photoData, name: "avatar"),
        .text("Rex", name: "name")
    ],
    to: Endpoint(baseURL: "https://api.example.com", path: "/profile", method: .post)
)

let fileURL: URL = try await network.download(
    Endpoint(baseURL: "https://files.example.com", path: "/report.pdf")
)
// fileURL is a temporary local path — copy it before it is cleaned up

// Attach a bearer token from an async provider
BearerTokenInterceptor(tokenProvider: { await tokenStore.accessToken })

// Inject static headers on every request
HeadersInterceptor([
    "X-App-Version": Bundle.main.appVersion,
    "X-Platform": "iOS"
])

// Log requests and responses to the console
LoggingInterceptor(verbose: true)  // verbose = include body

struct LocaleInterceptor: RequestInterceptor {
    func adapt(_ request: URLRequest) async throws -> URLRequest {
        var r = request
        r.setValue(Locale.current.identifier, forHTTPHeaderField: "Accept-Language")
        return r
    }
}

struct TokenRefreshInterceptor: ResponseInterceptor {
    func process(response: HTTPURLResponse, data: Data, for request: URLRequest) async throws {
        if response.statusCode == 401 {
            await tokenStore.refresh()
        }
    }
}

let network = SugarNetwork(
    requestInterceptors: [
        HeadersInterceptor(["X-Platform": "iOS"]),
        BearerTokenInterceptor { await tokenStore.token },
        LoggingInterceptor()
    ],
    responseInterceptors: [
        TokenRefreshInterceptor()
    ]
)

// No retries (default)
RetryPolicy.none

// 3 retries with exponential backoff starting at 0.5s, max 30s (library default)
RetryPolicy.default

// Custom: 5 retries, constant 1-second delay, only for server errors
RetryPolicy(
    maxAttempts: 5,
    backoff: .constant(1.0),
    retryableErrors: [.serverError]
)

// Exponential: 0.5s, 1s, 2s, 4s — capped at 10s
RetryPolicy(
    maxAttempts: 4,
    backoff: .exponential(base: 0.5, max: 10)
)

do {
    let user: User = try await network.request(endpoint)
} catch NetworkError.unauthorized {
    // Redirect to login
} catch NetworkError.notFound {
    // Show 404 message
} catch NetworkError.rateLimited(let retryAfter) {
    // Wait retryAfter seconds
} catch NetworkError.noConnection {
    // Show offline banner
} catch NetworkError.decodingFailed(let description) {
    // Log decoding mismatch
} catch {
    // Unexpected error
}

import SugarNetworkMocks

let mock = MockNetworkService()
mock.register(Dog(name: "Rex", breed: "Husky"), for: "/dogs")

let repo = DogRepository(network: mock)
let dogs = try await repo.fetchDogs()  // hits the mock

// Assert which endpoints were called
print(mock.recordedEndpoints.map(\.path))

// Simulate errors
mock.forcedError = .timeout

// Clean up between tests
mock.reset()

import SugarNetworkMocks

// Successful JSON response
let session = MockNetworkSession.success(data: Data(json.utf8))

// Successful response from an Encodable model
let session = try MockNetworkSession.success(model: myModel, statusCode: 201)

// Simulate URLError
let session = MockNetworkSession.urlError(.notConnectedToInternet)

// Check what was sent
let sut = SugarNetwork(session: session, requestInterceptors: [myInterceptor])
let _: MyModel = try await sut.request(endpoint)
let sentHeader = session.receivedRequests.first?.value(forHTTPHeaderField: "Authorization")