// http://1.116.118.188:30211/@fs/app/src/handlers.rs?import&raw??
use crate::http_parser::Request;
use std::sync::Mutex;
use std::collections::HashMap;
use serde::{Deserialize, Serialize};
use lazy_static::lazy_static;
use uuid::Uuid;

lazy_static! {
    static ref USERS: Mutex<HashMap<String, UserRecord>> = Mutex::new(HashMap::new());

    static ref COMMENTS: Mutex<Vec<CommentData>> = Mutex::new(Vec::new());
}

#[derive(Deserialize)]
struct AuthRequest {
    username: String,
    password: String,
}

#[derive(Clone)]
struct UserRecord {
    password: String,
    token: String,
}

#[derive(Serialize, Deserialize, Clone)]
struct CommentData {
    username: String,
    content: String,
}

fn make_resp(status: &str, body: &str) -> String {
    format!(
        "HTTP/1.1 {}\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{}",
        status,
        body.len(),
        body
    )
}

fn resp_ok(msg: &str) -> String {
    make_resp("200 OK", msg)
}

pub fn resp_err(status: &str, msg: &str) -> String {
    make_resp(status, &format!(r#"{{"error": "{}"}}"#, msg))
}

pub fn handle_register(req: &Request) -> String {
    if req.method != "POST" {
        return resp_err("405 Method Not Allowed", "Only POST");
    }

    let content_type = req.headers.get("content-type").map(|s| s.as_str()).unwrap_or("");
    let form: AuthRequest = if content_type.contains("application/json") {
        match req.parse_json() {
            Ok(d) => d,
            Err(_) => return resp_err("400 Bad Request", "Invalid JSON format"),
        }
    } else if content_type.contains("application/x-www-form-urlencoded") {
        let map = req.parse_form();

        let username = map.get("username").cloned().unwrap_or_default();
        let password = map.get("password").cloned().unwrap_or_default();

        if username.is_empty() || password.is_empty() {
            return resp_err("400 Bad Request", "Missing username or password");
        }

        AuthRequest { username, password }
    } else {
        return resp_err("415 Unsupported Media Type", "Content-Type must be json or form");
    };

    let mut db = USERS.lock().unwrap();
    if db.contains_key(&form.username) {
        return resp_err("409 Conflict", "User already exists");
    }
    let new_token = Uuid::new_v4().to_string();
    db.insert(
        form.username.clone(),
        UserRecord {
            password: form.password,
            token: new_token.clone(),
        },
    );
    println!("User registered: {} with token: {}", form.username, new_token);

    resp_ok(&format!(
        r#"{{"status": "registered", "token": "{}"}}"#,
        new_token
    ))
}

pub fn handle_login(req: &Request) -> String {
    if req.method != "POST" {
        return resp_err("405 Method Not Allowed", "Only POST");
    }

    let content_type = req.headers.get("content-type").map(|s| s.as_str()).unwrap_or("");
    let form: AuthRequest = if content_type.contains("application/json") {
        match req.parse_json() {
            Ok(d) => d,
            Err(_) => return resp_err("400 Bad Request", "Invalid JSON format"),
        }
    } else if content_type.contains("application/x-www-form-urlencoded") {
        let map = req.parse_form();

        let username = map.get("username").cloned().unwrap_or_default();
        let password = map.get("password").cloned().unwrap_or_default();

        if username.is_empty() || password.is_empty() {
            return resp_err("400 Bad Request", "Missing username or password");
        }

        AuthRequest { username, password }
    } else {
        return resp_err("415 Unsupported Media Type", "Content-Type must be json or form");
    };

    let db = USERS.lock().unwrap();

    if let Some(record) = db.get(&form.username) {
        if record.password == form.password {
            return resp_ok(&format!(
                r#"{{"status": "success", "token": "{}"}}"#,
                record.token
            ));
        }
    }

    resp_err("401 Unauthorized", "Invalid credentials")
}

pub fn handle_comment(req: &Request) -> String {
    let auth_header = req.headers.get("authorization").map(|v| v.as_str());
    if auth_header.is_none() {
        return resp_err("401 Unauthorized", "Missing Authorization header");
    }
    let input_token = auth_header.unwrap();
    let mut current_user = String::new();
    {
        let db = USERS.lock().unwrap();
        for (username, record) in db.iter() {
            if record.token == input_token {
                current_user = username.clone();
                break;
            }
        }
    }

    if current_user.is_empty() {
        return resp_err("403 Forbidden", "Invalid Token");
    }

    match req.method.as_str() {
        "GET" => {
            let db = COMMENTS.lock().unwrap();
            let json = serde_json::to_string(&*db).unwrap_or("[]".to_string());
            resp_ok(&json)
        }

        "POST" => {
            #[derive(Deserialize)]
            struct NewComment {
                content: String,
            }

            let content_type = req.headers.get("content-type").map(|s| s.as_str()).unwrap_or("");
            let new_comment: NewComment = if content_type.contains("application/json") {
                match req.parse_json() {
                    Ok(p) => p,
                    Err(_) => return resp_err("400 Bad Request", "Invalid JSON"),
                }
            } else if content_type.contains("application/x-www-form-urlencoded") {
                let map = req.parse_form();

                let content = map.get("content").cloned().unwrap_or_default();

                if content.is_empty() {
                    return resp_err("400 Bad Request", "Missing content");
                }

                NewComment { content }
            } else {
                return resp_err("415 Unsupported Media Type", "Content-Type must be json or form");
            };

            let mut comments = COMMENTS.lock().unwrap();

            println!("[HANDLER] Saving comment: {:?}", new_comment.content);

            comments.push(CommentData {
                username: current_user,
                content: new_comment.content,
            });

            resp_ok(r#"{"status": "comment added"}"#)
        }
        _ => resp_err("405 Method Not Allowed", "Method not supported"),
    }
}

pub fn resp_not_found() -> String {
    resp_err("404 Not Found", "Resource not found")
}

// http://1.116.118.188:30211/@fs/app/src/main.rs?import&raw??
mod http_parser;
mod handlers;

use bytes::{Buf, BytesMut};
use http_parser::ParseResult;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::{TcpListener, TcpStream};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let listener = TcpListener::bind("0.0.0.0:3000").await?;
    println!("server running on 127.0.0.1:3000");

    loop {
        let (socket, _) = listener.accept().await?;

        tokio::spawn(async move {
            if let Err(e) = process_connection(socket).await {
                eprintln!("Connection error: {}", e);
            }
        });
    }
}

async fn process_connection(mut socket: TcpStream) -> Result<(), Box<dyn std::error::Error>> {
    let mut buffer = BytesMut::with_capacity(4096);

    loop {
        let n = socket.read_buf(&mut buffer).await?;

        if n == 0 {
            if buffer.is_empty() {
                return Ok(());
            } else {
                eprintln!(
                    "Connection closed with {} bytes remaining (garbage)",
                    buffer.len()
                );
                return Ok(());
            }
        }

        loop {
            match http_parser::parse_packet(&mut buffer) {
                ParseResult::Complete(req, consumed_len) => {
                    println!("Parsed request: {} {}", req.method, req.route);
                    let response = router(&req);
                    socket.write_all(response.as_bytes()).await?;
                    buffer.advance(consumed_len);
                }

                ParseResult::Partial => {
                    break;
                }

                ParseResult::Invalid(skip_len) => {
                    println!("Warning: Skipping {} bytes of garbage data...", skip_len);
                    buffer.advance(skip_len);

                    if buffer.is_empty() {
                        break;
                    }
                }
            }
        }
    }
}

fn router(req: &http_parser::Request) -> String {
    if req.version != "HTTP/1.1" {
        return handlers::resp_err(
            "400 Bad Request",
            "Wrong HTTP Version. Only HTTP/1.1 is supported.",
        );
    }

    if !req.queries.is_empty() {
        println!("  -> Query params: {:?}", req.queries);
    }

    match req.route.as_str() {
        "/api/register" => handlers::handle_register(req),
        "/api/login" => handlers::handle_login(req),
        "/api/comment" => handlers::handle_comment(req),
        _ => handlers::resp_not_found(),
    }
}

// http://1.116.118.188:30211/@fs/app/src/http_parser.rs?import&raw??
use bytes::BytesMut;
use serde::Deserialize;
use std::{collections::HashMap, str};

#[derive(Debug)]
pub struct Request {
    pub method: String,
    pub route: String,
    pub queries: HashMap<String, String>,
    pub version: String,
    pub headers: HashMap<String, String>,
    pub body: String,
}

pub enum ParseResult {
    Complete(Request, usize),
    Partial,
    Invalid(usize),
}

impl Request {
    pub fn parse_form(&self) -> HashMap<String, String> {
        let mut map = HashMap::new();
        for pair in self.body.split('&') {
            if let Some((k, v)) = pair.split_once('=') {
                if !k.is_empty() {
                    map.insert(k.to_string(), v.to_string());
                }
            } else if !pair.is_empty() {
                map.insert(pair.to_string(), "".to_string());
            }
        }
        map
    }

    pub fn parse_json<T: for<'a> Deserialize<'a>>(&self) -> Result<T, serde_json::Error> {
        serde_json::from_str(&self.body)
    }
}

pub fn parse_packet(buffer: &mut BytesMut) -> ParseResult {
    let req_line_end = match buffer.windows(2).position(|w| w == b"\r\n") {
        Some(pos) => pos,
        None => return ParseResult::Partial,
    };

    let req_line_len = req_line_end + 2;

    let raw_req_line = match str::from_utf8(&buffer[..req_line_end]) {
        Ok(s) => s,
        Err(_) => return ParseResult::Invalid(req_line_len),
    };

    let (method, route, queries, version) = match parse_reqline(raw_req_line) {
        Some(res) => res,
        None => return ParseResult::Invalid(req_line_len),
    };

    let header_end = match buffer.windows(4).position(|w| w == b"\r\n\r\n") {
        Some(pos) => pos,
        None => return ParseResult::Partial,
    };

    let raw_headers = match str::from_utf8(&buffer[req_line_len..header_end]) {
        Ok(s) => s,
        Err(_) => return ParseResult::Invalid(header_end + 4),
    };
    let headers = parse_headers(raw_headers);

    let body_length: usize = headers
        .get("content-length")
        .and_then(|v| v.parse().ok())
        .unwrap_or(0);

    let total_len = header_end + 4 + body_length;
    if buffer.len() < total_len {
        return ParseResult::Partial;
    }

    let body_start = header_end + 4;
    let body_end = body_start + body_length;
    let body = str::from_utf8(&buffer[body_start..body_end])
        .unwrap_or("")
        .to_string();

    ParseResult::Complete(
        Request {
            method,
            route,
            queries,
            version,
            headers,
            body,
        },
        total_len,
    )
}

fn parse_headers(raw_headers: &str) -> HashMap<String, String> {
    let lines = raw_headers.lines();
    let mut headers: HashMap<String, String> = HashMap::new();
    for line in lines {
        if let Some((k, v)) = line.split_once(":") {
            if !k.is_empty() {
                headers.insert(k.trim().to_lowercase(), v.trim().to_string());
            }
        }
    }
    headers
}

fn parse_reqline(raw_req_line: &str) -> Option<(String, String, HashMap<String, String>, String)> {
    let mut raw_req_parts = raw_req_line.split_whitespace();
    let method = raw_req_parts.next()?.to_string();
    let raw_uri = raw_req_parts.next()?;
    let (path, queries) = parse_uri(raw_uri);
    let version = raw_req_parts.next()?.to_string();
    Some((method, path, queries, version))
}

fn parse_uri(raw_uri: &str) -> (String, HashMap<String, String>) {
    let (path, raw_query) = match raw_uri.split_once("?") {
        Some((p, q)) => (p, q),
        None => (raw_uri, ""),
    };

    let mut queries: HashMap<String, String> = HashMap::new();

    if !raw_query.is_empty() {
        for query in raw_query.split("&") {
            if query.is_empty() {
                continue;
            }

            let (k, v) = match query.split_once("=") {
                Some((k, v)) => (k, v),
                None => (query, ""),
            };

            if !k.is_empty() {
                queries.insert(k.to_string(), v.to_string());
            }
        }
    }
    (path.to_string(), queries)
}

ParseResult::Invalid(skip_len) => {
    println!("Warning: Skipping {} bytes of garbage data...", skip_len);
    buffer.advance(skip_len);

    if buffer.is_empty() {
        break;
    }
}

ParseResult::Partial => {
    break;
}

if args.len() > 1 && args[1] == "--version" {
        println!("{}", VERSION);
        return;
    }

#[cfg(feature = "ssr")]
async fn get_new_version() -> Option<Version> {
    use tokio::process::Command;

    let output = Command::new("./update/easyuu")
        .arg("--version")
        .output()
        .await
        .ok()?;

    let version_str = String::from_utf8(output.stdout).ok()?.trim().to_string();
    Version::parse(&version_str).ok()
}

#[cfg(feature = "ssr")]
async fn update() -> Result<(), Box<dyn std::error::Error>> {
    let new_binary = "./update/easyuu";
    self_replace::self_replace(&new_binary)?;
    // fs::remove_file(&new_binary)?;
    Ok(())
}

Some("path1") => {
    if let Ok(p) = field.text().await {
        base_dir = PathBuf::from(p);
    }
    continue;
}