use std::sync::OnceLock;
use tantivy::schema;
use tantivy::schema::{
    Field, IndexRecordOption, Schema as TantivySchema, TextFieldIndexing, TextOptions,
};

static SCHEMA: OnceLock<TantivySchema> = OnceLock::new();

pub struct Schema;

impl Schema {
    pub fn schema() -> &'static TantivySchema {
        SCHEMA.get_or_init(|| {
            let stored_ngram32 = TextOptions::default().set_indexing_options(
                TextFieldIndexing::default()
                    .set_index_option(IndexRecordOption::WithFreqsAndPositions)
                    .set_tokenizer("ngram_32"),
            ).set_stored();

            let stored_en_stem = TextOptions::default().set_indexing_options(
                TextFieldIndexing::default()
                    .set_index_option(IndexRecordOption::WithFreqsAndPositions)
                    .set_tokenizer("en_stem"),
            ).set_stored();

            let mut schema_builder = TantivySchema::builder();
            schema_builder.add_u64_field("type", schema::FAST | schema::INDEXED);
            schema_builder.add_text_field("iri", schema::STORED | schema::STRING);

            schema_builder.add_text_field("label:en", stored_ngram32.clone());
            schema_builder.add_text_field("definition:en", stored_en_stem.clone());

            /*schema_builder.add_text_field("title", en_stem.clone());
            schema_builder.add_text_field("description", en_stem.clone());
            schema_builder.add_text_field("content", en_stem);*/
            schema_builder.build()
        })
    }

    pub fn type_field() -> Field {
        Self::schema().get_field("type").unwrap()
    }

    pub fn iri_field() -> Field {
        Self::schema().get_field("iri").unwrap()
    }

    pub fn field(name: &str, language: &str) -> Field {
        Schema::schema()
            .get_field(&format!("{name}:{language}"))
            .expect("Field not found in schema")
    }

    pub fn all_fields() -> Vec<Field> {
        Self::schema().fields().map(|(field, _)| field).collect()
    }
}