mod routing;
mod services;

use routing::main_route;
use services::{
    database::{files::FileStorage, surreal::SurrealDb},
    runner::run,
};

use crate::services::{app::AppState, config::setup_config, tracing::setup_tracing};

#[tokio::main]
async fn main() {
    let config = setup_config();
    setup_tracing(&config.tracing);
    let auth_keys = (&config.auth_keys).try_into().expect("Missing PEMs");
    let surreal_db = SurrealDb::setup(&config.surreal_db)
        .await
        .expect("Failed to setup SurrealDb");
    let file_storage = FileStorage::setup(&config.file_storage)
        .await
        .expect("Failed to setup FileStorage");
    let state = AppState {
        auth_keys,
        surreal_db,
        file_storage,
    };
    run(config.app.url, main_route(&config).with_state(state)).await;
}

#[cfg(test)]
mod tests {
    use std::fs::OpenOptions;

    use crate::routing;
    use crate::services;
    use utoipa::OpenApi;
    use utoipauto::utoipauto;

    #[test]
    fn make_openapi_json() {
        #[utoipauto] // <===== Error here
        #[derive(OpenApi)]
        #[openapi(
            tags(
                (name = "todo", description = "chghckgj")
            )
        )]
        pub struct ApiDoc;
        let file = OpenOptions::new()
            .write(true)
            .truncate(true)
            .create(true)
            .open("openapi.json")
            .unwrap();
        serde_json::to_writer_pretty(file, &ApiDoc::openapi()).unwrap();
    }
}

#[utoipa::path(
    post,
    path = "/audio/delete",
    responses(
        (status = 200, description = "Delete listed audio samples successfully", body = DeleteSamplesRequest)
    )
)]
async fn delete_audio( <==== Add pub
    audio_repo: AudioRepository,
    _: Claims,
    ValidatedJson(data): ValidatedJson<DeleteSamplesRequest>,
) -> ResponseType<()> {
    let Ok(_) = audio_repo
        .delete_samples(data.ids)
        .await
        .map_err(|e| error!({error = ?e}, "Encountered an error while deleting a sample"))
    else {
        return ResponseType::Status(StatusCode::INTERNAL_SERVER_ERROR);
    };

    ResponseType::Status(StatusCode::OK)
}