use http::HeaderValue;
 
fn main() -> Result<(), Box<dyn std::error::Error>> {
    // HeaderValue represents the value portion of an HTTP header
    // It's used in HeaderMap and Response/Request builders
    
    let mut headers = http::HeaderMap::new();
    
    // HeaderValue is created from validated strings or bytes
    let content_type = HeaderValue::from_str("application/json")?;
    headers.insert(http::header::CONTENT_TYPE, content_type);
    
    let server = HeaderValue::from_str("MyServer/1.0")?;
    headers.insert(http::header::SERVER, server);
    
    println!("Headers: {:?}", headers);
    
    Ok(())
}

use http::HeaderValue;
 
fn main() -> Result<(), Box<dyn std::error::Error>> {
    // from_str validates that all characters are visible ASCII
    // Valid: visible ASCII characters (0x20-0x7E)
    
    let valid = HeaderValue::from_str("application/json")?;
    println!("Valid header: {:?}", valid);
    
    let valid2 = HeaderValue::from_str("text/html; charset=utf-8")?;
    println!("Valid header: {:?}", valid2);
    
    let valid3 = HeaderValue::from_str("value with spaces")?;
    println!("Valid header: {:?}", valid3);
    
    // from_str rejects:
    // - Control characters (0x00-0x1F and 0x7F)
    // - Non-ASCII characters (> 0x7E)
    
    // This would fail - control character
    // let invalid = HeaderValue::from_str("value\x00with\x00nulls")?;
    
    // This would fail - non-ASCII
    // let invalid = HeaderValue::from_str("日本語")?;
    
    // This would fail - newline
    // let invalid = HeaderValue::from_str("value\nmore")?;
    
    Ok(())
}

use http::HeaderValue;
 
fn main() -> Result<(), Box<dyn std::error::Error>> {
    // from_bytes accepts &[u8] and has relaxed validation
    // It rejects: null bytes (0x00) and newlines (0x0A, 0x0D)
    // But allows: other bytes including non-ASCII
    
    // Normal ASCII works fine
    let normal = HeaderValue::from_bytes(b"application/json")?;
    println!("Normal: {:?}", normal);
    
    // Non-ASCII bytes are allowed
    let non_ascii = HeaderValue::from_bytes(b"UTF-8: \xC3\xA9")?;  // é in UTF-8
    println!("Non-ASCII: {:?}", non_ascii);
    
    // from_bytes still rejects null bytes
    // let invalid = HeaderValue::from_bytes(b"value\x00here")?;
    // Error: InvalidHeaderValue
    
    // from_bytes rejects newlines (for header injection protection)
    // let invalid = HeaderValue::from_bytes(b"value\ninjected: bad")?;
    
    Ok(())
}

use http::HeaderValue;
 
fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Comparison of validation rules:
    
    // from_str(&str) -> Result<HeaderValue, InvalidHeaderValue>
    // - Input: UTF-8 string (guaranteed valid UTF-8 by Rust)
    // - Validation: visible ASCII only (0x20-0x7E)
    // - Rejects: control chars, non-ASCII characters
    
    // from_bytes(&[u8]) -> Result<HeaderValue, InvalidHeaderValue>
    // - Input: byte slice (arbitrary bytes)
    // - Validation: no nulls or newlines
    // - Allows: non-ASCII bytes, control chars except NUL/LF/CR
    
    // ASCII input - both work the same
    let from_str = HeaderValue::from_str("hello")?;
    let from_bytes = HeaderValue::from_bytes(b"hello")?;
    assert_eq!(from_str, from_bytes);
    
    // Non-ASCII input
    // from_str fails - non-ASCII not allowed
    // from_bytes succeeds - non-ASCII is allowed
    
    let bytes = b"binary\xFFdata";  // Contains 0xFF
    let header = HeaderValue::from_bytes(bytes)?;
    // from_str would fail: HeaderValue::from_str("binary\xFFdata")
    // (Actually that wouldn't compile - can't put \xFF in &str)
    
    println!("Binary header: {:?}", header);
    
    Ok(())
}

use http::HeaderValue;
 
fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Use from_str when:
    // 1. You have string data (most common case)
    // 2. You want strict HTTP compliance
    // 3. You want compile-time guarantees about input
    
    // User agent strings
    let user_agent = HeaderValue::from_str("MyApp/1.0")?;
    
    // Content types
    let content_type = HeaderValue::from_str("application/json")?;
    
    // Authorization schemes (ASCII portion)
    let auth = HeaderValue::from_str("Bearer token123")?;
    
    // Cache directives
    let cache_control = HeaderValue::from_str("max-age=3600, public")?;
    
    // from_str is more ergonomic when working with string literals
    // The compiler validates the string at compile time
    
    // This is preferred for all standard HTTP headers
    let mut headers = http::HeaderMap::new();
    headers.insert("X-Custom", HeaderValue::from_str("value")?);
    
    Ok(())
}

use http::HeaderValue;
 
fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Use from_bytes when:
    // 1. You have raw bytes from external source
    // 2. You need non-ASCII header values (rare)
    // 3. You're working with binary data in headers
    
    // Binary tokens in custom headers
    let token: [u8; 16] = [0x01, 0x02, 0x03, 0x04, 
                           0x05, 0x06, 0x07, 0x08,
                           0x09, 0x0A, 0x0B, 0x0C,
                           0x0D, 0x0E, 0x0F, 0x10];
    
    // Note: 0x0A is newline, would be rejected!
    // Let's use valid bytes instead
    let token: [u8; 16] = [0x01, 0x02, 0x03, 0x04, 
                           0x05, 0x06, 0x07, 0x08,
                           0x09, 0x0B, 0x0C, 0x0D,  // skip 0x0A
                           0x0E, 0x0F, 0x10, 0x11];
    
    // Base64 encode for safe header transmission
    let encoded = base64_encode(&token);
    let header = HeaderValue::from_str(&encoded)?;
    println!("Token header: {:?}", header);
    
    // Binary data that must go in header
    let binary_value = b"\x80\x81\x82\x83";  // High bytes
    let header = HeaderValue::from_bytes(binary_value)?;
    println!("Binary header: {:?}", header);
    
    // Data from file or network (already as bytes)
    let raw_bytes: Vec<u8> = vec![0x48, 0x65, 0x6C, 0x6C, 0x6F];  // "Hello"
    let header = HeaderValue::from_bytes(&raw_bytes)?;
    println!("From raw bytes: {:?}", header);
    
    Ok(())
}
 
fn base64_encode(data: &[u8]) -> String {
    // Simplified - use base64 crate in practice
    data.iter().map(|b| format!("{:02X}", b)).collect::<Vec<_>>().join("")
}

use http::HeaderValue;
 
fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Both methods protect against header injection
    
    // Newline injection attempt - BOTH reject this
    // These would fail:
    // HeaderValue::from_str("value\r\nX-Injected: malicious")?
    // HeaderValue::from_bytes(b"value\r\nX-Injected: malicious")?
    
    // This is crucial for security - prevents HTTP response splitting
    
    // from_str additionally catches control characters
    // that might cause issues in logging or processing
    
    // Example: safe handling of user input
    fn safe_header_from_user(user_input: &str) -> Result<HeaderValue, String> {
        // from_str validates input
        HeaderValue::from_str(user_input)
            .map_err(|e| format!("Invalid header value: {}", e))
    }
    
    // If you need to accept more bytes, you can use from_bytes
    // but be careful about what those bytes mean
    fn permissive_header_from_user(user_bytes: &[u8]) -> Result<HeaderValue, String> {
        // from_bytes is more permissive
        // but still rejects nulls and newlines
        HeaderValue::from_bytes(user_bytes)
            .map_err(|e| format!("Invalid header value: {}", e))
    }
    
    let safe = safe_header_from_user("application/json")?;
    println!("Safe: {:?}", safe);
    
    // from_str would reject this, but from_bytes accepts
    let permissive = permissive_header_from_user(b"binary\x80data")?;
    println!("Permissive: {:?}", permissive);
    
    Ok(())
}

use http::{HeaderValue, Response, HeaderMap};
 
fn build_response(content_type: &str, body: Vec<u8>) -> Result<Response<Vec<u8>>, Box<dyn std::error::Error>> {
    let mut response = Response::new(body);
    
    // Standard headers - use from_str
    response.headers_mut().insert(
        http::header::CONTENT_TYPE,
        HeaderValue::from_str(content_type)?
    );
    
    response.headers_mut().insert(
        http::header::SERVER,
        HeaderValue::from_str("MyServer/1.0")?
    );
    
    // Content length can use from_str
    let len = response.body().len();
    response.headers_mut().insert(
        http::header::CONTENT_LENGTH,
        HeaderValue::from_str(&len.to_string())?
    );
    
    Ok(response)
}
 
fn build_response_with_binary_header(
    content_type: &str, 
    binary_header: &[u8],
    body: Vec<u8>
) -> Result<Response<Vec<u8>>, Box<dyn std::error::Error>> {
    let mut response = Response::new(body);
    
    // Standard headers - from_str
    response.headers_mut().insert(
        http::header::CONTENT_TYPE,
        HeaderValue::from_str(content_type)?
    );
    
    // Custom binary header - from_bytes
    response.headers_mut().insert(
        "X-Binary-Token",
        HeaderValue::from_bytes(binary_header)?
    );
    
    Ok(response)
}
 
fn main() -> Result<(), Box<dyn std::error::Error>> {
    let response = build_response("application/json", b"{\"status\": \"ok\"}".to_vec())?;
    println!("Response headers: {:?}", response.headers());
    
    let binary_token: [u8; 8] = [0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE, 0xBA, 0xBE];
    let response2 = build_response_with_binary_header("text/plain", &binary_token, b"Hello".to_vec())?;
    println!("Response with binary header: {:?}", response2.headers());
    
    Ok(())
}

use http::HeaderValue;
 
fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Converting from HeaderValue back to string/bytes
    
    let header = HeaderValue::from_str("application/json")?;
    
    // as_bytes - get the raw bytes
    let bytes = header.as_bytes();
    println!("Bytes: {:?}", bytes);
    
    // to_str - convert to &str (may fail if non-ASCII)
    match header.to_str() {
        Ok(s) => println!("String: {}", s),
        Err(_) => println!("Contains non-ASCII bytes"),
    }
    
    // If you used from_bytes with non-ASCII:
    let binary_header = HeaderValue::from_bytes(b"binary\x80data")?;
    
    // as_bytes works
    println!("Binary bytes: {:?}", binary_header.as_bytes());
    
    // to_str fails for non-ASCII
    match binary_header.to_str() {
        Ok(s) => println!("String: {}", s),
        Err(_) => println!("Cannot convert to string - contains non-ASCII"),
    }
    
    // Safe conversion pattern
    fn header_to_string(header: &HeaderValue) -> String {
        // Try to convert to &str
        if let Ok(s) = header.to_str() {
            s.to_string()
        } else {
            // Fall back to hex representation
            header.as_bytes().iter()
                .map(|b| format!("{:02X}", b))
                .collect::<Vec<_>>()
                .join("")
        }
    }
    
    println!("Header string: {}", header_to_string(&header));
    println!("Binary header string: {}", header_to_string(&binary_header));
    
    Ok(())
}

use http::HeaderValue;
 
fn main() {
    // Both methods protect against header injection
    
    // This would be VERY BAD if allowed:
    // "value\r\nSet-Cookie: session=attacker_controlled"
    // An attacker could inject arbitrary headers
    
    let malicious_input = "value\r\nX-Injected: bad";
    
    // from_str rejects this
    match HeaderValue::from_str(malicious_input) {
        Ok(_) => println!("ERROR: Should have been rejected!"),
        Err(e) => println!("from_str correctly rejected: {}", e),
    }
    
    // from_bytes also rejects this
    match HeaderValue::from_bytes(malicious_input.as_bytes()) {
        Ok(_) => println!("ERROR: Should have been rejected!"),
        Err(e) => println!("from_bytes correctly rejected: {}", e),
    }
    
    // This protection is critical for web security
    // It prevents HTTP response splitting attacks
    
    fn set_user_header(headers: &mut http::HeaderMap, user_input: &str) -> Result<(), String> {
        // from_str provides security AND validation
        let value = HeaderValue::from_str(user_input)
            .map_err(|e| format!("Invalid header: {}", e))?;
        
        headers.insert("X-User-Input", value);
        Ok(())
    }
    
    let mut headers = http::HeaderMap::new();
    
    // Valid input works
    set_user_header(&mut headers, "valid-value").unwrap();
    
    // Malicious input is rejected
    match set_user_header(&mut headers, "valid\r\nX-Injected: bad") {
        Ok(()) => println!("ERROR: Injection not prevented!"),
        Err(e) => println!("Injection prevented: {}", e),
    }
}

use http::HeaderValue;
 
fn main() {
    // Both methods return Result<HeaderValue, InvalidHeaderValue>
    
    // from_str error handling
    match HeaderValue::from_str("valid") {
        Ok(value) => println!("Created: {:?}", value),
        Err(e) => eprintln!("Error: {}", e),
    }
    
    // Common error cases:
    // 1. Control characters (from_str)
    match HeaderValue::from_str("value\x00with\x00null") {
        Ok(_) => unreachable!(),
        Err(e) => println!("Rejected control characters: {}", e),
    }
    
    // 2. Newlines (both methods)
    match HeaderValue::from_bytes(b"value\nwith\nnewlines") {
        Ok(_) => unreachable!(),
        Err(e) => println!("Rejected newlines: {}", e),
    }
    
    // 3. Null bytes (both methods)
    match HeaderValue::from_bytes(b"value\x00with\x00null") {
        Ok(_) => unreachable!(),
        Err(e) => println!("Rejected null bytes: {}", e),
    }
    
    // Helper function with custom error handling
    fn parse_header_or_default(input: &[u8], default: &str) -> HeaderValue {
        HeaderValue::from_bytes(input)
            .unwrap_or_else(|_| HeaderValue::from_static(default))
    }
    
    let header = parse_header_or_default(b"valid", "default");
    println!("Header: {:?}", header);
    
    let header = parse_header_or_default(b"invalid\n", "default");
    println!("Header with default: {:?}", header);
}

use http::HeaderValue;
 
fn main() {
    // | Aspect              | from_str              | from_bytes            |
    // |---------------------|----------------------|------------------------|
    // | Input type          | &str                  | &[u8]                  |
    // | ASCII validation    | Visible ASCII only    | No restriction         |
    // | Control chars       | Rejected              | Rejected (NUL/LF/CR)   |
    // | Non-ASCII bytes     | N/A (str is UTF-8)    | Allowed                |
    // | Null bytes          | N/A                   | Rejected               |
    // | Newlines            | Rejected              | Rejected               |
    // | Security            | Injection protected   | Injection protected    |
    // | Use case            | Standard headers      | Binary/custom headers  |
    // | Ergonomics          | Works with strings    | Works with bytes       |
    
    // from_str is preferred for:
    // - All standard HTTP headers
    // - String literals
    // - User input that should be ASCII
    
    // from_bytes is preferred for:
    // - Binary data in headers
    // - Non-ASCII header values
    // - Data from external sources (files, network)
    
    println!("Comparison documented in table above");
}