use http::Method;
use std::convert::TryFrom;
 
fn construction_paths() {
    let bytes = b"GET";
    
    // from_bytes: direct hyper method, takes &[u8]
    let method1: Method = Method::from_bytes(bytes).unwrap();
    assert_eq!(method1, Method::GET);
    
    // try_from: standard library trait, works with &[u8] or &str
    let method2: Method = Method::try_from(bytes).unwrap();
    assert_eq!(method2, Method::GET);
    
    // try_from also works with string slices
    let method3: Method = Method::try_from("POST").unwrap();
    assert_eq!(method3, Method::POST);
    
    // Both produce identical Method values
    assert_eq!(method1, method2);
}

use http::Method;
 
fn from_bytes_examples() {
    // from_bytes specifically takes &[u8]
    let get = Method::from_bytes(b"GET").unwrap();
    assert_eq!(get, Method::GET);
    
    let post = Method::from_bytes(b"POST").unwrap();
    assert_eq!(post, Method::POST);
    
    // Works with extension methods (custom methods)
    let custom = Method::from_bytes(b"CUSTOM").unwrap();
    // This creates an extension method, not a known constant
    
    // Fails for invalid method names
    let invalid = Method::from_bytes(b"GET POST");  // Space not allowed
    assert!(invalid.is_err());
    
    let empty = Method::from_bytes(b"");
    assert!(empty.is_err());
    
    // The signature is:
    // pub fn from_bytes(src: &[u8]) -> Result<Method, InvalidMethod>
    
    // from_bytes is the canonical way when you have raw bytes
    // (e.g., from network parsing)
}

use http::Method;
use std::convert::TryFrom;
 
fn try_from_examples() {
    // try_from is the TryFrom trait implementation
    // It accepts &[u8] through TryFrom<&[u8]>
    let get: Method = Method::try_from(&b"GET"[..]).unwrap();
    assert_eq!(get, Method::GET);
    
    // It also accepts &str through TryFrom<&str>
    let post: Method = Method::try_from("POST").unwrap();
    assert_eq!(post, Method::POST);
    
    // The trait implementation enables generic code
    fn parse_method<T>(input: T) -> Result<Method, T::Error>
    where
        T: TryFrom<Method>,
        T::Error: std::fmt::Debug,
    {
        // This is contrived - showing trait usage
        unimplemented!()
    }
    
    // More realistic: using TryFrom bounds
    fn generic_parse<S>(source: S) -> Option<Method>
    where
        S: AsRef<[u8]>,
    {
        Method::try_from(source.as_ref()).ok()
    }
    
    // Works with both string and byte sources
    assert_eq!(generic_parse("GET"), Some(Method::GET));
    assert_eq!(generic_parse(&b"POST"[..]), Some(Method::POST));
}

use http::Method;
 
fn when_from_bytes() {
    // Scenario 1: Parsing network data
    // HTTP requests come as byte streams
    fn parse_http_request_line(data: &[u8]) -> Option<Method> {
        // Find the first space
        let space_idx = data.iter().position(|&b| b == b' ')?;
        let method_bytes = &data[..space_idx];
        
        // from_bytes is natural here - you already have &[u8]
        Method::from_bytes(method_bytes).ok()
    }
    
    // Scenario 2: Working with &[u8] from any source
    fn process_bytes(data: &[u8]) -> Result<Method, String> {
        Method::from_bytes(data)
            .map_err(|e| format!("Invalid method: {:?}", e))
    }
    
    // Scenario 3: Zero-copy parsing from buffers
    fn from_buffer(buf: &[u8]) -> Option<Method> {
        let method_end = buf.iter().position(|&b| b == b' ')?;
        Method::from_bytes(&buf[..method_end]).ok()
    }
    
    // Key point: from_bytes avoids conversion to String
    // when you already have bytes
}

use http::Method;
use std::convert::TryFrom;
 
fn when_try_from() {
    // Scenario 1: Generic code with TryFrom bounds
    fn parse_from_input<T>(input: T) -> Result<Method, String>
    where
        T: TryInto<Method>,
        T::Error: std::fmt::Debug,
    {
        input.try_into().map_err(|e| format!("Invalid method: {:?}", e))
    }
    
    // Works with strings or bytes
    let method1 = parse_from_input("GET").unwrap();
    let method2 = parse_from_input(&b"POST"[..]).unwrap();
    
    // Scenario 2: Using ? operator in TryFrom context
    fn in_conversion_context(input: &[u8]) -> Result<Method, String> {
        Method::try_from(input).map_err(|_| "Invalid method".to_string())
    }
    
    // Scenario 3: Integrating with trait-based APIs
    trait FromRaw {
        type Output;
        type Error;
        fn from_raw(data: &[u8]) -> Result<Self::Output, Self::Error>;
    }
    
    impl FromRaw for Method {
        type Output = Method;
        type Error = String;
        
        fn from_raw(data: &[u8]) -> Result<Method, String> {
            Method::try_from(data)
                .map_err(|e| format!("Invalid method: {:?}", e))
        }
    }
}

use http::Method;
 
fn standard_methods() {
    // Both methods recognize standard HTTP methods
    let methods = [
        ("GET", Method::GET),
        ("POST", Method::POST),
        ("PUT", Method::PUT),
        ("DELETE", Method::DELETE),
        ("HEAD", Method::HEAD),
        ("OPTIONS", Method::OPTIONS),
        ("PATCH", Method::PATCH),
        ("CONNECT", Method::CONNECT),
        ("TRACE", Method::TRACE),
    ];
    
    for (name, expected) in methods {
        // from_bytes
        assert_eq!(Method::from_bytes(name.as_bytes()).unwrap(), expected);
        
        // try_from with bytes
        assert_eq!(Method::try_from(name.as_bytes()).unwrap(), expected);
        
        // try_from with &str
        assert_eq!(Method::try_from(name).unwrap(), expected);
    }
    
    // Standard methods are interned for efficiency
    // (They're static constants in the Method type)
}

use http::Method;
 
fn extension_methods() {
    // Extension methods: custom method names
    let custom = Method::from_bytes(b"MYCUSTOM").unwrap();
    
    // Extension methods are valid but not standard
    assert!(!custom.is_standard());  // Note: Method doesn't have is_standard
    // Extension methods are stored as strings internally
    
    // Both approaches work for extension methods
    let ext1 = Method::from_bytes(b"WEBDAV").unwrap();
    let ext2: Method = Method::try_from("WEBDAV").unwrap();
    
    assert_eq!(ext1, ext2);
    
    // Extension methods are case-sensitive
    let webdav1 = Method::from_bytes(b"WEBDAV").unwrap();
    let webdav2 = Method::from_bytes(b"webdav").unwrap();
    
    // These are different methods
    assert_ne!(webdav1, webdav2);
    
    // Method names must be valid tokens per HTTP spec
    // Valid: uppercase letters, digits, some special chars
    let valid = Method::from_bytes(b"MY-METHOD.V2").unwrap();
    
    // Invalid: spaces, control chars, etc.
    assert!(Method::from_bytes(b"MY METHOD").is_err());
    assert!(Method::from_bytes(b"GET\r\n").is_err());
}

use http::Method;
use std::convert::TryFrom;
 
fn error_handling() {
    // from_bytes returns Result<Method, InvalidMethod>
    let result = Method::from_bytes(b"INVALID METHOD");
    
    // InvalidMethod is a struct from http crate
    match result {
        Ok(method) => println!("Got method: {}", method),
        Err(e) => {
            // InvalidMethod implements Display and Error
            println!("Invalid method: {}", e);
        }
    }
    
    // try_from returns Result<Method, InvalidMethod> as well
    let result2: Result<Method, _> = Method::try_from(b"BAD METHOD".as_slice());
    
    // Both return the same error type
    // InvalidMethod contains the invalid bytes for debugging
    
    // Common validation pattern:
    fn validate_method(bytes: &[u8]) -> Result<Method, String> {
        Method::from_bytes(bytes)
            .map_err(|e| format!("Invalid HTTP method: {}", e))
    }
    
    // Or using try_from:
    fn validate_method_trait(input: &str) -> Result<Method, String> {
        Method::try_from(input)
            .map_err(|e| format!("Invalid HTTP method: {}", e))
    }
}

use http::Method;
 
fn validation_rules() {
    // HTTP method names must be valid "tokens"
    // Per RFC 7230, tokens are:
    // - One or more characters
    // - From the set: A-Z, a-z, 0-9, and ! # $ % & ' * + - . ^ _ ` | ~
    
    // Valid methods
    assert!(Method::from_bytes(b"GET").is_ok());
    assert!(Method::from_bytes(b"POST").is_ok());
    assert!(Method::from_bytes(b"CUSTOM-METHOD").is_ok());
    assert!(Method::from_bytes(b"MY.METHOD").is_ok());
    assert!(Method::from_bytes(b"METHOD_V2").is_ok());
    
    // Invalid methods
    assert!(Method::from_bytes(b"").is_err());           // Empty
    assert!(Method::from_bytes(b"GET POST").is_err());   // Space
    assert!(Method::from_bytes(b"GET\tPOST").is_err());  // Tab
    assert!(Method::from_bytes(b"GET:POST").is_err());   // Colon
    assert!(Method::from_bytes(b"GET\r\n").is_err());    // Control chars
    
    // Note: Case matters for extension methods
    // Standard methods are compared case-insensitively for equality
    // But method names should be uppercase by convention
    
    // Both from_bytes and try_from enforce the same rules
}

use http::Method;
 
fn hyper_integration() {
    // In hyper, methods come from parsing HTTP requests
    // The parser uses from_bytes internally
    
    // When building a Request:
    fn build_request(method: &str, path: &str) -> Result<String, String> {
        // Validate method early
        let _ = Method::from_bytes(method.as_bytes())
            .map_err(|e| format!("Invalid method: {}", e))?;
        
        Ok(format!("{} {} HTTP/1.1\r\n", method, path))
    }
    
    // When parsing from raw bytes:
    fn parse_request(raw: &[u8]) -> Option<(Method, &[u8])> {
        let space_pos = raw.iter().position(|&b| b == b' ')?;
        let method_bytes = &raw[..space_pos];
        let method = Method::from_bytes(method_bytes).ok()?;
        
        // Parse remaining parts...
        Some((method, &raw[space_pos + 1..]))
    }
    
    // The Method type is used throughout hyper's API:
    // - Request<Body>::new(Method, Uri)
    // - Request::method() -> &Method
    // - Method implements Into<Method> for standard methods
}

use http::Method;
use std::str::FromStr;
 
fn method_type() {
    // Method represents HTTP methods efficiently
    // Standard methods are static constants
    // Extension methods are heap-allocated strings
    
    let get1 = Method::GET;  // Static constant
    let get2 = Method::from_bytes(b"GET").unwrap();  // Returns same
    
    assert_eq!(get1, get2);
    
    // Method implements useful traits:
    // - Clone, Copy (efficient for standard methods)
    // - Debug, Display
    // - Eq, Hash
    // - FromStr
    // - TryFrom<&[u8]>, TryFrom<&str>
    
    // FromStr is another way to parse:
    let from_str: Method = "GET".parse().unwrap();
    assert_eq!(from_str, Method::GET);
    
    // FromStr uses the same validation as from_bytes/try_from
    // It's essentially: Method::from_bytes(s.as_bytes())
    
    // Display shows the method name:
    println!("Method: {}", Method::POST);  // "POST"
    println!("Method: {}", Method::from_bytes(b"CUSTOM").unwrap());  // "CUSTOM"
}

use http::Method;
 
fn performance() {
    // from_bytes with standard methods:
    // - O(1) comparison to known constants
    // - Returns reference to static Method
    
    // from_bytes with extension methods:
    // - Validates the bytes
    // - Allocates a String internally
    // - Returns Method containing Arc<str> or similar
    
    // from_bytes avoids intermediate String allocation:
    fn parse_raw_bytes(data: &[u8]) -> Option<Method> {
        Method::from_bytes(data).ok()  // Direct from bytes
    }
    
    // try_from with &str may allocate depending on implementation:
    fn parse_str(s: &str) -> Option<Method> {
        Method::try_from(s).ok()  // May convert to bytes first
    }
    
    // For standard methods, both are equivalent performance
    // For extension methods, from_bytes with raw bytes avoids
    // the UTF-8 validation step (Method validates internally)
    
    // When you already have bytes, from_bytes is most direct:
    let bytes_from_network: &[u8] = b"GET";
    let method = Method::from_bytes(bytes_from_network).unwrap();
    
    // When you have strings, either works:
    let string_input = "GET";
    let method1 = Method::from_bytes(string_input.as_bytes()).unwrap();
    let method2: Method = Method::try_from(string_input).unwrap();
}

use http::Method;
use std::convert::TryFrom;
 
fn complete_example() {
    // Scenario: Parse HTTP request line
    fn parse_request_line(line: &str) -> Option<(Method, &str, &str)> {
        let parts: Vec<&str> = line.splitn(3, ' ').collect();
        if parts.len() != 3 {
            return None;
        }
        
        // Parse method - try_from is natural with strings
        let method = Method::try_from(parts[0]).ok()?;
        
        // Parse URI and version
        let uri = parts[1];
        let version = parts[2];
        
        Some((method, uri, version))
    }
    
    // Scenario: Parse from network buffer
    fn parse_from_buffer(buffer: &[u8]) -> Option<(Method, usize)> {
        // Find end of method (first space)
        let space_idx = buffer.iter().position(|&b| b == b' ')?;
        
        // from_bytes is natural with buffer data
        let method = Method::from_bytes(&buffer[..space_idx]).ok()?;
        
        Some((method, space_idx))
    }
    
    // Usage
    let request_line = "GET /path HTTP/1.1";
    if let Some((method, uri, version)) = parse_request_line(request_line) {
        println!("Method: {}, URI: {}, Version: {}", method, uri, version);
    }
    
    let buffer = b"POST /api/data HTTP/1.1\r\n";
    if let Some((method, idx)) = parse_from_buffer(buffer) {
        println!("Parsed method: {} at position {}", method, idx);
    }
}

use http::Method;
use std::convert::TryFrom;
 
fn quick_reference() {
    let bytes: &[u8] = b"GET";
    let string: &str = "POST";
    
    // from_bytes: direct API for byte slices
    let method1 = Method::from_bytes(bytes).unwrap();
    
    // try_from: standard trait for generic code
    let method2: Method = Method::try_from(bytes).unwrap();
    let method3: Method = Method::try_from(string).unwrap();
    
    // FromStr: when you have &str and want .parse()
    let method4: Method = "GET".parse().unwrap();
    
    // All produce the same result:
    assert_eq!(method1, Method::GET);
    assert_eq!(method2, Method::GET);
    assert_eq!(method3, Method::POST);
    assert_eq!(method4, Method::GET);
    
    // When to use each:
    // - from_bytes: Network data, &[u8] from parsing
    // - try_from: Generic code with TryFrom bounds, &str input
    // - parse/FromStr: String parsing with idiomatic API
    
    // Error type:
    // Both return Result<Method, InvalidMethod>
    // InvalidMethod implements std::error::Error
    
    // Key difference:
    // - from_bytes: Method::from_bytes(&[u8]) -> Result<Method, InvalidMethod>
    // - try_from: impl TryFrom<&[u8]> for Method
    // - try_from: impl TryFrom<&str> for Method
}
 
// Key insight:
// from_bytes is the direct API for &[u8] input.
// try_from is the trait-based API for generic code.
// Use from_bytes when parsing raw network data.
// Use try_from when working with strings or generic APIs.