// #![feature(if_let_guard)]

use std::{ collections::HashMap, path::PathBuf, sync::Arc };
use anyhow::Result;

use tokio::{
    fs::File,
    io::{ AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader },
    net::{ TcpListener, TcpStream },
};

mod utils;
use utils::*;

#[derive(Debug, Clone)]
struct Args {
    pub directory: Option<PathBuf>,
}

type A = Arc<Args>;


fn parse_args () -> Args {
    let directory = std::env::args()
        .position(|e| e == "--directory")
        .map(|e| e + 1)
        .map(|d| std::env::args().nth(d))
        .flatten()
        .map(|d| PathBuf::from(d));

    Args {
        directory
    }
}

#[tokio::main]
async fn main() -> Result<()> {
    let listener = TcpListener::bind("127.0.0.1:4221").await.unwrap();
    let args = Arc::new(parse_args());

    loop {
        let args = args.clone();
        let Ok((socket, info)) = listener.accept().await else { continue; } ;
        println!("Connection from {:?} accepted, processing…", info);
        let _ = process(socket, args).await;
    }

}


async fn process (mut stream: TcpStream, args: A) -> Result<()> {
    let buf_reader = BufReader::new(&mut stream);

    let mut data = buf_reader
        .lines();

    let (_method, path, _ver) = {
        let start_line = data.next_line().await?.ok_or(E::InvalidRequest)?; // should be 500;
        let mut parts = start_line.split_whitespace().map(ToOwned::to_owned);
        let method = parts.next().ok_or(E::InvalidRequest)?;
        let path   = parts.next().ok_or(E::InvalidRequest)?;
        let ver    = parts.next().ok_or(E::InvalidRequest)?;

        (method, path, ver)
    };

    let headers = Headers::parse(data.into_inner()).await;

    let response = match path.as_str() {
        "/" => Response::Empty,
        "/user-agent" => Response::TextPlain(headers.get("User-Agent").to_owned()),
        // p if let Some(echo) = p.strip_prefix("/echo/") => Response::TextPlain(echo), // a nicer way to do that, not available in stable yet
        p if p.starts_with("/echo/") => Response::TextPlain(p.trim_start_matches("/echo/").to_owned()),
        p if p.starts_with("/files/") => 'a : {
            let Some(path) = &args.directory else {
                break 'a Response::_500;
            };
            let path = path.join(p.trim_start_matches("/files/"));
            let Ok(mut f) = File::open(path).await else {
                break 'a Response::_404;
            };

            let mut buf = vec![];
            let _ = f.read_to_end(&mut buf).await;
            Response::OctetStream(buf)
        },
        _ => Response::_404,
    };

    let _ = stream.write_all(&response.build()).await;
    let _ = stream.flush().await;

    Ok(())
}

#[derive(Debug, Clone)]
pub struct Headers (HashMap<String, String>);

impl Headers {
    pub async fn parse (mut reader: BufReader<&'_ mut TcpStream>) -> Self {
        let mut map = HashMap::new();
        let mut buf = String::new();
        while let Ok(_) = reader.read_line(&mut buf).await {
            if let Some((k, v)) = buf.split_once(":") {
                map.insert(k.trim().to_lowercase(), v.trim().to_owned());
            } else {
                break;
            }

            buf.clear();
        }
        Self(map)
    }

    pub fn get <'a> (&'a self, key: &str) -> &'a str {
        self.0.get(&key.to_lowercase()).map(|e| e.as_str()).unwrap_or_default()
    }
}

#[derive(Debug, Clone)]
enum Response {
    _404,
    _500,
    Empty,
    TextPlain (String),
    OctetStream (Vec<u8>)
}


#[allow(non_upper_case_globals)]
impl Response {
    fn build (self) -> Vec<u8> {

        let headers = self.headers().join("\r\n");

        let code = match self {
            Self::_404 => "404 Not Found",
            Self::_500 => "500 Internal Server Error",
            _ => "200 OK",
        };

        let mut v: Vec<u8> = f!("HTTP/1.1 {code}\r\n{headers}\r\n\r\n").into();
        match self {
            Self::OctetStream(bytes) => {
                v.extend_from_slice(&bytes);
            },
            Self::TextPlain(text) => {
                v.extend_from_slice(text.as_bytes());
            },
            _ => ()
        }

        v
    }

    fn headers (&self) -> Vec<String> {
        match self {
            Self::TextPlain(text) => vec![f!("Content-Type: text/plain"), format!("Content-Length: {}", text.len())],
            Self::OctetStream(bytes) => vec![f!("Content-Type: application/octet-stream"), format!("Content-Length: {}", bytes.len())],
            _ => d!()
        }
    }
}