use actix::prelude::*;

use axum::Router;

use jsonrpsee::server::serve_with_graceful_shutdown;

use lyquor_api::anyhow;

use lyquor_image_store::OciDistributionStore;

use lyquor_jsonrpc::client::ClientHandle;

use std::sync::Arc;

use tokio::net::TcpListener;

use tokio_util::sync::CancellationToken;

pub mod httptls;

mod jsonrpc;

mod lyquid;

mod node;

mod oci;

pub use self::lyquid::LyquidServiceContext;

pub use self::node::NodeServiceContext;

pub struct HttpServer {

    bind_addr: String,

    jsonrpc: jsonrpc::JsonRpcContext,

    lyquid_service_context: Arc<lyquid::LyquidServiceContext>,

    node_service_context: Arc<node::NodeServiceContext>,

    oci: oci::OciRouteState,

    http_tls: Option<httptls::HttpTls>,

    shutdown: CancellationToken,

    task: Option<tokio::task::JoinHandle<()>>,

}

impl std::fmt::Debug for HttpServer {

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

        f.debug_struct("HttpServer")

            .field("bind_addr", &self.bind_addr)

            .finish()

    }

}

impl HttpServer {

    pub async fn new(

        bind_addr: &str, client: ClientHandle, fco: Addr<lyquor_seq::fco::FCO>, pool: Addr<crate::lyquid::LyquidPool>,

        node_service_context: NodeServiceContext, oci_store: Arc<dyn OciDistributionStore>,

        shutdown: CancellationToken, http_tls: Option<httptls::HttpTls>,

    ) -> Result<Self, anyhow::Error> {

        let bind_addr = bind_addr.into();

        Ok(Self {

            bind_addr,

            jsonrpc: jsonrpc::JsonRpcContext::new(client, pool.clone(), fco),

            lyquid_service_context: Arc::new(LyquidServiceContext::new(pool)),

            node_service_context: Arc::new(node_service_context),

            oci: oci::OciRouteState::new(oci_store),

            http_tls,

            shutdown,

            task: None,

        })

    }

    pub fn start(&mut self) {

        if self.task.is_some() {

            tracing::warn!("HttpServer already started.");

            return;

        }

        let bind_addr = self.bind_addr.clone();

        let jsonrpc_state = jsonrpc::JsonRpcRouteState::new(self.jsonrpc.clone(), self.shutdown.child_token());

        let lyquid_service_context = self.lyquid_service_context.clone();

        let node_service_context = self.node_service_context.clone();

        let oci_state = self.oci.clone();

        let shutdown = self.shutdown.child_token();

        let http_tls = self.http_tls.clone();

        self.task = Some(tokio::spawn(async move {

            run_http_server(

                bind_addr,

                jsonrpc_state,

                lyquid_service_context,

                node_service_context,

                oci_state,

                http_tls,

                shutdown,

            )

            .await;

        }));

    }

    pub fn stop(&self) {

        // Single shutdown signal for all HTTP/JSON-RPC tasks; cleanup is handled

        // by the token-driven tasks spawned in `start` and `JsonRpcRouteState::new`.

        self.shutdown.cancel();

    }

}

fn build_router(

    jsonrpc_state: jsonrpc::JsonRpcRouteState, lyquid_service_context: Arc<lyquid::LyquidServiceContext>,

    node_service_context: Arc<node::NodeServiceContext>, oci_state: oci::OciRouteState,

) -> Router {

    // Keep top-level router composition in mod.rs so adding REST APIs later only

    // extends this function.

    node::build_node_router(node_service_context)

        .merge(lyquid::build_lyquid_router(lyquid_service_context))

        .merge(oci::build_oci_router(oci_state))

        .merge(jsonrpc::build_jsonrpc_router(jsonrpc_state))

}

async fn run_http_server(

    bind_addr: String, jsonrpc_state: jsonrpc::JsonRpcRouteState,

    lyquid_service_context: Arc<lyquid::LyquidServiceContext>, node_service_context: Arc<node::NodeServiceContext>,

    oci_state: oci::OciRouteState, http_tls: Option<httptls::HttpTls>, shutdown: CancellationToken,

) {

    let listener = match TcpListener::bind(&bind_addr).await {

        Ok(listener) => listener,

        Err(e) => {

            tracing::error!("Failed to start HTTP server: {e:?}.");

            return;

        }

    };

    if let Some(tls) = &http_tls {

        tls.spawn_renewal_worker(shutdown.child_token());

    }

    // Don't change this line as it is parsed by tests.

    tracing::info!("API listening at {}", bind_addr);

    loop {

        let (socket, _remote) = tokio::select! {

            res = listener.accept() => match res {

                Ok(pair) => pair,

                Err(e) => {

                    tracing::error!("Failed to accept HTTP API connection: {e:?}.");

                    continue;

                }

            },

            _ = shutdown.cancelled() => break,

        };

        let app = build_router(

            jsonrpc_state.clone(),

            lyquid_service_context.clone(),

            node_service_context.clone(),

            oci_state.clone(),

        );

        let connection_shutdown = shutdown.child_token();

        let tls = {

            if let Some(ht) = &http_tls {

                ht.current_acceptor()

            } else {

                None

            }

        };

        // TODO: do we need to split TLS and non-TLS ports?

        tokio::spawn(async move {

            if let Some(tls) = tls {

                match tls.accept(socket).await {

                    Ok(tls_stream) => {

                        if let Err(e) =

                            serve_with_graceful_shutdown(tls_stream, app, connection_shutdown.cancelled()).await

                        {

                            tracing::debug!("HTTPS API connection error: {e:?}.");

                        }

                    }

                    Err(e) => {

                        tracing::debug!("HTTPS handshake error: {e:?}.");

                    }

                }

            } else if let Err(e) = serve_with_graceful_shutdown(socket, app, connection_shutdown.cancelled()).await {

                tracing::debug!("HTTP API connection error: {e:?}.");

            }

        });

    }

}