// License: see LICENSE file at root directory of `master` branch

//! # Header

use {
    alloc::{
        collections::BTreeMap,
        string::{String, ToString},
    },
    core::{
        fmt::{self, Display, Formatter},
        str::FromStr,
    },
    crate::Error,
};

/// # Header map
pub type HeaderMap = BTreeMap<Header, String>;

/// # Line break
pub const LINE_BREAK: &str = concat!('\r', '\n');

// Authentication
const HEADER_WWW_AUTHENTICATE: &str = "WWW-Authenticate";
const HEADER_AUTHORIZATION: &str = "Authorization";
const HEADER_PROXY_AUTHENTICATE: &str = "Proxy-Authenticate";
const HEADER_PROXY_AUTHORIZATION: &str = "Proxy-Authorization";

// Caching
const HEADER_AGE: &str = "Age";
const HEADER_CACHE_CONTROL: &str = "Cache-Control";
const HEADER_CLEAR_SITE_DATA: &str = "Clear-Site-Data";
const HEADER_EXPIRES: &str = "Expires";
const HEADER_PRAGMA: &str = "Pragma";
const HEADER_WARNING: &str = "Warning";

// Conditionals
const HEADER_LAST_MODIFIED: &str = "Last-Modified";
const HEADER_ETAG: &str = "ETag";
const HEADER_IF_MATCH: &str = "If-Match";
const HEADER_IF_NONE_MATCH: &str = "If-None-Match";
const HEADER_IF_MODIFIED_SINCE: &str = "If-Modified-Since";
const HEADER_IF_UNMODIFIED_SINCE: &str = "If-Unmodified-Since";
const HEADER_VARY: &str = "Vary";

// Connection management
const HEADER_CONNECTION: &str = "Connection";
const HEADER_KEEP_ALIVE: &str = "Keep-Alive";

// Content negotiation
const HEADER_ACCEPT: &str = "Accept";
const HEADER_ACCEPT_CHARSET: &str = "Accept-Charset";
const HEADER_ACCEPT_ENCODING: &str = "Accept-Encoding";
const HEADER_ACCEPT_LANGUAGE: &str = "Accept-Language";

// Controls
const HEADER_EXPECT: &str = "Expect";
const HEADER_MAX_FORWARDS: &str = "Max-Forwards";

// Cookies
const HEADER_COOKIE: &str = "Cookie";
const HEADER_SET_COOKIE: &str = "Set-Cookie";

// Cross-Origin Resource Sharing (CORS)
const HEADER_ACCESS_CONTROL_ALLOW_ORIGIN: &str = "Access-Control-Allow-Origin";
const HEADER_ACCESS_CONTROL_ALLOW_CREDENTIALS: &str = "Access-Control-Allow-Credentials";
const HEADER_ACCESS_CONTROL_ALLOW_HEADERS: &str = "Access-Control-Allow-Headers";
const HEADER_ACCESS_CONTROL_ALLOW_METHODS: &str = "Access-Control-Allow-Methods";
const HEADER_ACCESS_CONTROL_EXPOSE_HEADERS: &str = "Access-Control-Expose-Headers";
const HEADER_ACCESS_CONTROL_MAX_AGE: &str = "Access-Control-Max-Age";
const HEADER_ACCESS_CONTROL_REQUEST_HEADERS: &str = "Access-Control-Request-Headers";
const HEADER_ACCESS_CONTROL_REQUEST_METHOD: &str = "Access-Control-Request-Method";
const HEADER_ORIGIN: &str = "Origin";
const HEADER_SERVICE_WORKER_ALLOWED: &str = "Service-Worker-Allowed";
const HEADER_TIMING_ALLOW_ORIGIN: &str = "Timing-Allow-Origin";
const HEADER_X_PERMITTED_CROSS_DOMAIN_POLICIES: &str = "X-Permitted-Cross-Domain-Policies";

// Do Not Track
const HEADER_DNT: &str = "DNT";
const HEADER_TK: &str = "Tk";

// Downloads
const HEADER_CONTENT_DISPOSITION: &str = "Content-Disposition";

// Message body information
const HEADER_CONTENT_LENGTH: &str = "Content-Length";
const HEADER_CONTENT_TYPE: &str = "Content-Type";
const HEADER_CONTENT_ENCODING: &str = "Content-Encoding";
const HEADER_CONTENT_LANGUAGE: &str = "Content-Language";
const HEADER_CONTENT_LOCATION: &str = "Content-Location";

// Proxies
const HEADER_FORWARDED: &str = "Forwarded";
const HEADER_VIA: &str = "Via";

// Redirects
const HEADER_LOCATION: &str = "Location";

// Request context
const HEADER_FROM: &str = "From";
const HEADER_HOST: &str = "Host";
const HEADER_REFERER: &str = "Referer";
const HEADER_REFERRER_POLICY: &str = "Referrer-Policy";
const HEADER_USER_AGENT: &str = "User-Agent";

// Response context
const HEADER_ALLOW: &str = "Allow";
const HEADER_SERVER: &str = "Server";

// Range requests
const HEADER_ACCEPT_RANGES: &str = "Accept-Ranges";
const HEADER_RANGE: &str = "Range";
const HEADER_IF_RANGE: &str = "If-Range";
const HEADER_CONTENT_RANGE: &str = "Content-Range";

// Security
const HEADER_CROSS_ORIGIN_OPENER_POLICY: &str = "Cross-Origin-Opener-Policy";
const HEADER_CROSS_ORIGIN_RESOURCE_POLICY: &str = "Cross-Origin-Resource-Policy";
const HEADER_CONTENT_SECURITY_POLICY: &str = "Content-Security-Policy";
const HEADER_CONTENT_SECURITY_POLICY_REPORT_ONLY: &str = "Content-Security-Policy-Report-Only";
const HEADER_EXPECT_CT: &str = "Expect-CT";
const HEADER_FEATURE_POLICY: &str = "Feature-Policy";
const HEADER_PUBLIC_KEY_PINS: &str = "Public-Key-Pins";
const HEADER_PUBLIC_KEY_PINS_REPORT_ONLY: &str = "Public-Key-Pins-Report-Only";
const HEADER_STRICT_TRANSPORT_SECURITY: &str = "Strict-Transport-Security";
const HEADER_UPGRADE_INSECURE_REQUESTS: &str = "Upgrade-Insecure-Requests";
const HEADER_X_CONTENT_TYPE_OPTIONS: &str = "X-Content-Type-Options";
const HEADER_X_DOWNLOAD_OPTIONS: &str = "X-Download-Options";
const HEADER_X_FRAME_OPTIONS: &str = "X-Frame-Options";
const HEADER_X_POWERED_BY: &str = "X-Powered-By";
const HEADER_X_XSS_PROTECTION: &str = "X-XSS-Protection";

// Server-sent events
const HEADER_LAST_EVENT_ID: &str = "Last-Event-ID";
const HEADER_PING_FROM: &str = "Ping-From";
const HEADER_PING_TO: &str = "Ping-To";
const HEADER_REPORT_TO: &str = "Report-To";

// Transfer coding
const HEADER_TRANSFER_ENCODING: &str = "Transfer-Encoding";
const HEADER_TE: &str = "TE";
const HEADER_TRAILER: &str = "Trailer";

// WebSockets
const HEADER_SEC_WEBSOCKET_KEY: &str = "Sec-WebSocket-Key";
const HEADER_SEC_WEBSOCKET_EXTENSIONS: &str = "Sec-WebSocket-Extensions";
const HEADER_SEC_WEBSOCKET_ACCEPT: &str = "Sec-WebSocket-Accept";
const HEADER_SEC_WEBSOCKET_PROTOCOL: &str = "Sec-WebSocket-Protocol";
const HEADER_SEC_WEBSOCKET_VERSION: &str = "Sec-WebSocket-Version";

// Other
const HEADER_ALT_SVC: &str = "Alt-Svc";
const HEADER_DATE: &str = "Date";
const HEADER_LARGE_ALLOCATION: &str = "Large-Allocation";
const HEADER_LINK: &str = "Link";
const HEADER_RETRY_AFTER: &str = "Retry-After";
const HEADER_SERVER_TIMING: &str = "Server-Timing";
const HEADER_SOURCEMAP: &str = "SourceMap";
const HEADER_UPGRADE: &str = "Upgrade";
const HEADER_X_DNS_PREFETCH_CONTROL: &str = "X-DNS-Prefetch-Control";
const HEADER_X_REQUESTED_WITH: &str = "X-Requested-With";

/// # Header
///
/// ## References
///
/// - <https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers>
#[derive(Debug, Eq, PartialEq, Hash, Ord, PartialOrd, Clone)]
pub enum Header {

    /// # WWW-Authenticate,
    WWWAuthenticate,

    /// # Authorization,
    Authorization,

    /// # Proxy-Authenticate,
    ProxyAuthenticate,

    /// # Proxy-Authorization,
    ProxyAuthorization,

    /// # Age,
    Age,

    /// # Cache-Control,
    CacheControl,

    /// # Clear-Site-Data,
    ClearSiteData,

    /// # Expires,
    Expires,

    /// # Pragma,
    Pragma,

    /// # Warning,
    Warning,

    /// # Last-Modified,
    LastModified,

    /// # ETag,
    ETag,

    /// # If-Match,
    IfMatch,

    /// # If-None-Match,
    IfNoneMatch,

    /// # If-Modified-Since,
    IfModifiedSince,

    /// # If-Unmodified-Since,
    IfUnmodifiedSince,

    /// # Vary,
    Vary,

    /// # Connection,
    Connection,

    /// # Keep-Alive,
    KeepAlive,

    /// # Accept,
    Accept,

    /// # Accept-Charset,
    AcceptCharset,

    /// # Accept-Encoding,
    AcceptEncoding,

    /// # Accept-Language,
    AcceptLanguage,

    /// # Expect,
    Expect,

    /// # Max-Forwards,
    MaxForwards,

    /// # Cookie,
    Cookie,

    /// # Set-Cookie,
    SetCookie,

    /// # Access-Control-Allow-Origin,
    AccessControlAllowOrigin,

    /// # Access-Control-Allow-Credentials,
    AccessControlAllowCredentials,

    /// # Access-Control-Allow-Headers,
    AccessControlAllowHeaders,

    /// # Access-Control-Allow-Methods,
    AccessControlAllowMethods,

    /// # Access-Control-Expose-Headers,
    AccessControlExposeHeaders,

    /// # Access-Control-Max-Age,
    AccessControlMaxAge,

    /// # Access-Control-Request-Headers,
    AccessControlRequestHeaders,

    /// # Access-Control-Request-Method,
    AccessControlRequestMethod,

    /// # Origin,
    Origin,

    /// # Service-Worker-Allowed,
    ServiceWorkerAllowed,

    /// # Timing-Allow-Origin,
    TimingAllowOrigin,

    /// # X-Permitted-Cross-Domain-Policies,
    XPermittedCrossDomainPolicies,

    /// # DNT,
    DNT,

    /// # Tk,
    Tk,

    /// # Content-Disposition,
    ContentDisposition,

    /// # Content-Length,
    ContentLength,

    /// # Content-Type,
    ContentType,

    /// # Content-Encoding,
    ContentEncoding,

    /// # Content-Language,
    ContentLanguage,

    /// # Content-Location,
    ContentLocation,

    /// # Forwarded,
    Forwarded,

    /// # Via,
    Via,

    /// # Location,
    Location,

    /// # From,
    From,

    /// # Host,
    Host,

    /// # Referer,
    Referer,

    /// # Referrer-Policy,
    ReferrerPolicy,

    /// # User-Agent,
    UserAgent,

    /// # Allow,
    Allow,

    /// # Server,
    Server,

    /// # Accept-Ranges,
    AcceptRanges,

    /// # Range,
    Range,

    /// # If-Range,
    IfRange,

    /// # Content-Range,
    ContentRange,

    /// # Cross-Origin-Opener-Policy
    CrossOriginOpenerPolicy,

    /// # Cross-Origin-Resource-Policy
    CrossOriginResourcePolicy,

    /// # Content-Security-Policy
    ContentSecurityPolicy,

    /// # Content-Security-Policy-Report-Only,
    ContentSecurityPolicyReportOnly,

    /// # Expect-CT,
    ExpectCT,

    /// # Feature-Policy,
    FeaturePolicy,

    /// # Public-Key-Pins
    PublicKeyPins,

    /// # Public-Key-Pins-Report-Only,
    PublicKeyPinsReportOnly,

    /// # Strict-Transport-Security
    StrictTransportSecurity,

    /// # Upgrade-Insecure-Requests,
    UpgradeInsecureRequests,

    /// # X-Content-Type-Options,
    XContentTypeOptions,

    /// # X-Download-Options,
    XDownloadOptions,

    /// # X-Frame-Options
    XFrameOptions,

    /// # X-Powered-By,
    XPoweredBy,

    /// # X-XSS-Protection,
    XXSSProtection,

    /// # Last-Event-ID,
    LastEventID,

    /// # Ping-From,
    PingFrom,

    /// # Ping-To,
    PingTo,

    /// # Report-To,
    ReportTo,

    /// # Transfer-Encoding,
    TransferEncoding,

    /// # TE,
    TE,

    /// # Trailer,
    Trailer,

    /// # Sec-WebSocket-Key,
    SecWebSocketKey,

    /// # Sec-WebSocket-Extensions,
    SecWebSocketExtensions,

    /// # Sec-WebSocket-Accept,
    SecWebSocketAccept,

    /// # Sec-WebSocket-Protocol,
    SecWebSocketProtocol,

    /// # Sec-WebSocket-Version,
    SecWebSocketVersion,

    /// # Alt-Svc,
    AltSvc,

    /// # Date,
    Date,

    /// # Large-Allocation,
    LargeAllocation,

    /// # Link,
    Link,

    /// # Retry-After,
    RetryAfter,

    /// # Server-Timing,
    ServerTiming,

    /// # SourceMap,
    SourceMap,

    /// # Upgrade,
    Upgrade,

    /// # X-DNS-Prefetch-Control,
    XDNSPrefetchControl,

    /// # X-Requested-With,
    XRequestedWith,

    /// # Unknown
    Unknown(String),

}

impl Header {

    /// # Checks if this header is standard
    pub fn is_standard(&self) -> bool {
        match self {
            Header::Unknown(_) => false,
            _ => true,
        }
    }

}

impl Display for Header {

    fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
        f.write_str(match self {
            Header::WWWAuthenticate => HEADER_WWW_AUTHENTICATE,
            Header::Authorization => HEADER_AUTHORIZATION,
            Header::ProxyAuthenticate => HEADER_PROXY_AUTHENTICATE,
            Header::ProxyAuthorization => HEADER_PROXY_AUTHORIZATION,
            Header::Age => HEADER_AGE,
            Header::CacheControl => HEADER_CACHE_CONTROL,
            Header::ClearSiteData => HEADER_CLEAR_SITE_DATA,
            Header::Expires => HEADER_EXPIRES,
            Header::Pragma => HEADER_PRAGMA,
            Header::Warning => HEADER_WARNING,
            Header::LastModified => HEADER_LAST_MODIFIED,
            Header::ETag => HEADER_ETAG,
            Header::IfMatch => HEADER_IF_MATCH,
            Header::IfNoneMatch => HEADER_IF_NONE_MATCH,
            Header::IfModifiedSince => HEADER_IF_MODIFIED_SINCE,
            Header::IfUnmodifiedSince => HEADER_IF_UNMODIFIED_SINCE,
            Header::Vary => HEADER_VARY,
            Header::Connection => HEADER_CONNECTION,
            Header::KeepAlive => HEADER_KEEP_ALIVE,
            Header::Accept => HEADER_ACCEPT,
            Header::AcceptCharset => HEADER_ACCEPT_CHARSET,
            Header::AcceptEncoding => HEADER_ACCEPT_ENCODING,
            Header::AcceptLanguage => HEADER_ACCEPT_LANGUAGE,
            Header::Expect => HEADER_EXPECT,
            Header::MaxForwards => HEADER_MAX_FORWARDS,
            Header::Cookie => HEADER_COOKIE,
            Header::SetCookie => HEADER_SET_COOKIE,
            Header::AccessControlAllowOrigin => HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
            Header::AccessControlAllowCredentials => HEADER_ACCESS_CONTROL_ALLOW_CREDENTIALS,
            Header::AccessControlAllowHeaders => HEADER_ACCESS_CONTROL_ALLOW_HEADERS,
            Header::AccessControlAllowMethods => HEADER_ACCESS_CONTROL_ALLOW_METHODS,
            Header::AccessControlExposeHeaders => HEADER_ACCESS_CONTROL_EXPOSE_HEADERS,
            Header::AccessControlMaxAge => HEADER_ACCESS_CONTROL_MAX_AGE,
            Header::AccessControlRequestHeaders => HEADER_ACCESS_CONTROL_REQUEST_HEADERS,
            Header::AccessControlRequestMethod => HEADER_ACCESS_CONTROL_REQUEST_METHOD,
            Header::Origin => HEADER_ORIGIN,
            Header::ServiceWorkerAllowed => HEADER_SERVICE_WORKER_ALLOWED,
            Header::TimingAllowOrigin => HEADER_TIMING_ALLOW_ORIGIN,
            Header::XPermittedCrossDomainPolicies => HEADER_X_PERMITTED_CROSS_DOMAIN_POLICIES,
            Header::DNT => HEADER_DNT,
            Header::Tk => HEADER_TK,
            Header::ContentDisposition => HEADER_CONTENT_DISPOSITION,
            Header::ContentLength => HEADER_CONTENT_LENGTH,
            Header::ContentType => HEADER_CONTENT_TYPE,
            Header::ContentEncoding => HEADER_CONTENT_ENCODING,
            Header::ContentLanguage => HEADER_CONTENT_LANGUAGE,
            Header::ContentLocation => HEADER_CONTENT_LOCATION,
            Header::Forwarded => HEADER_FORWARDED,
            Header::Via => HEADER_VIA,
            Header::Location => HEADER_LOCATION,
            Header::From => HEADER_FROM,
            Header::Host => HEADER_HOST,
            Header::Referer => HEADER_REFERER,
            Header::ReferrerPolicy => HEADER_REFERRER_POLICY,
            Header::UserAgent => HEADER_USER_AGENT,
            Header::Allow => HEADER_ALLOW,
            Header::Server => HEADER_SERVER,
            Header::AcceptRanges => HEADER_ACCEPT_RANGES,
            Header::Range => HEADER_RANGE,
            Header::IfRange => HEADER_IF_RANGE,
            Header::ContentRange => HEADER_CONTENT_RANGE,
            Header::CrossOriginOpenerPolicy => HEADER_CROSS_ORIGIN_OPENER_POLICY,
            Header::CrossOriginResourcePolicy => HEADER_CROSS_ORIGIN_RESOURCE_POLICY,
            Header::ContentSecurityPolicy => HEADER_CONTENT_SECURITY_POLICY,
            Header::ContentSecurityPolicyReportOnly => HEADER_CONTENT_SECURITY_POLICY_REPORT_ONLY,
            Header::ExpectCT => HEADER_EXPECT_CT,
            Header::FeaturePolicy => HEADER_FEATURE_POLICY,
            Header::PublicKeyPins => HEADER_PUBLIC_KEY_PINS,
            Header::PublicKeyPinsReportOnly => HEADER_PUBLIC_KEY_PINS_REPORT_ONLY,
            Header::StrictTransportSecurity => HEADER_STRICT_TRANSPORT_SECURITY,
            Header::UpgradeInsecureRequests => HEADER_UPGRADE_INSECURE_REQUESTS,
            Header::XContentTypeOptions => HEADER_X_CONTENT_TYPE_OPTIONS,
            Header::XDownloadOptions => HEADER_X_DOWNLOAD_OPTIONS,
            Header::XFrameOptions => HEADER_X_FRAME_OPTIONS,
            Header::XPoweredBy => HEADER_X_POWERED_BY,
            Header::XXSSProtection => HEADER_X_XSS_PROTECTION,
            Header::LastEventID => HEADER_LAST_EVENT_ID,
            Header::PingFrom => HEADER_PING_FROM,
            Header::PingTo => HEADER_PING_TO,
            Header::ReportTo => HEADER_REPORT_TO,
            Header::TransferEncoding => HEADER_TRANSFER_ENCODING,
            Header::TE => HEADER_TE,
            Header::Trailer => HEADER_TRAILER,
            Header::SecWebSocketKey => HEADER_SEC_WEBSOCKET_KEY,
            Header::SecWebSocketExtensions => HEADER_SEC_WEBSOCKET_EXTENSIONS,
            Header::SecWebSocketAccept => HEADER_SEC_WEBSOCKET_ACCEPT,
            Header::SecWebSocketProtocol => HEADER_SEC_WEBSOCKET_PROTOCOL,
            Header::SecWebSocketVersion => HEADER_SEC_WEBSOCKET_VERSION,
            Header::AltSvc => HEADER_ALT_SVC,
            Header::Date => HEADER_DATE,
            Header::LargeAllocation => HEADER_LARGE_ALLOCATION,
            Header::Link => HEADER_LINK,
            Header::RetryAfter => HEADER_RETRY_AFTER,
            Header::ServerTiming => HEADER_SERVER_TIMING,
            Header::SourceMap => HEADER_SOURCEMAP,
            Header::Upgrade => HEADER_UPGRADE,
            Header::XDNSPrefetchControl => HEADER_X_DNS_PREFETCH_CONTROL,
            Header::XRequestedWith => HEADER_X_REQUESTED_WITH,
            Header::Unknown(s) => s,
        })
    }

}

impl FromStr for Header {

    type Err = Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        for f in &[
            parse_authenticating_headers, parse_caching_headers, parse_conditional_headers, parse_connection_management_headers,
            parse_content_negotiating_headers, parse_control_headers, parse_cookie_headers, parse_cors_headers, parse_dnt_headers,
            parse_downloading_headers, parse_message_body_information_headers, parse_proxy_headers, parse_redirecting_headers,
            parse_request_headers, parse_response_headers, parse_range_headers, parse_security_headers, parse_server_headers,
            parse_transfer_encoding_headers, parse_web_sockets_headers, parse_other_headers,
        ] {
            if let Some(result) = f(s) {
                return Ok(result);
            }
        }

        Ok(Header::Unknown(s.to_string()))
    }

}

/// # Parses authenticating headers
fn parse_authenticating_headers(s: &str) -> Option<Header> {
    if HEADER_WWW_AUTHENTICATE.eq_ignore_ascii_case(s) {
        return Some(Header::WWWAuthenticate);
    }
    if HEADER_AUTHORIZATION.eq_ignore_ascii_case(s) {
        return Some(Header::Authorization);
    }
    if HEADER_PROXY_AUTHENTICATE.eq_ignore_ascii_case(s) {
        return Some(Header::ProxyAuthenticate);
    }
    if HEADER_PROXY_AUTHORIZATION.eq_ignore_ascii_case(s) {
        return Some(Header::ProxyAuthorization);
    }

    None
}

/// # Parses caching headers
fn parse_caching_headers(s: &str) -> Option<Header> {
    if HEADER_AGE.eq_ignore_ascii_case(s) {
        return Some(Header::Age);
    }
    if HEADER_CACHE_CONTROL.eq_ignore_ascii_case(s) {
        return Some(Header::CacheControl);
    }
    if HEADER_CLEAR_SITE_DATA.eq_ignore_ascii_case(s) {
        return Some(Header::ClearSiteData);
    }
    if HEADER_EXPIRES.eq_ignore_ascii_case(s) {
        return Some(Header::Expires);
    }
    if HEADER_PRAGMA.eq_ignore_ascii_case(s) {
        return Some(Header::Pragma);
    }
    if HEADER_WARNING.eq_ignore_ascii_case(s) {
        return Some(Header::Warning);
    }

    None
}

/// # Parses conditional headers
fn parse_conditional_headers(s: &str) -> Option<Header> {
    if HEADER_LAST_MODIFIED.eq_ignore_ascii_case(s) {
        return Some(Header::LastModified);
    }
    if HEADER_ETAG.eq_ignore_ascii_case(s) {
        return Some(Header::ETag);
    }
    if HEADER_IF_MATCH.eq_ignore_ascii_case(s) {
        return Some(Header::IfMatch);
    }
    if HEADER_IF_NONE_MATCH.eq_ignore_ascii_case(s) {
        return Some(Header::IfNoneMatch);
    }
    if HEADER_IF_MODIFIED_SINCE.eq_ignore_ascii_case(s) {
        return Some(Header::IfModifiedSince);
    }
    if HEADER_IF_UNMODIFIED_SINCE.eq_ignore_ascii_case(s) {
        return Some(Header::IfUnmodifiedSince);
    }
    if HEADER_VARY.eq_ignore_ascii_case(s) {
        return Some(Header::Vary);
    }

    None
}

/// # Parses connection management headers
fn parse_connection_management_headers(s: &str) -> Option<Header> {
    if HEADER_CONNECTION.eq_ignore_ascii_case(s) {
        return Some(Header::Connection);
    }
    if HEADER_KEEP_ALIVE.eq_ignore_ascii_case(s) {
        return Some(Header::KeepAlive);
    }

    None
}

/// # Parses content negotiating headers
fn parse_content_negotiating_headers(s: &str) -> Option<Header> {
    if HEADER_ACCEPT.eq_ignore_ascii_case(s) {
        return Some(Header::Accept);
    }
    if HEADER_ACCEPT_CHARSET.eq_ignore_ascii_case(s) {
        return Some(Header::AcceptCharset);
    }
    if HEADER_ACCEPT_ENCODING.eq_ignore_ascii_case(s) {
        return Some(Header::AcceptEncoding);
    }
    if HEADER_ACCEPT_LANGUAGE.eq_ignore_ascii_case(s) {
        return Some(Header::AcceptLanguage);
    }

    None
}

/// # Parses control headers
fn parse_control_headers(s: &str) -> Option<Header> {
    if HEADER_EXPECT.eq_ignore_ascii_case(s) {
        return Some(Header::Expect);
    }
    if HEADER_MAX_FORWARDS.eq_ignore_ascii_case(s) {
        return Some(Header::MaxForwards);
    }

    None
}

/// # Parses cookie headers
fn parse_cookie_headers(s: &str) -> Option<Header> {
    if HEADER_COOKIE.eq_ignore_ascii_case(s) {
        return Some(Header::Cookie);
    }
    if HEADER_SET_COOKIE.eq_ignore_ascii_case(s) {
        return Some(Header::SetCookie);
    }

    None
}

/// # Parses cors headers
fn parse_cors_headers(s: &str) -> Option<Header> {
    if HEADER_ACCESS_CONTROL_ALLOW_ORIGIN.eq_ignore_ascii_case(s) {
        return Some(Header::AccessControlAllowOrigin);
    }
    if HEADER_ACCESS_CONTROL_ALLOW_CREDENTIALS.eq_ignore_ascii_case(s) {
        return Some(Header::AccessControlAllowCredentials);
    }
    if HEADER_ACCESS_CONTROL_ALLOW_HEADERS.eq_ignore_ascii_case(s) {
        return Some(Header::AccessControlAllowHeaders);
    }
    if HEADER_ACCESS_CONTROL_ALLOW_METHODS.eq_ignore_ascii_case(s) {
        return Some(Header::AccessControlAllowMethods);
    }
    if HEADER_ACCESS_CONTROL_EXPOSE_HEADERS.eq_ignore_ascii_case(s) {
        return Some(Header::AccessControlExposeHeaders);
    }
    if HEADER_ACCESS_CONTROL_MAX_AGE.eq_ignore_ascii_case(s) {
        return Some(Header::AccessControlMaxAge);
    }
    if HEADER_ACCESS_CONTROL_REQUEST_HEADERS.eq_ignore_ascii_case(s) {
        return Some(Header::AccessControlRequestHeaders);
    }
    if HEADER_ACCESS_CONTROL_REQUEST_METHOD.eq_ignore_ascii_case(s) {
        return Some(Header::AccessControlRequestMethod);
    }
    if HEADER_ORIGIN.eq_ignore_ascii_case(s) {
        return Some(Header::Origin);
    }
    if HEADER_SERVICE_WORKER_ALLOWED.eq_ignore_ascii_case(s) {
        return Some(Header::ServiceWorkerAllowed);
    }
    if HEADER_TIMING_ALLOW_ORIGIN.eq_ignore_ascii_case(s) {
        return Some(Header::TimingAllowOrigin);
    }
    if HEADER_X_PERMITTED_CROSS_DOMAIN_POLICIES.eq_ignore_ascii_case(s) {
        return Some(Header::XPermittedCrossDomainPolicies);
    }

    None
}

/// # Parses DNT headers
fn parse_dnt_headers(s: &str) -> Option<Header> {
    if HEADER_DNT.eq_ignore_ascii_case(s) {
        return Some(Header::DNT);
    }
    if HEADER_TK.eq_ignore_ascii_case(s) {
        return Some(Header::Tk);
    }

    None
}

/// # Parses downloading headers
fn parse_downloading_headers(s: &str) -> Option<Header> {
    if HEADER_CONTENT_DISPOSITION.eq_ignore_ascii_case(s) {
        return Some(Header::ContentDisposition);
    }

    None
}

/// # Parses message body information headers
fn parse_message_body_information_headers(s: &str) -> Option<Header> {
    if HEADER_CONTENT_LENGTH.eq_ignore_ascii_case(s) {
        return Some(Header::ContentLength);
    }
    if HEADER_CONTENT_TYPE.eq_ignore_ascii_case(s) {
        return Some(Header::ContentType);
    }
    if HEADER_CONTENT_ENCODING.eq_ignore_ascii_case(s) {
        return Some(Header::ContentEncoding);
    }
    if HEADER_CONTENT_LANGUAGE.eq_ignore_ascii_case(s) {
        return Some(Header::ContentLanguage);
    }
    if HEADER_CONTENT_LOCATION.eq_ignore_ascii_case(s) {
        return Some(Header::ContentLocation);
    }

    None
}

/// # Parses proxy headers
fn parse_proxy_headers(s: &str) -> Option<Header> {
    if HEADER_FORWARDED.eq_ignore_ascii_case(s) {
        return Some(Header::Forwarded);
    }
    if HEADER_VIA.eq_ignore_ascii_case(s) {
        return Some(Header::Via);
    }

    None
}

/// # Parses redirecting headers
fn parse_redirecting_headers(s: &str) -> Option<Header> {
    if HEADER_LOCATION.eq_ignore_ascii_case(s) {
        return Some(Header::Location);
    }

    None
}

/// # Parses request headers
fn parse_request_headers(s: &str) -> Option<Header> {
    if HEADER_FROM.eq_ignore_ascii_case(s) {
        return Some(Header::From);
    }
    if HEADER_HOST.eq_ignore_ascii_case(s) {
        return Some(Header::Host);
    }
    if HEADER_REFERER.eq_ignore_ascii_case(s) {
        return Some(Header::Referer);
    }
    if HEADER_REFERRER_POLICY.eq_ignore_ascii_case(s) {
        return Some(Header::ReferrerPolicy);
    }
    if HEADER_USER_AGENT.eq_ignore_ascii_case(s) {
        return Some(Header::UserAgent);
    }

    None
}

/// # Parses response headers
fn parse_response_headers(s: &str) -> Option<Header> {
    if HEADER_ALLOW.eq_ignore_ascii_case(s) {
        return Some(Header::Allow);
    }
    if HEADER_SERVER.eq_ignore_ascii_case(s) {
        return Some(Header::Server);
    }

    None
}

/// # Parses range headers
fn parse_range_headers(s: &str) -> Option<Header> {
    if HEADER_ACCEPT_RANGES.eq_ignore_ascii_case(s) {
        return Some(Header::AcceptRanges);
    }
    if HEADER_RANGE.eq_ignore_ascii_case(s) {
        return Some(Header::Range);
    }
    if HEADER_IF_RANGE.eq_ignore_ascii_case(s) {
        return Some(Header::IfRange);
    }
    if HEADER_CONTENT_RANGE.eq_ignore_ascii_case(s) {
        return Some(Header::ContentRange);
    }

    None
}

/// # Parses security headers
fn parse_security_headers(s: &str) -> Option<Header> {
    if HEADER_CROSS_ORIGIN_OPENER_POLICY.eq_ignore_ascii_case(s) {
        return Some(Header::CrossOriginOpenerPolicy);
    }
    if HEADER_CROSS_ORIGIN_RESOURCE_POLICY.eq_ignore_ascii_case(s) {
        return Some(Header::CrossOriginResourcePolicy);
    }
    if HEADER_CONTENT_SECURITY_POLICY.eq_ignore_ascii_case(s) {
        return Some(Header::ContentSecurityPolicy);
    }
    if HEADER_CONTENT_SECURITY_POLICY_REPORT_ONLY.eq_ignore_ascii_case(s) {
        return Some(Header::ContentSecurityPolicyReportOnly);
    }
    if HEADER_EXPECT_CT.eq_ignore_ascii_case(s) {
        return Some(Header::ExpectCT);
    }
    if HEADER_FEATURE_POLICY.eq_ignore_ascii_case(s) {
        return Some(Header::FeaturePolicy);
    }
    if HEADER_PUBLIC_KEY_PINS.eq_ignore_ascii_case(s) {
        return Some(Header::PublicKeyPins);
    }
    if HEADER_PUBLIC_KEY_PINS_REPORT_ONLY.eq_ignore_ascii_case(s) {
        return Some(Header::PublicKeyPinsReportOnly);
    }
    if HEADER_STRICT_TRANSPORT_SECURITY.eq_ignore_ascii_case(s) {
        return Some(Header::StrictTransportSecurity);
    }
    if HEADER_UPGRADE_INSECURE_REQUESTS.eq_ignore_ascii_case(s) {
        return Some(Header::UpgradeInsecureRequests);
    }
    if HEADER_X_CONTENT_TYPE_OPTIONS.eq_ignore_ascii_case(s) {
        return Some(Header::XContentTypeOptions);
    }
    if HEADER_X_DOWNLOAD_OPTIONS.eq_ignore_ascii_case(s) {
        return Some(Header::XDownloadOptions);
    }
    if HEADER_X_FRAME_OPTIONS.eq_ignore_ascii_case(s) {
        return Some(Header::XFrameOptions);
    }
    if HEADER_X_POWERED_BY.eq_ignore_ascii_case(s) {
        return Some(Header::XPoweredBy);
    }
    if HEADER_X_XSS_PROTECTION.eq_ignore_ascii_case(s) {
        return Some(Header::XXSSProtection);
    }

    None
}

/// # Parses server headers
fn parse_server_headers(s: &str) -> Option<Header> {
    if HEADER_LAST_EVENT_ID.eq_ignore_ascii_case(s) {
        return Some(Header::LastEventID);
    }
    if HEADER_PING_FROM.eq_ignore_ascii_case(s) {
        return Some(Header::PingFrom);
    }
    if HEADER_PING_TO.eq_ignore_ascii_case(s) {
        return Some(Header::PingTo);
    }
    if HEADER_REPORT_TO.eq_ignore_ascii_case(s) {
        return Some(Header::ReportTo);
    }

    None
}

/// # Parses transfer encoding headers
fn parse_transfer_encoding_headers(s: &str) -> Option<Header> {
    if HEADER_TRANSFER_ENCODING.eq_ignore_ascii_case(s) {
        return Some(Header::TransferEncoding);
    }
    if HEADER_TE.eq_ignore_ascii_case(s) {
        return Some(Header::TE);
    }
    if HEADER_TRAILER.eq_ignore_ascii_case(s) {
        return Some(Header::Trailer);
    }

    None
}

/// # Parses web-sockets headers
fn parse_web_sockets_headers(s: &str) -> Option<Header> {
    if HEADER_SEC_WEBSOCKET_KEY.eq_ignore_ascii_case(s) {
        return Some(Header::SecWebSocketKey);
    }
    if HEADER_SEC_WEBSOCKET_EXTENSIONS.eq_ignore_ascii_case(s) {
        return Some(Header::SecWebSocketExtensions);
    }
    if HEADER_SEC_WEBSOCKET_ACCEPT.eq_ignore_ascii_case(s) {
        return Some(Header::SecWebSocketAccept);
    }
    if HEADER_SEC_WEBSOCKET_PROTOCOL.eq_ignore_ascii_case(s) {
        return Some(Header::SecWebSocketProtocol);
    }
    if HEADER_SEC_WEBSOCKET_VERSION.eq_ignore_ascii_case(s) {
        return Some(Header::SecWebSocketVersion);
    }

    None
}

/// # Parses other headers
fn parse_other_headers(s: &str) -> Option<Header> {
    if HEADER_ALT_SVC.eq_ignore_ascii_case(s) {
        return Some(Header::AltSvc);
    }
    if HEADER_DATE.eq_ignore_ascii_case(s) {
        return Some(Header::Date);
    }
    if HEADER_LARGE_ALLOCATION.eq_ignore_ascii_case(s) {
        return Some(Header::LargeAllocation);
    }
    if HEADER_LINK.eq_ignore_ascii_case(s) {
        return Some(Header::Link);
    }
    if HEADER_RETRY_AFTER.eq_ignore_ascii_case(s) {
        return Some(Header::RetryAfter);
    }
    if HEADER_SERVER_TIMING.eq_ignore_ascii_case(s) {
        return Some(Header::ServerTiming);
    }
    if HEADER_SOURCEMAP.eq_ignore_ascii_case(s) {
        return Some(Header::SourceMap);
    }
    if HEADER_UPGRADE.eq_ignore_ascii_case(s) {
        return Some(Header::Upgrade);
    }
    if HEADER_X_DNS_PREFETCH_CONTROL.eq_ignore_ascii_case(s) {
        return Some(Header::XDNSPrefetchControl);
    }
    if HEADER_X_REQUESTED_WITH.eq_ignore_ascii_case(s) {
        return Some(Header::XRequestedWith);
    }

    None
}