use crate::router::xrpc::{
  XrpcEndpoint,
  XrpcHandler,
  QueryInput,
  ProcedureInput,
};
use axum::Router as AxumRouter;
use core::net::SocketAddr;
use std::net::{IpAddr, Ipv4Addr};
use tokio::net::TcpListener;

pub struct Router {
  addr: SocketAddr,
  router: AxumRouter,
}

// In case server ever needs to support more than just XRPC
pub enum Endpoint {
  Xrpc(XrpcEndpoint),
}
impl Endpoint {
  pub fn new_xrpc_query<Q>(nsid: String, query: Q) -> Self
  where
    Q: XrpcHandler<QueryInput> + Clone
  {
    Endpoint::Xrpc(XrpcEndpoint::new_query(nsid,query))
  }
  pub fn new_xrpc_procedure<P>(nsid: String, procedure: P) -> Self
  where
    P: XrpcHandler<ProcedureInput> + Clone
  {
    Endpoint::Xrpc(XrpcEndpoint::new_procedure(nsid,procedure))
  }
}

pub mod xrpc;

impl Router {
  pub fn new() -> Self {
    let mut router = AxumRouter::new();
    router = XrpcEndpoint::not_implemented().add_to_router(router);
    let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127,0,0,1)), 6702);
    Router { router, addr }
  }

  pub fn add_endpoint(mut self, endpoint: Endpoint) -> Self {
    match endpoint {
      Endpoint::Xrpc(ep) => self.router = ep.add_to_router(self.router),
    };
    self
  }

  pub async fn serve(self) {
    let listener = TcpListener::bind(self.addr).await.unwrap();

    axum::serve(listener, self.router).await.unwrap();
  }
}