codecrafters submit [skip ci]

1 files changed, 176 insertions, 92 deletions

diff --git a/src/main.rs b/src/main.rs
index 1ad6f26..ccdaa37 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,15 +1,128 @@
 #![allow(unused)]
+use http_server_starter_rust::router::Router;
 use itertools::Itertools;
 use std::collections::HashMap;
+use std::fs::File;
 use std::io::{self, Read, Write};
 use std::net::{TcpListener, TcpStream};
-use std::{str, thread};
+use std::str::Utf8Error;
+use std::sync::{Arc, Mutex};
+use std::{str, thread, usize};
 
-use http_server_starter_rust::http_types::*;
 use http_server_starter_rust::request::*;
 use http_server_starter_rust::response::*;
+use http_server_starter_rust::{extractor, http_types::*};
 
-fn handle_client(mut stream: TcpStream) {
+fn read_file_as_bytes(path: &str) -> io::Result<Vec<u8>> {
+    // Open the file in read-only mode
+    let mut file = File::open(path)?;
+
+    // Create a buffer to hold the file contents
+    let mut buffer = Vec::new();
+
+    // Read the file contents into the buffer
+    file.read_to_end(&mut buffer)?;
+
+    // Return the buffer
+    Ok(buffer)
+}
+
+fn handle_echo(request: &Request, ctx: Option<&HashMap<String, String>>) -> Response {
+    let mut headers = HashMap::new();
+    // Extract the route regardless of the variant
+    let mut echo_string = "".to_string();
+    let route = match request.method() {
+        Method::Get(route) | Method::Post(route) | Method::Put(route) => route,
+    };
+
+    for ch in route.chars().skip(1).skip_while(|&ch| ch != '/').skip(1) {
+        echo_string.push(ch);
+    }
+    if echo_string.chars().last().unwrap() == '/' {
+        echo_string.pop();
+    }
+    let len = echo_string.len().to_string();
+    headers.insert("Content-Type".to_string(), "text/plain".to_string());
+    headers.insert("Content-Length".to_string(), len);
+    let body = echo_string;
+    Response::new(
+        "1.1".to_string(),
+        StatusCode::Ok,
+        Some(Headers(headers)),
+        Some(body),
+    )
+}
+
+fn handle_files(request: &Request, ctx: Option<&HashMap<String, String>>) -> Response {
+    // Extract the route regardless of the variant
+    let mut file = "".to_string();
+    let route = match request.method() {
+        Method::Get(route) | Method::Post(route) | Method::Put(route) => route,
+    };
+
+    let mut directory = ctx.unwrap().get(&"dir".to_string()).unwrap().clone();
+    directory.pop(); // remove last slash
+
+    for ch in route.chars().skip(1).skip_while(|&ch| ch != '/') {
+        file.push(ch);
+    }
+    if file.chars().last().unwrap() == '/' {
+        file.pop();
+    }
+    let len = file.len().to_string();
+
+    let full_path = &(directory + &file);
+    dbg!(full_path);
+
+    match read_file_as_bytes(full_path) {
+        Ok(bytes) => {
+            let mut headers = HashMap::new();
+            headers.insert(
+                "Content-Type".to_string(),
+                "application/octet-stream".to_string(),
+            );
+            headers.insert("Content-Length".to_string(), bytes.len().to_string());
+            let body = String::from_utf8(bytes).unwrap();
+            Response::new(
+                "1.1".to_string(),
+                StatusCode::Ok,
+                Some(Headers(headers)),
+                Some(body),
+            )
+        }
+        Err(_) => Response::new("1.1".to_string(), StatusCode::NotFound, None, None),
+    }
+}
+
+fn handle_user_agent(request: &Request, ctx: Option<&HashMap<String, String>>) -> Response {
+    let mut headers = HashMap::new();
+    let user_agent = request.get_tag("User-Agent".to_string());
+    let len = user_agent.len().to_string();
+    headers.insert("Content-Type".to_string(), "text/plain".to_string());
+    headers.insert("Content-Length".to_string(), len);
+    let body = user_agent.to_string();
+    Response::new(
+        "1.1".to_string(),
+        StatusCode::Ok,
+        Some(Headers(headers)),
+        Some(body),
+    )
+    .into()
+}
+
+fn handle_success(request: &Request, ctx: Option<&HashMap<String, String>>) -> Response {
+    Response::new("1.1".to_string(), StatusCode::Ok, None, None).into()
+}
+
+fn handle_not_found(request: Request, ctx: Option<&HashMap<String, String>>) -> Response {
+    Response::new("1.1".to_string(), StatusCode::NotFound, None, None).into()
+}
+
+fn serve(
+    mut stream: TcpStream,
+    router: Arc<Mutex<Router>>,
+    ctx: Arc<Mutex<HashMap<String, String>>>,
+) -> io::Result<usize> {
     // Buffer to store the data received from the client
     let mut buffer = [0; 512];
 
@@ -17,107 +130,78 @@ fn handle_client(mut stream: TcpStream) {
     match stream.read(&mut buffer) {
         Ok(_) => {
             // Convert buffer to a string and print the received data
-            if let Ok(request) = str::from_utf8(&buffer) {
-                println!("Received request: {}", request);
-                let request = Request::from(request);
-                println!("Request after parsing: {:?}", request);
-                let succses: String =
-                    Response::new("1.1".to_string(), StatusCode::Ok, None, None).into();
-                let succses = succses.as_bytes();
-
-                let not_found: String =
-                    Response::new("1.1".to_string(), StatusCode::NotFound, None, None).into();
-                let not_found = not_found.as_bytes();
-
-                match request.method {
-                    HTTPMethod::Get((endpoint, target)) => {
-                        match (endpoint.as_str(), target.as_str()) {
-                            ("", "") => match stream.write(succses) {
-                                Ok(_) => {
-                                    println!("Response sent successfully");
-                                }
-                                Err(e) => eprintln!("Failed to send response: {}", e),
-                            },
-                            ("echo", target) => {
-                                let mut headers = HashMap::new();
-                                headers
-                                    .insert("Content-Type".to_string(), "text/plain".to_string());
-                                headers.insert(
-                                    "Content-Length".to_string(),
-                                    (target.len() - 1).to_string(),
-                                );
-                                let body = target[0..target.len() - 1].to_string();
-                                let response: String = Response::new(
-                                    "1.1".to_string(),
-                                    StatusCode::Ok,
-                                    Some(Headers(headers)),
-                                    Some(body),
-                                )
-                                .into();
-                                dbg!(&response);
-                                let response = response.as_bytes();
-
-                                match stream.write(response) {
-                                    Ok(_) => {
-                                        println!("Response sent successfully");
-                                        println!("Hello echo");
-                                    }
-                                    Err(e) => eprintln!("Failed to send response: {}", e),
-                                }
-                            }
-                            ("user-agent", _) => {
-                                let mut headers = HashMap::new();
-                                let user_agent: String =
-                                    request.headers.unwrap().0.get("User-Agent").unwrap().into();
-                                headers
-                                    .insert("Content-Type".to_string(), "text/plain".to_string());
-                                headers.insert(
-                                    "Content-Length".to_string(),
-                                    user_agent.len().to_string(),
-                                );
-                                let body = user_agent;
-                                let response: String = Response::new(
-                                    "1.1".to_string(),
-                                    StatusCode::Ok,
-                                    Some(Headers(headers)),
-                                    Some(body),
-                                )
-                                .into();
-                                dbg!(&response);
-                                let response = response.as_bytes();
-
-                                match stream.write(response) {
-                                    Ok(_) => {
-                                        println!("Response sent successfully");
-                                        println!("Hello user-agent");
-                                    }
-                                    Err(e) => eprintln!("Failed to send response: {}", e),
-                                }
-                            }
-                            _ => match stream.write(not_found) {
-                                Ok(_) => println!("Response sent successfully"),
-                                Err(e) => eprintln!("Failed to send response: {}", e),
-                            },
-                        }
-                    }
-                    HTTPMethod::Post(_target) => todo!(),
-                    HTTPMethod::Put(_target) => todo!(),
+            match str::from_utf8(&buffer) {
+                Ok(request) => {
+                    use Method::*;
+                    println!("Received request:\n{}", request);
+                    let request_lines: Vec<&str> = request.split("\r\n").collect();
+                    let request = Request::from(request_lines);
+                    let request_string: String = (&request).into();
+
+                    println!("Request after parsing:\n{}", request_string);
+                    dbg!(&request.method);
+
+                    let response: String = {
+                        let router = router.lock().unwrap();
+                        let ctx = ctx.lock().unwrap();
+                        router.handle(&request, Some(&ctx)).into()
+                    };
+                    stream.write(response.as_bytes())
                 }
+                Err(_) => todo!(),
             }
         }
-        Err(e) => {
-            eprintln!("Failed to read from stream: {}", e);
-        }
+        Err(_) => todo!(),
     }
 }
 
 fn main() -> io::Result<()> {
+    // Collect the command-line arguments
+    let args: Vec<String> = std::env::args().collect();
+
+    let mut dir = "".to_string();
+
+    let ctx = Arc::new(Mutex::new(HashMap::new()));
+
+    // Check if the correct number of arguments are provided
+    if args.len() == 3 {
+        // Parse the arguments
+        if args[1] == "--directory" {
+            dir += &args[2];
+            println!("Directory: {}", dir);
+        } else {
+            eprintln!("Unknown argument: {}", args[1]);
+            eprintln!("Usage: {} --directory <path>", args[0]);
+            return Ok(());
+        }
+    } else {
+        eprintln!("Usage: {} --directory <path>", args[0]);
+    }
+
     let listener = TcpListener::bind("127.0.0.1:4221").unwrap();
 
+    let router = Arc::new(Mutex::new(Router::new()));
+    ctx.lock().unwrap().insert("dir".to_string(), dir);
+
+    {
+        let mut router = router.lock().unwrap();
+        router
+            .route(get("/"), handle_success)
+            .route(get("/echo/:var/"), handle_echo)
+            .route(get("/user-agent/"), handle_user_agent)
+            .route(get("/files/:file/"), handle_files);
+    }
+
     for stream in listener.incoming() {
         match stream {
             Ok(stream) => {
-                thread::spawn(move || handle_client(stream));
+                let router = Arc::clone(&router);
+                let ctx = Arc::clone(&ctx);
+                thread::spawn(move || {
+                    if let Err(e) = serve(stream, router, ctx) {
+                        eprintln!("Failed to serve connection: {}", e);
+                    }
+                });
             }
             Err(e) => {
                 eprintln!("error: {}", e);