#[derive(Serialize, Deserialize, Clone)]

#[derive(Serialize, Deserialize, Clone, Debug)]

#[derive(Debug)]

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

        write!(f, "{}", self.msg)

    }

    fn into_response(self) -> axum::response::Response {

        self.msg.into_response()

    }

async fn route_get_index() -> Result<Html<String>, MyError> {

    Ok(Html(String::new()))

}

async fn route_get_configuration(

    State(state): State<SharedState>,

) -> Result<Json<AnnotationServerConfig>, MyError> {

    let state = &mut state.read().unwrap();

    Ok(Json(state.config.clone()))

}

#[derive(Deserialize)]

async fn run_sparql(

    config: &AnnotationServerConfig,

    query_config: &QueryConfig,

    entity: &str,

) -> Result<String, MyError> {

    let query_path = config.assets_dir.join(&query_config.query_file);

    println!("reading {}", query_path.display());

    let query = read_to_string(&query_path).await.map_err(|_| MyError {

        msg: format!("could not read {}", query_path.display()),

    })?;

    let query = query.replace("%%ENTITY%%", entity);

    println!("querying: {}", config.sparql_endpoint);

    println!("{}", query);

    let mut url = Url::parse(&config.sparql_endpoint).unwrap();

    url.query_pairs_mut().append_pair("query", &query);

    let client = reqwest::Client::new();

    let res = client

        .get(url)

        .basic_auth(&config.sparql_user, Some(&config.sparql_password))

        .send()

        .await

        .unwrap();

    let status = res.status();

    let text = res.text().await.unwrap();

    if status != StatusCode::OK {

        return Err(MyError { msg: text });

    }

    println!("sparql result: {}", status);

    println!("sparql result: {}", text);

    Ok(text)

}

async fn run_template(

    config: &AnnotationServerConfig,

    query_config: &QueryConfig,

    sparql_output: String,

) -> Result<String, MyError> {

    let template_path = config.assets_dir.join(&query_config.template_file);

    let template = read_to_string(&template_path).await.map_err(|_| MyError {

        msg: format!("could not read {}", template_path.display()),

    })?;

    println!("template {}", template);

    let client = reqwest::Client::new();

    let res = client

        .post(&config.template_url)

        .form(&[("data", sparql_output), ("query", template)])

        .send()

        .await

        .unwrap();

    let status = res.status();

    let text = res.text().await.unwrap();

    if status != StatusCode::OK {

        return Err(MyError { msg: text });

    }

    Ok(text)

}

async fn route_get_query(

    State(state): State<SharedState>,

    Query(query): Query<QueryQuery>,

) -> Result<Html<String>, MyError> {

    let config: AnnotationServerConfig = {

        let state = state.read().unwrap();

        state.config.clone()

    let query_config = if let Some(query_config) = config.query_configs.get(&query.query) {

        query_config

        return Err(MyError {

            msg: format!("{} is not known", query.query),

        });

    println!("{} {} {:?}", query.query, query.entity, query_config);

    let sparql_output = run_sparql(&config, query_config, &query.entity).await?;

    let template_output = run_template(&config, query_config, sparql_output).await?;

    Ok(Html(template_output))

}

pub fn create_app(

    config: AnnotationServerConfig,

) -> Result<axum::routing::IntoMakeService<Router>, Box<dyn Error>> {

    let assets_dir = &config.assets_dir;

    let serve_dir =

        ServeDir::new(assets_dir).not_found_service(ServeFile::new(assets_dir.join("404.html")));

    let cors = CorsLayer::new()

        // allow `GET` and `POST` when accessing the resource

        .allow_methods([Method::GET, Method::POST])

        // allow requests from any origin

        .allow_origin(Any);

    let shared_state = Arc::new(RwLock::new(AppState { config }));

    Ok(Router::new()

        .route("/", get(route_get_index))

        .route("/query", get(route_get_query))

        .route("/configuration.json", get(route_get_configuration))

        .nest_service("/assets", serve_dir)

        .layer(cors)

        .with_state(Arc::clone(&shared_state))

        .into_make_service())

}