import Foundation
#if canImport(Darwin)
import Darwin
#elseif canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#endif

private let requestReadTimeoutMilliseconds: Int32 = 5000

struct CLILocalHTTPRequest {
    let method: String
    let target: String
    let host: String
    let path: String
    let queryItems: [String: String]

    static func parse(_ data: Data) -> Result<CLILocalHTTPRequest, CLILocalHTTPRequestParseError> {
        guard let raw = String(data: data, encoding: .utf8),
              let firstLine = raw.components(separatedBy: "\r\n").first
        else {
            return .failure(.invalidRequest)
        }

        let parts = firstLine.split(separator: " ")
        guard parts.count >= 3 else { return .failure(.invalidRequest) }

        let method = String(parts[0]).uppercased()
        let target = String(parts[1])
        guard target.hasPrefix("/") else { return .failure(.invalidRequest) }

        let headerResult = Self.parseHeaders(raw)
        let host: String
        switch headerResult {
        case let .success(headers):
            let hosts = headers.compactMap { name, value in
                name.lowercased() == "host" ? value : nil
            }
            guard let candidate = hosts.first else { return .failure(.missingHost) }
            guard hosts.count == 1 else { return .failure(.duplicateHost) }
            guard Self.isAllowedLoopbackHost(candidate) else { return .failure(.disallowedHost) }
            host = candidate
        case let .failure(error):
            return .failure(error)
        }

        let components = URLComponents(string: "http://localhost\(target)")
        let path = components?.path ?? target
        var queryItems: [String: String] = [:]
        for item in components?.queryItems ?? [] {
            if let value = item.value {
                queryItems[item.name] = value
            }
        }

        return .success(CLILocalHTTPRequest(
            method: method,
            target: target,
            host: host,
            path: path,
            queryItems: queryItems))
    }

    private static func parseHeaders(_ raw: String) -> Result<[(String, String)], CLILocalHTTPRequestParseError> {
        let lines = raw.components(separatedBy: "\r\n")
        var headers: [(String, String)] = []

        for line in lines.dropFirst() {
            if line.isEmpty { break }
            guard let separator = line.firstIndex(of: ":") else {
                return .failure(.invalidRequest)
            }
            let name = String(line[..<separator]).trimmingCharacters(in: .whitespacesAndNewlines)
            let value = String(line[line.index(after: separator)...]).trimmingCharacters(in: .whitespacesAndNewlines)
            guard !name.isEmpty else { return .failure(.invalidRequest) }
            headers.append((name, value))
        }

        return .success(headers)
    }

    private static func isAllowedLoopbackHost(_ host: String) -> Bool {
        let trimmed = host.trimmingCharacters(in: .whitespacesAndNewlines)
        guard !trimmed.isEmpty, !trimmed.contains(",") else { return false }

        let hostWithoutPort: String
        if trimmed.hasPrefix("[") {
            guard let closingBracket = trimmed.firstIndex(of: "]") else { return false }
            hostWithoutPort = String(trimmed[...closingBracket])
            let remainder = trimmed[trimmed.index(after: closingBracket)...]
            guard remainder.isEmpty || Self.isValidPortSuffix(String(remainder)) else { return false }
        } else {
            let segments = trimmed.split(separator: ":", omittingEmptySubsequences: false)
            switch segments.count {
            case 1:
                hostWithoutPort = String(segments[0])
            case 2:
                guard Self.isValidPort(String(segments[1])) else { return false }
                hostWithoutPort = String(segments[0])
            default:
                return false
            }
        }

        switch hostWithoutPort.lowercased() {
        case "127.0.0.1", "localhost", "localhost.", "[::1]":
            return true
        default:
            return false
        }
    }

    private static func isValidPortSuffix(_ raw: String) -> Bool {
        guard raw.hasPrefix(":") else { return false }
        return self.isValidPort(String(raw.dropFirst()))
    }

    private static func isValidPort(_ raw: String) -> Bool {
        guard let port = Int(raw), port > 0, port <= Int(UInt16.max) else { return false }
        return true
    }
}

enum CLILocalHTTPRequestParseError: Error, Equatable {
    case invalidRequest
    case missingHost
    case duplicateHost
    case disallowedHost
}

enum CLIHTTPStatus {
    case ok
    case badRequest
    case forbidden
    case notFound
    case methodNotAllowed
    case internalServerError
    case gatewayTimeout
    var code: Int {
        switch self {
        case .ok: 200
        case .badRequest: 400
        case .forbidden: 403
        case .notFound: 404
        case .methodNotAllowed: 405
        case .internalServerError: 500
        case .gatewayTimeout: 504
        }
    }

    var reason: String {
        switch self {
        case .ok: "OK"
        case .badRequest: "Bad Request"
        case .forbidden: "Forbidden"
        case .notFound: "Not Found"
        case .methodNotAllowed: "Method Not Allowed"
        case .internalServerError: "Internal Server Error"
        case .gatewayTimeout: "Gateway Timeout"
        }
    }
}

struct CLILocalHTTPResponse {
    let status: CLIHTTPStatus
    let body: Data
    let contentType: String
    let usageCacheKeys: [String?]?

    init(
        status: CLIHTTPStatus,
        body: Data,
        contentType: String = "application/json; charset=utf-8",
        usageCacheKeys: [String?]? = nil)
    {
        self.status = status
        self.body = body
        self.contentType = contentType
        self.usageCacheKeys = usageCacheKeys
    }

    var serialized: Data {
        var headers = "HTTP/1.1 \(self.status.code) \(self.status.reason)\r\n"
        headers += "Content-Type: \(self.contentType)\r\n"
        headers += "Content-Length: \(self.body.count)\r\n"
        headers += "Connection: close\r\n"
        headers += "\r\n"

        var data = Data(headers.utf8)
        data.append(self.body)
        return data
    }
}

final class CLILocalHTTPServer: @unchecked Sendable {
    typealias Handler = @Sendable (CLILocalHTTPRequest) async -> CLILocalHTTPResponse

    private let host: String
    private let port: UInt16
    private let handler: Handler
    private let stateLock = NSLock()
    private var listeningFD: Int32?
    private var stopRequested = false

    init(host: String, port: UInt16, handler: @escaping Handler) {
        self.host = host
        self.port = port
        self.handler = handler
    }

    func stop() {
        self.stateLock.lock()
        self.stopRequested = true
        self.stateLock.unlock()
    }

    func run(onListening: @Sendable () -> Void = {}) async throws {
        ignoreSIGPIPE()

        #if canImport(Darwin)
        let streamType = SOCK_STREAM
        #elseif canImport(Glibc)
        let streamType = Int32(SOCK_STREAM.rawValue)
        #elseif canImport(Musl)
        let streamType = Int32(SOCK_STREAM)
        #endif

        let serverFD = socket(AF_INET, streamType, 0)
        guard serverFD >= 0 else {
            throw POSIXError(POSIXErrorCode(rawValue: errno) ?? .EIO)
        }
        var ownsServerFD = true
        defer {
            if ownsServerFD {
                closeSocket(serverFD)
            }
        }

        var reuse: Int32 = 1
        setsockopt(
            serverFD,
            SOL_SOCKET,
            SO_REUSEADDR,
            &reuse,
            socklen_t(MemoryLayout<Int32>.size))

        var address = sockaddr_in()
        #if canImport(Darwin)
        address.sin_len = UInt8(MemoryLayout<sockaddr_in>.size)
        #endif
        address.sin_family = sa_family_t(AF_INET)
        address.sin_port = self.port.bigEndian
        guard inet_pton(AF_INET, self.host, &address.sin_addr) == 1 else {
            throw POSIXError(.EADDRNOTAVAIL)
        }

        let bound = withUnsafePointer(to: &address) { pointer in
            pointer.withMemoryRebound(to: sockaddr.self, capacity: 1) { socketAddress in
                bind(serverFD, socketAddress, socklen_t(MemoryLayout<sockaddr_in>.size))
            }
        }
        guard bound == 0 else {
            throw POSIXError(POSIXErrorCode(rawValue: errno) ?? .EIO)
        }

        guard listen(serverFD, 16) == 0 else {
            throw POSIXError(POSIXErrorCode(rawValue: errno) ?? .EIO)
        }
        guard self.installListeningFD(serverFD) else {
            return
        }
        ownsServerFD = false
        defer {
            if self.releaseListeningFD(serverFD) {
                closeSocket(serverFD)
            }
        }
        onListening()

        while !self.isStopRequested {
            guard waitForReadable(serverFD, timeoutMilliseconds: 250) else {
                continue
            }
            var clientAddress = sockaddr()
            var clientLength = socklen_t(MemoryLayout<sockaddr>.size)
            let clientFD = accept(serverFD, &clientAddress, &clientLength)
            guard clientFD >= 0 else {
                if self.isStopRequested { return }
                if errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK || errno == ECONNABORTED {
                    continue
                }
                throw POSIXError(POSIXErrorCode(rawValue: errno) ?? .EIO)
            }
            let handler = self.handler
            Task {
                defer { closeSocket(clientFD) }
                await handleClient(clientFD, handler: handler)
            }
        }
    }

    private var isStopRequested: Bool {
        self.stateLock.lock()
        let value = self.stopRequested
        self.stateLock.unlock()
        return value
    }

    private func installListeningFD(_ fd: Int32) -> Bool {
        self.stateLock.lock()
        defer { self.stateLock.unlock() }
        guard !self.stopRequested else { return false }
        self.listeningFD = fd
        return true
    }

    private func releaseListeningFD(_ fd: Int32) -> Bool {
        self.stateLock.lock()
        defer { self.stateLock.unlock() }
        guard self.listeningFD == fd else { return false }
        self.listeningFD = nil
        return true
    }
}

private func handleClient(
    _ clientFD: Int32,
    handler: @Sendable (CLILocalHTTPRequest) async -> CLILocalHTTPResponse) async
{
    let request: CLILocalHTTPRequest
    switch readRequest(clientFD) {
    case let .success(parsedRequest):
        request = parsedRequest
    case .failure(.disallowedHost):
        sendResponse(
            CLILocalHTTPResponse(
                status: .forbidden,
                body: Data(#"{"error":"forbidden host"}"#.utf8)),
            to: clientFD)
        return
    case .failure:
        sendResponse(
            CLILocalHTTPResponse(
                status: .badRequest,
                body: Data(#"{"error":"invalid request"}"#.utf8)),
            to: clientFD)
        return
    }

    let response = await handler(request)
    sendResponse(response, to: clientFD)
}

private func readRequest(_ fd: Int32) -> Result<CLILocalHTTPRequest, CLILocalHTTPRequestParseError> {
    var data = Data()
    var buffer = [UInt8](repeating: 0, count: 4096)
    let bufferSize = buffer.count
    var sawHeaderEnd = false

    while data.count < 16384 {
        guard waitForReadable(fd, timeoutMilliseconds: requestReadTimeoutMilliseconds) else {
            return .failure(.invalidRequest)
        }
        let count = buffer.withUnsafeMutableBytes { rawBuffer in
            recv(fd, rawBuffer.baseAddress, bufferSize, 0)
        }
        guard count > 0 else { break }
        data.append(buffer, count: count)
        if data.range(of: Data("\r\n\r\n".utf8)) != nil {
            sawHeaderEnd = true
            break
        }
    }

    guard sawHeaderEnd else { return .failure(.invalidRequest) }
    return CLILocalHTTPRequest.parse(data)
}

private func sendResponse(_ response: CLILocalHTTPResponse, to fd: Int32) {
    let data = response.serialized
    data.withUnsafeBytes { rawBuffer in
        guard let base = rawBuffer.baseAddress else { return }
        var sent = 0
        while sent < data.count {
            let count = send(fd, base.advanced(by: sent), data.count - sent, sendNoSignalFlags())
            guard count > 0 else { break }
            sent += count
        }
    }
}

private func waitForReadable(_ fd: Int32, timeoutMilliseconds: Int32) -> Bool {
    var pollFD = pollfd(fd: fd, events: Int16(POLLIN), revents: 0)
    while true {
        let result = poll(&pollFD, 1, timeoutMilliseconds)
        if result > 0 {
            return (pollFD.revents & Int16(POLLIN)) != 0
        }
        if result == -1, errno == EINTR {
            continue
        }
        return false
    }
}

private func sendNoSignalFlags() -> Int32 {
    #if canImport(Darwin)
    0
    #else
    Int32(MSG_NOSIGNAL)
    #endif
}

private func ignoreSIGPIPE() {
    #if canImport(Darwin)
    _ = Darwin.signal(SIGPIPE, SIG_IGN)
    #elseif canImport(Glibc)
    _ = Glibc.signal(SIGPIPE, SIG_IGN)
    #elseif canImport(Musl)
    _ = Musl.signal(SIGPIPE, SIG_IGN)
    #endif
}

private func closeSocket(_ fd: Int32) {
    #if canImport(Darwin)
    Darwin.close(fd)
    #elseif canImport(Glibc)
    Glibc.close(fd)
    #elseif canImport(Musl)
    Musl.close(fd)
    #endif
}