import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif

public protocol ProviderHTTPTransport: Sendable {
    func data(for request: URLRequest) async throws -> (Data, URLResponse)
}

#if !os(Linux)
extension URLSession: ProviderHTTPTransport {}
#endif

extension URLSession {
    public func response(for request: URLRequest) async throws -> ProviderHTTPResponse {
        let (data, response) = try await self.data(for: request)
        guard let httpResponse = response as? HTTPURLResponse else {
            throw URLError(.badServerResponse)
        }
        return ProviderHTTPResponse(data: data, response: httpResponse)
    }
}

public struct ProviderHTTPResponse: Sendable {
    public let data: Data
    public let response: HTTPURLResponse

    public init(data: Data, response: HTTPURLResponse) {
        self.data = data
        self.response = response
    }

    public var statusCode: Int {
        self.response.statusCode
    }
}

public struct ProviderHTTPRetryPolicy: Sendable {
    public let maxRetries: Int
    public let retryableStatusCodes: Set<Int>
    public let retryableURLErrorCodes: Set<URLError.Code>
    public let retryableMethods: Set<String>
    public let baseDelaySeconds: TimeInterval
    public let maxDelaySeconds: TimeInterval

    public init(
        maxRetries: Int,
        retryableStatusCodes: Set<Int> = [408, 429, 500, 502, 503, 504],
        retryableURLErrorCodes: Set<URLError.Code> = [
            .timedOut,
            .networkConnectionLost,
            .cannotConnectToHost,
            .cannotFindHost,
            .dnsLookupFailed,
        ],
        retryableMethods: Set<String> = ["GET", "HEAD", "OPTIONS"],
        baseDelaySeconds: TimeInterval = 1,
        maxDelaySeconds: TimeInterval = 10)
    {
        self.maxRetries = max(0, maxRetries)
        self.retryableStatusCodes = retryableStatusCodes
        self.retryableURLErrorCodes = retryableURLErrorCodes
        self.retryableMethods = retryableMethods
        self.baseDelaySeconds = max(0, baseDelaySeconds)
        self.maxDelaySeconds = max(0, maxDelaySeconds)
    }

    public static let disabled = ProviderHTTPRetryPolicy(
        maxRetries: 0,
        retryableStatusCodes: [],
        retryableURLErrorCodes: [],
        baseDelaySeconds: 0,
        maxDelaySeconds: 0)

    public static let transientIdempotent = ProviderHTTPRetryPolicy(maxRetries: 1)

    func shouldRetry(request: URLRequest, attempt: Int, statusCode: Int) -> Bool {
        self.canRetry(request: request, attempt: attempt)
            && self.retryableStatusCodes.contains(statusCode)
    }

    func shouldRetry(request: URLRequest, attempt: Int, error: Error) -> Bool {
        guard self.canRetry(request: request, attempt: attempt) else { return false }
        guard let urlError = error as? URLError else { return false }
        return self.retryableURLErrorCodes.contains(urlError.code)
    }

    func delaySeconds(attempt: Int, response: HTTPURLResponse?) -> TimeInterval {
        if let retryAfter = response?.value(forHTTPHeaderField: "Retry-After"),
           let seconds = TimeInterval(retryAfter.trimmingCharacters(in: .whitespacesAndNewlines)),
           seconds >= 0
        {
            return min(seconds, self.maxDelaySeconds)
        }

        guard self.baseDelaySeconds > 0 else { return 0 }
        let multiplier = pow(2, Double(max(0, attempt)))
        return min(self.baseDelaySeconds * multiplier, self.maxDelaySeconds)
    }

    private func canRetry(request: URLRequest, attempt: Int) -> Bool {
        guard attempt < self.maxRetries else { return false }
        let method = request.httpMethod?.uppercased() ?? "GET"
        return self.retryableMethods.contains(method)
    }
}

public struct ProviderHTTPTransportHandler: ProviderHTTPTransport {
    private let handler: @Sendable (URLRequest) async throws -> (Data, URLResponse)

    public init(_ handler: @escaping @Sendable (URLRequest) async throws -> (Data, URLResponse)) {
        self.handler = handler
    }

    public func data(for request: URLRequest) async throws -> (Data, URLResponse) {
        try await self.handler(request)
    }
}

extension ProviderHTTPTransport {
    public func response(for request: URLRequest) async throws -> ProviderHTTPResponse {
        try await self.response(for: request, retryPolicy: .disabled)
    }

    public func response(
        for request: URLRequest,
        retryPolicy: ProviderHTTPRetryPolicy) async throws -> ProviderHTTPResponse
    {
        var attempt = 0

        while true {
            do {
                let (data, response) = try await self.data(for: request)
                guard let httpResponse = response as? HTTPURLResponse else {
                    throw URLError(.badServerResponse)
                }
                let providerResponse = ProviderHTTPResponse(data: data, response: httpResponse)
                guard retryPolicy.shouldRetry(
                    request: request,
                    attempt: attempt,
                    statusCode: providerResponse.statusCode)
                else {
                    return providerResponse
                }
                try await Self.sleepBeforeRetry(policy: retryPolicy, attempt: attempt, response: httpResponse)
                attempt += 1
            } catch {
                guard retryPolicy.shouldRetry(request: request, attempt: attempt, error: error) else {
                    throw error
                }
                try await Self.sleepBeforeRetry(policy: retryPolicy, attempt: attempt, response: nil)
                attempt += 1
            }
        }
    }

    private static func sleepBeforeRetry(
        policy: ProviderHTTPRetryPolicy,
        attempt: Int,
        response: HTTPURLResponse?) async throws
    {
        let delay = policy.delaySeconds(attempt: attempt, response: response)
        guard delay > 0 else { return }
        try await Task.sleep(nanoseconds: UInt64(delay * 1_000_000_000))
    }
}

public final class ProviderHTTPClient: ProviderHTTPTransport, @unchecked Sendable {
    public static let shared = ProviderHTTPClient(session: ProviderHTTPClient.sharedSession())

    private let session: URLSession

    public init(session: URLSession? = nil) {
        self.session = session ?? Self.redirectGuardedSession()
    }

    static func defaultConfiguration() -> URLSessionConfiguration {
        let configuration = URLSessionConfiguration.default
        configuration.timeoutIntervalForRequest = 30
        configuration.timeoutIntervalForResource = 90
        #if !os(Linux)
        configuration.waitsForConnectivity = false
        #endif
        return configuration
    }

    private static func sharedSession() -> URLSession {
        if self.isRunningTests {
            // XCTest URLProtocol.registerClass stubs only intercept URLSession.shared on macOS.
            return .shared
        }
        return self.redirectGuardedSession()
    }

    static func redirectGuardedSession(
        configuration: URLSessionConfiguration = ProviderHTTPClient.defaultConfiguration()) -> URLSession
    {
        URLSession(
            configuration: configuration,
            delegate: ProviderHTTPRedirectGuardDelegate(),
            delegateQueue: nil)
    }

    private static var isRunningTests: Bool {
        let environment = ProcessInfo.processInfo.environment
        if environment["XCTestConfigurationFilePath"] != nil || environment["XCTestBundlePath"] != nil {
            return true
        }
        if ProcessInfo.processInfo.processName.lowercased().contains("xctest") {
            return true
        }
        return CommandLine.arguments.contains { $0.lowercased().contains(".xctest") }
    }

    public func data(for request: URLRequest) async throws -> (Data, URLResponse) {
        try await self.session.data(for: request)
    }
}

final class ProviderHTTPRedirectGuardDelegate: NSObject, URLSessionTaskDelegate, @unchecked Sendable {
    func urlSession(
        _: URLSession,
        task: URLSessionTask,
        willPerformHTTPRedirection _: HTTPURLResponse,
        newRequest request: URLRequest,
        completionHandler: @escaping @Sendable (URLRequest?) -> Void)
    {
        completionHandler(Self.guardedRedirectRequest(originalURL: task.originalRequest?.url, redirectRequest: request))
    }

    static func guardedRedirectRequest(originalURL: URL?, redirectRequest request: URLRequest) -> URLRequest? {
        guard let originalURL, let redirectedURL = request.url else { return nil }
        guard originalURL.scheme?.caseInsensitiveCompare("https") == .orderedSame else { return nil }
        guard redirectedURL.scheme?.caseInsensitiveCompare("https") == .orderedSame else { return nil }
        guard self.isSameOrigin(originalURL, redirectedURL) else { return nil }
        return request
    }

    private static func isSameOrigin(_ lhs: URL, _ rhs: URL) -> Bool {
        lhs.scheme?.lowercased() == rhs.scheme?.lowercased()
            && lhs.host?.lowercased() == rhs.host?.lowercased()
            && self.normalizedPort(lhs) == self.normalizedPort(rhs)
    }

    private static func normalizedPort(_ url: URL) -> Int? {
        if let port = url.port { return port }
        switch url.scheme?.lowercased() {
        case "http": return 80
        case "https": return 443
        default: return nil
        }
    }
}