use std::{any::type_name_of_val, error::Error};

use http_body_util::{Either, Full};
use hyper::{
    body::{Body, Bytes, Incoming}, server::conn::http1, service::{HttpService, Service}, Request, Response, StatusCode
};
use hyper_util::rt::TokioIo;
use log::{error, info};
use tokio::net::{TcpListener, TcpStream};

pub type GeneralResponse = Response<GeneralBody>;
pub type GeneralBody = Either<Incoming, Full<Bytes>>;

pub fn to_general_response(res: Response<Incoming>) -> GeneralResponse {
    let (parts, body) = res.into_parts();
    Response::from_parts(parts, GeneralBody::Left(body))
}

pub struct Server<S> {
    listener: TcpListener,
    service: S,
}

pub trait TcpIntercept {
    fn stream(&mut self, stream: &TcpStream);
}

pub async fn default_response() -> GeneralResponse {
    Response::builder()
        .status(404)
        .body(GeneralBody::Right(Full::from(Bytes::from(
            "That route doesn't exist.",
        ))))
        .unwrap()
}

pub async fn custom_resp(e: StatusCode, m: &'static str) -> GeneralResponse {
    Response::builder()
        .status(e)
        .body(GeneralBody::Right(Full::from(Bytes::from(m))))
        .unwrap()
}

impl<S> Server<S>
where
    S: TcpIntercept,
    S: Service<Request<Incoming>> + Clone + Send + 'static,
    S: HttpService<Incoming> + Clone + Send,
    <S::ResBody as Body>::Error: Into<Box<dyn Error + Send + Sync>>,
    <S::ResBody as Body>::Data: Send,
    S::ResBody: Send,
    <S as HttpService<Incoming>>::Future: Send,
{
    pub async fn handle(&self) {
        info!(
            "Server started at http://{} for service: {}",
            self.listener.local_addr().unwrap(),
            type_name_of_val(&self.service)
        );

        loop {
            let (stream, _) = self.listener.accept().await.unwrap();

            let mut svc_clone = self.service.clone();
            svc_clone.stream(&stream);

            let io = TokioIo::new(stream);

            tokio::task::spawn(async move {
                if let Err(err) = http1::Builder::new()
                    .writev(false)
                    .serve_connection(io, svc_clone)
                    .await
                {
                    error!("Error while trying to serve connection: {err}")
                };
            });
        }
    }

    pub async fn new(service: S, a: (String, u16)) -> Result<Self, Box<dyn Error>> {
        Ok(Self {
            listener: TcpListener::bind(&a).await?,
            service,
        })
    }
}
/*
*/