pub mod atp;
pub mod did;
pub mod error;
pub mod keys;
pub mod oauth;
pub mod proxy;
pub mod store;

use atproto_identity::key::KeyData;
use atproto_identity::resolve::{HickoryDnsResolver, InnerIdentityResolver};
use atproto_identity::traits::IdentityResolver;
use std::path::PathBuf;
use std::sync::Arc;
use std::time::Duration;

#[derive(Clone)]
pub struct Config {
    pub base_url: String,
    pub did: String,
    pub signing_key: KeyData,
    pub db_path: PathBuf,
    pub plc_url: String,
}

#[derive(Clone)]
pub struct AppState {
    pub config: Arc<Config>,
    pub store: store::Store,
    pub http: reqwest::Client,
    pub resolver: Arc<dyn IdentityResolver>,
}

pub async fn state(config: Config) -> anyhow::Result<AppState> {
    let store = store::Store::open(&config.db_path)?;
    let http = reqwest::Client::builder()
        .redirect(atproto_identity::redirect::validated_policy())
        .connect_timeout(Duration::from_secs(10))
        .timeout(Duration::from_secs(60))
        .build()?;
    let inner = InnerIdentityResolver {
        dns_resolver: Arc::new(HickoryDnsResolver::create_resolver(&[])),
        http_client: http.clone(),
        plc_hostname: config.plc_url.clone(),
    };
    Ok(AppState {
        config: Arc::new(config),
        store,
        http,
        resolver: Arc::new(zkwid::resolver::DidKeyResolver { inner }),
    })
}

pub fn router(state: AppState) -> axum::Router {
    axum::Router::new()
        .merge(did::routes())
        .merge(oauth::routes())
        .merge(keys::routes())
        .merge(proxy::routes())
        .with_state(state)
}

pub async fn serve(state: AppState, listener: tokio::net::TcpListener) -> anyhow::Result<()> {
    axum::serve(listener, router(state)).await?;
    Ok(())
}