SwiftAuthNet

dependencies: [
    .package(url: "https://github.com/yvente/SwiftAuthNet.git", from: "0.1.0")
]

import SwiftAuthNet

final class KeychainTokenProvider: TokenProvider {
    func getAccessToken() async -> String? {
        return Keychain.get("access_token")
    }
    
    func getRefreshToken() async -> String? {
        return Keychain.get("refresh_token")
    }
    
    func clearTokens() async {
        Keychain.delete("access_token")
        Keychain.delete("refresh_token")
    }
}

final class AuthRefreshService: TokenRefreshService {
    private let tokenProvider: TokenProvider
    
    init(tokenProvider: TokenProvider) {
        self.tokenProvider = tokenProvider
    }
    
    func refreshToken() async throws {
        guard let refreshToken = await tokenProvider.getRefreshToken() else {
            throw AuthError.noRefreshToken
        }
        
        var request = URLRequest(url: URL(string: "https://api.example.com/auth/refresh")!)
        request.httpMethod = "POST"
        request.setValue("Bearer \(refreshToken)", forHTTPHeaderField: "Authorization")
        
        // Use plain URLSession to avoid interceptor loop
        let (data, response) = try await URLSession.shared.data(for: request)
        
        guard let httpResponse = response as? HTTPURLResponse,
              httpResponse.statusCode == 200 else {
            throw AuthError.refreshFailed
        }
        
        let tokens = try JSONDecoder().decode(TokenResponse.self, from: data)
        Keychain.set(tokens.accessToken, for: "access_token")
        Keychain.set(tokens.refreshToken, for: "refresh_token")
    }
}

// Create components
let tokenProvider = KeychainTokenProvider()
let refreshService = AuthRefreshService(tokenProvider: tokenProvider)
let refresher = TokenRefresher(refreshService: refreshService)

// Create interceptor
let authInterceptor = AuthInterceptor(
    tokenProvider: tokenProvider,
    tokenRefresher: refresher
)

// Configure globally
URLSession.shared.configureInterceptors(
    NetworkInterceptorConfig(interceptors: [authInterceptor])
)

let request = URLRequest(url: URL(string: "https://api.example.com/user/profile")!)
let (data, response) = try await URLSession.shared.authenticatedRequest(request)

let interceptor = AuthInterceptor(
    tokenProvider: tokenProvider,
    tokenRefresher: refresher,
    shouldRefreshOnResponse: { response in
        // Refresh on 401 or 403
        return response.statusCode == 401 || response.statusCode == 403
    },
    shouldClearTokensOnRefreshFailure: { error in
        // Clear tokens if refresh returns 401
        if case NetworkError.unauthorized = error {
            return true
        }
        return false
    }
)

let customSession = URLSession(configuration: .default)
customSession.configureInterceptors(
    NetworkInterceptorConfig(
        interceptors: [authInterceptor],
        maxRetryCount: 2
    )
)

struct LoggingInterceptor: RequestInterceptor {
    func adapt(_ request: URLRequest) async throws -> URLRequest {
        print("📤 Request: \(request.url?.absoluteString ?? "")")
        return request
    }
}

URLSession.shared.configureInterceptors(
    NetworkInterceptorConfig(interceptors: [
        LoggingInterceptor(),
        authInterceptor
    ])
)