parser.rs

use crate::prelude::*;

use std::time::{Duration, Instant};

struct BoundarySearcher {
    pattern: Vec<u8>,
    skip_table: [usize; 256],
}

impl BoundarySearcher {
    fn new(pattern: Vec<u8>) -> Self {
        let pattern_len = pattern.len();
        let mut skip_table = [pattern_len; 256];

        // Build skip table (all except last character)
        for i in 0..pattern_len.saturating_sub(1) {
            skip_table[pattern[i] as usize] = pattern_len - 1 - i;
        }

        Self {
            pattern,
            skip_table,
        }
    }

    // Search from start position, returns position if found
    fn search(&self, haystack: &[u8], start: usize) -> Option<usize> {
        let pattern_len = self.pattern.len();
        let haystack_len = haystack.len();

        if start + pattern_len > haystack_len {
            return None;
        }

        let mut pos = start;
        let search_end = haystack_len - pattern_len;

        while pos <= search_end {
            // Check if pattern matches at current position
            let mut matches = true;
            for i in 0..pattern_len {
                if haystack[pos + i] != self.pattern[i] {
                    matches = false;
                    break;
                }
            }

            if matches {
                return Some(pos);
            }

            // Skip ahead using bad character rule
            let last_char = haystack[pos + pattern_len - 1];
            pos += self.skip_table[last_char as usize];
        }

        None
    }
}
pub fn parse_request_headers(headers_data: &[u8]) -> Result<HttpRequest, String> {
    let headers_str = str::from_utf8(headers_data).map_err(|_| "Invalid UTF-8 in headers")?;

    let mut lines = headers_str.lines();

    let request_line = lines.next().ok_or("Empty request")?;
    let mut request = parse_request_line(request_line)?;
    let mut current_header_name: Option<String> = None;
    let mut current_header_value = String::new();
    for line in lines {
        if line.trim().is_empty() {
            if let Some(name) = current_header_name.take() {
                request
                    .headers
                    .insert(name, current_header_value.trim().to_string());
                current_header_value.clear();
            }
            continue;
        }

        if line.starts_with(' ') || line.starts_with('\t') {
            if current_header_name.is_some() {
                current_header_value.push(' ');
                current_header_value.push_str(line.trim());
            } else {
                return Err(format!("Invalid continuation line: {}", line));
            }
        } else {
            if let Some(name) = current_header_name.take() {
                request
                    .headers
                    .insert(name, current_header_value.trim().to_string());
                current_header_value.clear();
            }
            parse_header_line(line, &mut current_header_name, &mut current_header_value)?;
        }
    }
    if let Some(name) = current_header_name.take() {
        request
            .headers
            .insert(name, current_header_value.trim().to_string());
    }

    if !request.headers.contains_key("host") {
        return Err("Missing Host header".to_string());
    }

    Ok(HttpRequest::new(
        request.method,
        request.uri,
        request.version,
        request.headers,
    ))
}
pub fn parse_multipart_body(body: &[u8], content_type: &str) -> Result<Vec<MultipartPart>, String> {
    let start_time = Instant::now();
    let timeout = Duration::from_secs(10);
    let boundary = extract_boundary(content_type)?;

    let initial_boundary = format!("--{}", boundary).into_bytes();
    let boundary_pattern = format!("\r\n--{}", boundary).into_bytes();
    let end_boundary = format!("\r\n--{}--", boundary).into_bytes();

    let boundary_searcher = BoundarySearcher::new(boundary_pattern.clone());
    let end_searcher = BoundarySearcher::new(end_boundary.clone());

    let mut parts = Vec::new();

    println!("Parsing multipart body with boundary: {}", boundary);
    println!("Body length: {}", body.len());
    if body.is_empty() {
        println!("Empty body received");
        return Err("Empty multipart body".to_string());
    }

    if start_time.elapsed() > timeout {
        println!("Timeout during multipart parsing setup");
        return Err("Timeout during multipart parsing setup".to_string());
    }

    if !body.starts_with(&initial_boundary) {
        println!("Missing initial boundary: expected --{}", boundary);
        return Err(format!("Missing initial boundary: expected --{}", boundary));
    }
    let mut current_pos = initial_boundary.len();

    if current_pos + 2 > body.len() || &body[current_pos..current_pos + 2] != b"\r\n" {
        println!(
            "Invalid data after initial boundary at pos {}: {:?}",
            current_pos,
            &body[current_pos..(current_pos + 10).min(body.len())]
        );
        return Err("Invalid data after initial boundary".to_string());
    }
    current_pos += 2;
    let time = Instant::now();
   loop {
        if start_time.elapsed() > timeout {
            println!("Timeout during multipart parsing loop at pos {}", current_pos);
            return Err("Timeout during multipart parsing loop".to_string());
        }
        
        if current_pos >= body.len() {
            break;
        }
        
        // Search for boundaries efficiently (single pass)
        let end_boundary_pos = end_searcher.search(body, current_pos);
        let next_boundary_pos = boundary_searcher.search(body, current_pos);
        
        // Determine which boundary comes first
        let (part_end, is_final, boundary_len) = match (next_boundary_pos, end_boundary_pos) {
            (Some(next), Some(end)) if end <= next => {
                println!("Found end boundary at position {}", end);
                (end, true, end_boundary.len())
            }
            (Some(next), _) => {
                println!("Found next boundary at position {}", next);
                (next, false, boundary_pattern.len())
            }
            (None, Some(end)) => {
                println!("Found end boundary at position {}", end);
                (end, true, end_boundary.len())
            }
            (None, None) => {
                println!(
                    "No closing boundary found at pos {}: searching in {:?}",
                    current_pos,
                    String::from_utf8_lossy(&body[current_pos..(current_pos + 100).min(body.len())])
                );
                return Err("No closing boundary found".to_string());
            }
        };
        
        let part_data = &body[current_pos..part_end];
        println!(
            "Processing part data (len={}): {:?}",
            part_data.len(),
            String::from_utf8_lossy(&part_data[..(100).min(part_data.len())])
        );
        
        // Find headers end efficiently
        let headers_end = find_double_crlf(part_data).ok_or_else(|| {
            println!(
                "Invalid part headers at pos {}: {:?}",
                current_pos,
                String::from_utf8_lossy(&part_data[..(100).min(part_data.len())])
            );
            "Invalid part headers"
        })?;
        
        let headers_str = std::str::from_utf8(&part_data[..headers_end]).map_err(|e| {
            println!("Invalid UTF-8 in part headers: {}", e);
            format!("Invalid UTF-8 in part headers: {}", e)
        })?;
        println!("Part headers (raw):\n{}", headers_str);
        
        let mut part = MultipartPart {
            name: String::new(),
            filename: None,
            content_type: None,
            data: Vec::new(),
        };
        
        // Parse headers
        let header_lines = headers_str
            .split("\r\n")
            .filter(|line| !line.trim().is_empty());
        
        for header in header_lines {
            println!("Processing header: '{}'", header);
            match parse_part_header(header) {
                Ok(Some((name, value))) => {
                    println!("Parsed header: {}: {}", name, value);
                    match name.to_lowercase().as_str() {
                        "content-disposition" => {
                            if let Some(name_val) = extract_disposition_param(&value, "name") {
                                println!("Set part.name: {}", name_val);
                                part.name = name_val;
                            }
                            if let Some(filename_val) = extract_disposition_param(&value, "filename") {
                                println!("Set part.filename: {}", filename_val);
                                part.filename = Some(filename_val);
                            }
                        }
                        "content-type" => {
                            println!("Set part.content_type: {}", value);
                            part.content_type = Some(value.to_string());
                        }
                        _ => println!("Ignoring unknown header: {}: {}", name, value),
                    }
                }
                Ok(None) => println!("Skipped header with no colon: '{}'", header),
                Err(e) => println!("Failed to parse header '{}': {}", header, e),
            }
        }
        
        if part.name.is_empty() {
            println!(
                "Missing name in Content-Disposition for part at pos {}",
                current_pos
            );
            return Err("Missing name in Content-Disposition".to_string());
        }
        
        let mut part_data_slice = &part_data[headers_end..];
        
        // Remove trailing CRLF before boundary
        if part_data_slice.ends_with(b"\r\n") {
            part_data_slice = &part_data_slice[..part_data_slice.len() - 2];
        }
        
        part.data = part_data_slice.to_vec();
        let part_name = part.name.clone();
        let part_filename = part.filename.clone();
        let part_data_len = part.data.len();
        
        parts.push(part);
        println!(
            "Added part: name={}, filename={:?}, data_len={}",
            part_name, part_filename, part_data_len
        );
        
        if is_final {
            println!("Reached end boundary, stopping parse");
            break;
        }
        
        // Move past the boundary
        current_pos = part_end + boundary_len;
        
        // Expect CRLF after boundary
        if current_pos + 2 <= body.len() && &body[current_pos..current_pos + 2] == b"\r\n" {
            current_pos += 2;
            println!("Advanced past CRLF after boundary, now at pos {}", current_pos);
        } else if current_pos >= body.len() {
            println!("Reached end of body at pos {}", current_pos);
            break;
        } else {
            println!(
                "Invalid data after boundary at pos {}: {:?}",
                current_pos,
                &body[current_pos..(current_pos + 10).min(body.len())]
            );
            return Err("Invalid data after boundary".to_string());
        }
    }
    let time2 = Instant::now();
    println!("{:?}", time2.duration_since(time));
    if parts.is_empty() {
        println!("No valid parts found in multipart data");
        return Err("No valid parts found in multipart data".to_string());
    }

    println!("Successfully parsed {} parts", parts.len());
    Ok(parts)
}

fn extract_boundary(content_type: &str) -> Result<String, String> {
    let parts: Vec<&str> = content_type.split(';').map(|s| s.trim()).collect();
    for part in parts {
        if let Some(boundary) = part.strip_prefix("boundary=") {
            let boundary = boundary.trim_matches('"').to_string();
            if boundary.is_empty() {
                return Err("Empty boundary in Content-Type".to_string());
            }
            println!("Extracted boundary: {}", boundary);
            return Ok(boundary);
        }
    }
    Err("No boundary found in Content-Type".to_string())
}

fn extract_disposition_param(disposition: &str, param: &str) -> Option<String> {
    let param_prefix = format!("{}=\"", param);
    let start = disposition.find(&param_prefix)?;
    let value_start = start + param_prefix.len();
    let value_end = disposition[value_start..]
        .find('"')
        .map(|pos| pos + value_start)
        .unwrap_or(disposition.len());
    let value = disposition[value_start..value_end].trim().to_string();
    if value.is_empty() {
        println!(
            "Empty value for param {} in disposition: '{}'",
            param, disposition
        );
        None
    } else {
        println!("Extracted {}: '{}'", param, value);
        Some(value)
    }
}

fn parse_part_header(header: &str) -> Result<Option<(String, String)>, String> {
    let header = header.trim();
    if header.is_empty() {
        println!("Skipping empty header");
        return Ok(None);
    }
    if let Some(colon_pos) = header.find(':') {
        let name = header[..colon_pos].trim().to_lowercase();
        let value = header[colon_pos + 1..].trim();
        if name.is_empty() {
            println!("Empty header name in: '{}'", header);
            return Err("Empty header name in multipart part".to_string());
        }
        Ok(Some((name, value.to_string())))
    } else {
        println!("No colon found in header: '{}'", header);
        Ok(None)
    }
}

fn parse_request_line(line: &str) -> Result<HttpRequest, String> {
    let parts: Vec<&str> = line.split_whitespace().collect();
    if parts.len() != 3 {
        return Err("Invalid request line format".to_string());
    }

    let method = parts[0].to_uppercase();
    let mut uri = parts[1].to_string();
    let version = parts[2].to_string();

    // Handle absolute URI
    if uri.starts_with("http://") || uri.starts_with("https://") {
        let pos = uri.find("://").unwrap_or_default();
        let after_scheme = &uri[pos + 3..];
        // Ensure there is a host part
        if after_scheme.is_empty() || after_scheme.starts_with('/') {
            return Err("Malformed absolute URI: missing host".to_string());
        }
        if let Some(slash_pos) = after_scheme.find('/') {
            uri = after_scheme[slash_pos..].to_string();
        } else {
            uri = "/".to_string();
        }
    }

    match method.as_str() {
        "GET" | "POST" | "PUT" | "DELETE" | "HEAD" | "OPTIONS" | "PATCH" => {}
        _ => {
            return Err(format!("Unsupported HTTP method: {}", method));
        }
    }

    if version != "HTTP/1.1" {
        return Err(format!("Only HTTP/1.1 is supported, got: {}", version));
    }

    Ok(HttpRequest::new(method, uri, version, HashMap::new()))
}

fn parse_header_line(
    line: &str,
    header_name: &mut Option<String>,
    header_value: &mut String,
) -> Result<(), String> {
    if let Some(colon_pos) = line.find(':') {
        let name = line[..colon_pos].trim().to_lowercase();
        let value = line[colon_pos + 1..].trim();
        if name.is_empty() {
            return Err("Empty header name".to_string());
        }
        *header_name = Some(name);
        *header_value = value.to_string();
        Ok(())
    } else {
        Err(format!("Invalid header format: {}", line))
    }
}

fn find_double_crlf(data: &[u8]) -> Option<usize> {
    if data.len() < 4 {
        return None;
    }
    
    let mut i = 0;
    let end = data.len() - 3;
    
    while i <= end {
        // Check for \r\n\r\n pattern
        if data[i] == b'\r'
            && data[i + 1] == b'\n'
            && data[i + 2] == b'\r'
            && data[i + 3] == b'\n'
        {
            return Some(i + 4);
        }
        i += 1;
    }
    
    None
}