use std::future::Future;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::time::Duration;

use dever_runtime::{bytes::Bytes, channel::Channel, http, net, task};

fn limits() -> http::Limits {
    http::Limits {
        header_bytes: 8192,
        body_bytes: 1024,
        timeout_ms: 1000,
        connections: 4,
        http2: None,
    }
}

fn run_test(test: impl Future<Output = Result<(), String>>) {
    task::run_entry_with(
        task::RuntimeConfig {
            worker_threads: 1,
            max_blocking_threads: 2,
            task_capacity: 32,
        },
        async {
            tokio::time::timeout(Duration::from_secs(8), test)
                .await
                .map_err(|_| "HTTP test deadline exceeded".to_owned())?
        },
    )
    .unwrap();
}

fn header(name: &str, value: &str) -> http::Header {
    http::Header {
        name: name.into(),
        value: Bytes::from_text(value),
    }
}

fn request() -> http::Request {
    http::Request {
        method: "GET".into(),
        target: "/".into(),
        headers: vec![header("host", "test")],
        body: Bytes::new(vec![]),
    }
}

fn response(body: Bytes) -> http::Response {
    http::Response {
        status: 200,
        headers: vec![],
        body,
    }
}

async fn server<F, Fut>(
    route: F,
    limits: http::Limits,
) -> Result<(task::Task<()>, net::Listener, i64), String>
where
    F: Fn(http::Request) -> Fut + Clone + Send + Sync + 'static,
    Fut: Future<Output = Result<http::Response, String>> + Send + 'static,
{
    let listener = net::listen("127.0.0.1", 0).await?;
    let port = net::port(&listener)?;
    let owned = listener.clone();
    let task = task::run(async move { http::serve(route, owned, limits).await }).await?;
    Ok((task, listener, port))
}

// 独立、只读的测试线协议观察器：按 Content-Length 保留下一条响应，不调用 Hyper。
struct Peer {
    socket: net::Socket,
    buffered: Vec<u8>,
}

impl Peer {
    async fn connect(port: i64) -> Result<Self, String> {
        let socket = net::connect_timeout("127.0.0.1", port, 2000).await?;
        net::timeout(&socket, 2000)?;
        Ok(Self {
            socket,
            buffered: vec![],
        })
    }

    async fn write(&self, wire: &[u8]) -> Result<(), String> {
        net::write(&self.socket, &Bytes::new(wire.to_vec())).await
    }

    async fn read_more(&mut self) -> Result<(), String> {
        let bytes = net::read(&self.socket, 4096)
            .await?
            .ok_or("unexpected HTTP EOF")?;
        self.buffered.extend_from_slice(bytes.values());
        Ok(())
    }

    async fn response(&mut self, head_only: bool) -> Result<(String, Vec<u8>), String> {
        let end = loop {
            if let Some(end) = self
                .buffered
                .windows(4)
                .position(|part| part == b"\r\n\r\n")
            {
                break end + 4;
            }
            self.read_more().await?;
        };
        let headers = String::from_utf8(self.buffered[..end].to_vec()).unwrap();
        let length = if head_only {
            0
        } else {
            headers
                .lines()
                .find_map(|line| {
                    let (name, value) = line.split_once(':')?;
                    name.eq_ignore_ascii_case("content-length")
                        .then(|| value.trim().parse::<usize>().unwrap())
                })
                .unwrap_or(0)
        };
        while self.buffered.len() < end + length {
            self.read_more().await?;
        }
        let body = self.buffered[end..end + length].to_vec();
        self.buffered.drain(..end + length);
        Ok((headers.to_ascii_lowercase(), body))
    }
}

#[test]
fn persistent_pipeline_preserves_chunked_binary_body_and_duplicate_headers() {
    run_test(async {
        let (server, listener, port) = server(
            |request| async move {
                if request.target == "/first" {
                    assert_eq!(request.body.values(), &[0, 255, b'x']);
                    let values: Vec<_> = request
                        .headers
                        .iter()
                        .filter(|header| header.name == "x-many")
                        .map(|header| header.value.values())
                        .collect();
                    assert_eq!(values, [b"one".as_slice(), &[0x80]]);
                }
                Ok(http::Response {
                    status: 200,
                    headers: vec![header("set-cookie", "a=1"), header("set-cookie", "b=2")],
                    body: request.body,
                })
            },
            limits(),
        )
        .await?;
        let mut peer = Peer::connect(port).await?;
        peer.write(b"POST /first HTTP/1.1\r\nHost: test\r\nX-Many: one\r\nX-Many: \x80\r\nTransfer-Encoding: chunked\r\n\r\n2\r\n\0\xff\r\n1\r\nx\r\n0\r\n\r\nPOST /next HTTP/1.1\r\nHost: test\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok").await?;
        let (headers, body) = peer.response(false).await?;
        assert!(headers.starts_with("http/1.1 200"));
        assert_eq!(headers.matches("set-cookie:").count(), 2);
        assert_eq!(body, [0, 255, b'x']);
        assert_eq!(peer.response(false).await?.1, b"ok");
        assert_eq!(net::read(&peer.socket, 1).await?, None);
        task::stop(server).await?;
        listener.close()?;
        Ok(())
    });
}

#[test]
fn head_and_no_content_responses_keep_next_message_aligned() {
    run_test(async {
        let (server, listener, port) = server(
            |request| async move {
                let mut result = response(Bytes::from_text("head representation"));
                if request.target == "/empty" {
                    result.status = 204;
                    result.body = Bytes::new(vec![]);
                }
                if request.target == "/reset" {
                    result.status = 205;
                    result.body = Bytes::new(vec![]);
                }
                if request.target == "/cached" {
                    result.status = 304;
                    result.body = Bytes::new(vec![]);
                }
                Ok(result)
            },
            limits(),
        )
        .await?;
        let mut peer = Peer::connect(port).await?;
        for (wire, status, head) in [
            (
                b"HEAD / HTTP/1.1\r\nHost: test\r\n\r\n".as_slice(),
                "200",
                true,
            ),
            (b"GET /empty HTTP/1.1\r\nHost: test\r\n\r\n", "204", false),
            (b"GET /reset HTTP/1.1\r\nHost: test\r\n\r\n", "205", false),
            (b"GET /cached HTTP/1.1\r\nHost: test\r\n\r\n", "304", false),
        ] {
            peer.write(wire).await?;
            let (headers, body) = peer.response(head).await?;
            assert!(
                headers.starts_with(&format!("http/1.1 {status}")),
                "{headers}"
            );
            assert!(body.is_empty());
        }
        task::stop(server).await?;
        listener.close()?;
        Ok(())
    });
}

#[test]
fn invalid_peers_and_limits_do_not_reach_the_handler_or_stop_the_server() {
    run_test(async {
        let calls = Arc::new(AtomicUsize::new(0));
        let observed = calls.clone();
        let mut budget = limits();
        budget.body_bytes = 4;
        let (server, listener, port) = server(
            move |_| {
                observed.fetch_add(1, Ordering::SeqCst);
                async { Ok(response(Bytes::new(vec![]))) }
            },
            budget,
        )
        .await?;
        let oversized = format!(
            "GET / HTTP/1.1\r\nHost: test\r\nX-Large: {}\r\n\r\n",
            "a".repeat(9000)
        );
        for (wire, status) in [
            (b"POST / HTTP/1.1\r\nHost: test\r\nContent-Length: 1\r\nContent-Length: 2\r\n\r\nx".as_slice(), "400"),
            (b"GET / HTTP/1.1\r\nHost: a\r\nHost: b\r\n\r\n", "400"),
            (b"POST / HTTP/1.1\r\nHost: test\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nabcde\r\n0\r\n\r\n", "413"),
            (b"POST / HTTP/1.1\r\nHost: test\r\nContent-Length: 5\r\n\r\n", "413"),
            (b"POST / HTTP/1.1\r\nHost: test\r\nTransfer-Encoding: chunked\r\n\r\n0\r\nX-Trailer: yes\r\n\r\n", "501"),
            (b"CONNECT test:80 HTTP/1.1\r\nHost: test\r\n\r\n", "501"),
            (b"GET / HTTP/1.1\r\nHost: test\r\nConnection: upgrade\r\nUpgrade: websocket\r\n\r\n", "501"),
            (oversized.as_bytes(), "431"),
        ] {
            let mut peer = Peer::connect(port).await?;
            peer.write(wire).await?;
            let (headers, _) = peer.response(false).await?;
            assert!(headers.starts_with(&format!("http/1.1 {status}")), "{headers}");
        }
        assert_eq!(calls.load(Ordering::SeqCst), 0);
        assert_eq!(
            http::send("127.0.0.1", port, request(), limits())
                .await?
                .status,
            200
        );
        assert_eq!(calls.load(Ordering::SeqCst), 1);
        task::stop(server).await?;
        listener.close()?;
        Ok(())
    });
}

struct Dropped(Arc<AtomicBool>);
impl Drop for Dropped {
    fn drop(&mut self) {
        self.0.store(true, Ordering::SeqCst);
    }
}

#[test]
fn stop_closes_active_connections_and_drains_handler_descendants() {
    run_test(async {
        let entered = Channel::new(1)?;
        let notify = entered.clone();
        let dropped = Arc::new(AtomicBool::new(false));
        let observed = dropped.clone();
        let (server, listener, port) = server(
            move |_| {
                let notify = notify.clone();
                let marker = Dropped(observed.clone());
                async move {
                    let child = task::run(async move {
                        let _marker = marker;
                        notify.send(()).await?;
                        std::future::pending::<()>().await;
                        Ok(())
                    })
                    .await?;
                    task::wait(child).await?;
                    Ok(response(Bytes::new(vec![])))
                }
            },
            limits(),
        )
        .await?;
        let peer = Peer::connect(port).await?;
        peer.write(b"GET / HTTP/1.1\r\nHost: test\r\n\r\n").await?;
        entered.receive().await?;
        task::stop(server).await?;
        assert!(dropped.load(Ordering::SeqCst));
        assert_eq!(net::read(&peer.socket, 1).await?, None);
        // serve 只释放自己的 listener 别名，调用者仍可决定资源生命周期。
        assert_eq!(net::port(&listener)?, port);
        listener.close()?;
        Ok(())
    });
}

#[test]
fn handler_fault_returns_500_and_keeps_the_accept_loop_running() {
    run_test(async {
        let (server, listener, port) = server(
            |request| async move {
                if request.target == "/fault" {
                    return Err("route fault".into());
                }
                Ok(response(Bytes::from_text("healthy")))
            },
            limits(),
        )
        .await?;
        let mut peer = Peer::connect(port).await?;
        peer.write(b"GET /fault HTTP/1.1\r\nHost: test\r\n\r\n")
            .await?;
        let (headers, body) = peer.response(false).await?;
        assert!(headers.starts_with("http/1.1 500"), "{headers}");
        assert!(body.is_empty());
        let healthy = http::send("127.0.0.1", port, request(), limits()).await?;
        assert_eq!(healthy.status, 200);
        assert_eq!(healthy.body.values(), b"healthy");
        task::stop(server).await?;
        listener.close()?;
        Ok(())
    });
}

#[test]
fn connection_capacity_backpressures_before_dispatching_another_request() {
    run_test(async {
        let entered = Channel::new(2)?;
        let release = Channel::new(2)?;
        let notify = entered.clone();
        let wait = release.clone();
        let calls = Arc::new(AtomicUsize::new(0));
        let observed = calls.clone();
        let mut budget = limits();
        budget.connections = 1;
        let (server, listener, port) = server(
            move |_| {
                let notify = notify.clone();
                let wait = wait.clone();
                let observed = observed.clone();
                async move {
                    observed.fetch_add(1, Ordering::SeqCst);
                    notify.send(()).await?;
                    wait.receive().await?;
                    Ok(response(Bytes::new(vec![])))
                }
            },
            budget,
        )
        .await?;
        let mut first = Peer::connect(port).await?;
        first
            .write(b"GET / HTTP/1.1\r\nHost: test\r\nConnection: close\r\n\r\n")
            .await?;
        entered.receive().await?;
        let mut second = Peer::connect(port).await?;
        second
            .write(b"GET / HTTP/1.1\r\nHost: test\r\nConnection: close\r\n\r\n")
            .await?;
        tokio::task::yield_now().await;
        assert_eq!(calls.load(Ordering::SeqCst), 1);
        release.send(()).await?;
        first.response(false).await?;
        entered.receive().await?;
        assert_eq!(calls.load(Ordering::SeqCst), 2);
        release.send(()).await?;
        second.response(false).await?;
        task::stop(server).await?;
        listener.close()?;
        Ok(())
    });
}

#[test]
fn header_body_and_handler_deadlines_release_the_connection() {
    run_test(async {
        let mut budget = limits();
        budget.timeout_ms = 100;
        let (server, listener, port) = server(
            |_| async {
                std::future::pending::<()>().await;
                Ok(response(Bytes::new(vec![])))
            },
            budget,
        )
        .await?;
        let peer = Peer::connect(port).await?;
        peer.write(b"GET / HTTP/1.1\r\nHost:").await?;
        // Hyper 对未完成的请求头超时直接关闭连接，没有可交给 handler 的请求。
        assert_eq!(net::read(&peer.socket, 1).await?, None);
        for (wire, expected) in [
            (
                b"POST / HTTP/1.1\r\nHost: test\r\nContent-Length: 2\r\n\r\nx".as_slice(),
                "408",
            ),
            (b"GET / HTTP/1.1\r\nHost: test\r\n\r\n", "504"),
        ] {
            let mut peer = Peer::connect(port).await?;
            peer.write(wire).await?;
            let (headers, _) = peer.response(false).await?;
            assert!(
                headers.starts_with(&format!("http/1.1 {expected}")),
                "{headers}"
            );
            assert_eq!(net::read(&peer.socket, 1).await?, None);
        }
        task::stop(server).await?;
        listener.close()?;
        Ok(())
    });
}

#[test]
fn client_accepts_chunked_and_eof_bodies_but_rejects_truncation_and_oversize() {
    run_test(async {
        for (wire, expected) in [
            (b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\nSet-Cookie: a=1\r\nSet-Cookie: b=2\r\n\r\n2\r\nok\r\n0\r\n\r\n".as_slice(), true),
            (b"HTTP/1.1 200 OK\r\nConnection: close\r\n\r\nok", true),
            (b"HTTP/1.1 200 OK\r\nContent-Length: 3\r\n\r\nok", false),
            (b"HTTP/1.1 200 OK\r\nContent-Length: 2048\r\n\r\n", false),
        ] {
            let listener = net::listen("127.0.0.1", 0).await?;
            let port = net::port(&listener)?;
            let peer = task::run(async move {
                let socket = net::accept(&listener).await?;
                net::timeout(&socket, 1000)?;
                let sent = net::read(&socket, 4096).await?.unwrap().to_text()?;
                assert!(sent.starts_with("GET / HTTP/1.1\r\n"));
                assert!(sent.contains("host: test\r\n"));
                for piece in wire.chunks(7) { net::write(&socket, &Bytes::new(piece.to_vec())).await?; tokio::task::yield_now().await; }
                Ok(())
            }).await?;
            let received = http::send("127.0.0.1", port, request(), limits()).await;
            if expected { assert_eq!(received?.body.values(), b"ok"); } else { assert!(received.is_err()); }
            task::wait(peer).await?;
        }
        Ok(())
    });
}

#[test]
fn invalid_outgoing_messages_and_configuration_fail_before_connecting() {
    run_test(async {
        for invalid in [
            header("x-test", "ok\r\ninjected: yes"),
            header("content-length", "0"),
            header("transfer-encoding", "chunked"),
        ] {
            let mut request = request();
            request.headers.push(invalid);
            let error = http::send("127.0.0.1", 0, request, limits())
                .await
                .unwrap_err();
            assert!(!error.contains("Connection refused"), "{error}");
        }
        let mut excessive = request();
        excessive.headers.extend(vec![header("x", ""); 32769]);
        assert_eq!(
            http::send("127.0.0.1", 0, excessive, limits())
                .await
                .unwrap_err(),
            "HTTP headers exceed header_bytes"
        );
        for budget in [
            http::Limits {
                header_bytes: 1,
                ..limits()
            },
            http::Limits {
                body_bytes: -1,
                ..limits()
            },
            http::Limits {
                timeout_ms: 0,
                ..limits()
            },
            http::Limits {
                connections: 0,
                ..limits()
            },
        ] {
            assert!(
                http::send("127.0.0.1", 0, request(), budget)
                    .await
                    .unwrap_err()
                    .starts_with("HTTP")
            );
        }
        Ok(())
    });
}

#[test]
fn invalid_handler_responses_return_500_and_keep_the_accept_loop_running() {
    run_test(async {
        for status in [99, 204, 205, 304, 600] {
            let (server, listener, port) = server(
                move |request| async move {
                    if request.target != "/invalid" {
                        return Ok(response(Bytes::from_text("healthy")));
                    }
                    Ok(http::Response {
                        status,
                        headers: vec![],
                        body: Bytes::from_text("invalid body"),
                    })
                },
                limits(),
            )
            .await?;
            let mut peer = Peer::connect(port).await?;
            peer.write(b"GET /invalid HTTP/1.1\r\nHost: test\r\n\r\n")
                .await?;
            let (headers, body) = peer.response(false).await?;
            assert_eq!(headers.split_whitespace().nth(1), Some("500"), "{headers}");
            assert!(headers.lines().any(|line| line == "connection: close"));
            assert!(body.is_empty());
            assert!(peer.buffered.is_empty());
            assert_eq!(net::read(&peer.socket, 1).await?, None);
            let healthy = http::send("127.0.0.1", port, request(), limits()).await?;
            assert_eq!(healthy.status, 200);
            assert_eq!(healthy.body.values(), b"healthy");
            listener.close()?;
            task::wait(server).await?;
        }
        Ok(())
    });
}

#[test]
fn client_timeout_and_stop_release_the_owned_connection_driver() {
    run_test(async {
        for stop in [false, true] {
            let listener = net::listen("127.0.0.1", 0).await?;
            let port = net::port(&listener)?;
            let received = Channel::new(1)?;
            let notify = received.clone();
            let peer = task::run(async move {
                let socket = net::accept(&listener).await?;
                net::timeout(&socket, 2000)?;
                assert!(net::read(&socket, 4096).await?.is_some());
                notify.send(()).await?;
                assert_eq!(net::read(&socket, 1).await?, None);
                Ok(())
            })
            .await?;
            let mut budget = limits();
            budget.timeout_ms = if stop { 1000 } else { 100 };
            let client = task::run(async move {
                let result = http::send("127.0.0.1", port, request(), budget).await;
                assert_eq!(result.unwrap_err(), "HTTP request timed out");
                Ok(())
            })
            .await?;
            received.receive().await?;
            if stop {
                task::stop(client).await?;
            } else {
                task::wait(client).await?;
            }
            task::wait(peer).await?;
        }
        Ok(())
    });
}

#[test]
fn a_stalled_writer_releases_its_connection_slot() {
    run_test(async {
        let mut budget = limits();
        budget.timeout_ms = 100;
        budget.connections = 1;
        budget.body_bytes = 16 * 1024 * 1024;
        let entered = Channel::new(1)?;
        let notify = entered.clone();
        let (server, listener, port) = server(
            move |request| {
                let notify = notify.clone();
                async move {
                    let body = if request.target == "/slow" {
                        notify.send(()).await?;
                        Bytes::new(vec![b'x'; 16 * 1024 * 1024])
                    } else {
                        Bytes::from_text("next")
                    };
                    Ok(response(body))
                }
            },
            budget,
        )
        .await?;
        let slow = Peer::connect(port).await?;
        slow.write(b"GET /slow HTTP/1.1\r\nHost: test\r\nConnection: close\r\n\r\n")
            .await?;
        entered.receive().await?;
        let mut next = Peer::connect(port).await?;
        next.write(b"GET /next HTTP/1.1\r\nHost: test\r\nConnection: close\r\n\r\n")
            .await?;
        assert_eq!(next.response(false).await?.1, b"next");
        task::stop(server).await?;
        listener.close()?;
        Ok(())
    });
}