use meilisearch_sdk::client::Client;
use meilisearch_sdk::errors::{Error as MeilisearchError, ErrorCode};
use tracing::{debug, error, info};

use crate::config::Config;

#[derive(Debug, thiserror::Error)]
pub enum Error {
    #[error("Could not read token: {0}")]
    Token(std::io::Error),
    #[error("{0}")]
    Meilisearch(#[from] MeilisearchError),
}

impl TryFrom<&Config> for Client {
    type Error = Error;

    fn try_from(config: &Config) -> Result<Self, Self::Error> {
        let token = match &config.meilisearch.token {
            Some(t) => Some(std::fs::read_to_string(t).map_err(Error::Token)?),
            None => None,
        };
        Ok(Client::new(&config.meilisearch.url, token)?)
    }
}

pub async fn ensure_index(
    client: &Client,
    name: &str,
) -> Result<(), MeilisearchError> {
    match client.get_index(name).await {
        Ok(_) => {
            debug!("Meilisearch index '{}' already exists", name);
            Ok(())
        },
        Err(MeilisearchError::Meilisearch(e))
            if e.error_code == ErrorCode::IndexNotFound =>
        {
            info!("Creating Meilisearch index: {}", name);
            if let Err(e) = create_index(client, name).await {
                error!("Failed to create index: {}", e);
                Err(e)
            } else {
                Ok(())
            }
        },
        Err(e) => {
            error!("Failed to check index: {}", e);
            Err(e)
        },
    }
}

async fn create_index(
    client: &Client,
    index: &str,
) -> Result<(), meilisearch_sdk::errors::Error> {
    let task = client.create_index(index, Some("id")).await?;
    task.wait_for_completion(client, None, None).await?;
    Ok(())
}