import PrismNetwork

enum UserEndpoint: PrismNetworkEndpoint {
    case list
    case get(id: String)
    case create(name: String, email: String)

    var host: String { "api.example.com" }

    var path: String {
        switch self {
        case .list:            return "/v1/users"
        case .get(let id):     return "/v1/users/\(id)"
        case .create:          return "/v1/users"
        }
    }

    var method: PrismNetworkMethod {
        switch self {
        case .list, .get: return .get
        case .create:     return .post
        }
    }

    var headers: [String: String] {
        ["Content-Type": PrismNetworkHeaderType.json.rawValue]
    }

    var body: (any Encodable)? {
        switch self {
        case .create(let name, let email):
            return ["name": name, "email": email]
        default:
            return nil
        }
    }
}

import PrismNetwork

struct User: PrismEntity, Sendable {
    let id: String
    let name: String
    let email: String
}

struct ListUsersRequest: PrismNetworkRequest {
    typealias Response = [User]
    let endpoint: UserEndpoint = .list
}

struct GetUserRequest: PrismNetworkRequest {
    typealias Response = User
    let endpoint: UserEndpoint

    init(id: String) {
        self.endpoint = .get(id: id)
    }
}

let client = PrismNetworkAdapter()

// List all users
let users = try await client.request(on: ListUsersRequest())

// Get a single user
let user = try await client.request(on: GetUserRequest(id: "42"))
print(user.name) // "Alice"

let formatter = DateFormatter()
formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSZ"

let user = try await client.request(
    on: GetUserRequest(id: "42"),
    with: formatter
)

let redirectURL = try await client.redirect(
    from: GetUserRequest(id: "42")
)
print(redirectURL) // https://api.example.com/v2/users/42

let config = URLSessionConfiguration.default
config.timeoutIntervalForRequest = 30

let cache = URLCache(
    memoryCapacity: 10 * 1024 * 1024,  // 10 MB
    diskCapacity: 50 * 1024 * 1024      // 50 MB
)

let client = PrismNetworkAdapter(
    configuration: config,
    cache: cache
)

do {
    let user = try await client.request(on: GetUserRequest(id: "42"))
} catch let error as PrismNetworkError {
    switch error {
    case .invalidURL:      print("Bad URL")
    case .noConnectivity:  print("No network")
    case .unauthorized:    print("Auth required")
    case .forbidden:       print("Access denied")
    case .badRequest:      print("Invalid request")
    case .serverError:     print("Server error")
    case .invalidResponse: print("Unexpected response")
    case .noCache:         print("No cached data")
    }
}

actor MockNetworkClient: PrismNetworkClient {
    var mockResponse: Any?

    func request<Request: PrismNetworkRequest>(
        on request: Request,
        with formatter: DateFormatter?
    ) async throws -> Request.Response {
        guard let response = mockResponse as? Request.Response else {
            throw PrismNetworkError.invalidResponse
        }
        return response
    }

    func redirect<Request: PrismNetworkRequest>(
        from request: Request
    ) async throws -> URL {
        throw PrismNetworkError.invalidResponse
    }
}