use actix::prelude::*;

use axum::Router;

use jsonrpsee::server::serve_with_graceful_shutdown;

use lyquor_api::anyhow;

use lyquor_jsonrpc::client::ClientHandle;

use tokio::net::TcpListener;

use tokio_util::sync::CancellationToken;

mod jsonrpc;

pub use jsonrpc::{NewConsoleLines, Subscriptions};

pub struct HttpServer {

    bind_addr: String,

    jsonrpc: jsonrpc::JsonRpcContext,

    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, console_sub: Addr<Subscriptions>, fco: Addr<lyquor_seq::fco::FCO>,

        pool: Addr<crate::lyquid::LyquidPool>,

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

        let bind_addr = bind_addr.into();

        Ok(Self {

            bind_addr,

            jsonrpc: jsonrpc::JsonRpcContext::new(client, console_sub, pool, fco),

            shutdown: CancellationToken::new(),

            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 route_state = jsonrpc::JsonRpcRouteState::new(self.jsonrpc.clone(), self.shutdown.clone());

        let shutdown = self.shutdown.clone();

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

            run_http_server(bind_addr, route_state, 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(route_state: jsonrpc::JsonRpcRouteState) -> Router {

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

    // extends this function.

    jsonrpc::build_jsonrpc_router(route_state)

}

async fn run_http_server(bind_addr: String, route_state: jsonrpc::JsonRpcRouteState, shutdown: CancellationToken) {

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

        Ok(listener) => listener,

        Err(e) => {

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

            return;

        }

    };

    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(route_state.clone());

        let connection_shutdown = shutdown.clone();

        tokio::spawn(async move {

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

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

            }

        });

    }

}