//! Contains structs for indexing a record based on a single [`Mapping`]

use super::{
    errors::{IndexerError, LoadIndexerError},
    mapping::{Mapping, MappingWithMeta},
    vector::{EncryptedTerm, TermVector, VectorTerm},
};
use crate::record::{Record, Value};

use hex_literal::hex;
use ore_encoding_rs::{siphash, OrePlaintext};
use ore_rs::{scheme::bit2::OREAES128, ORECipher, OREEncrypt};

/// Encrypt string terms using siphash and ORE for match queries
fn encrypt_string_terms(
    ore: &mut OREAES128,
    index_id: &[u8; 16],
    record_id: &[u8; 16],
    terms: Vec<String>,
) -> Result<Option<TermVector>, IndexerError> {
    let terms = terms
        .into_iter()
        .map(|term| OrePlaintext::from(siphash(term.as_bytes())))
        .map(|plaintext| {
            plaintext
                .0
                .encrypt(ore)
                .map(EncryptedTerm::from)
                .map(|term| VectorTerm {
                    term,
                    link: *record_id,
                })
        })
        .collect::<Result<Vec<_>, _>>()?;

    // If there are no string terms there is no point inserting anything into the database - just
    // return None.
    if terms.is_empty() {
        return Ok(None);
    }

    Ok(Some(TermVector {
        terms,
        index_id: *index_id,
    }))
}

/// An Indexer that indexs a record based on a single index.
pub struct MappingIndexer {
    ore: OREAES128,
    pub(crate) index_id: [u8; 16],
    pub(crate) mapping: Mapping,
}

impl MappingIndexer {
    /// Load a single MappingIndexer from a [`MappingWithMeta`]
    pub fn from_mapping(mapping: MappingWithMeta) -> Result<Self, LoadIndexerError> {
        let seed = hex!("00010203 04050607");

        let ore = OREAES128::init(mapping.prf_key, mapping.prp_key, &seed)
            .map_err(|e| LoadIndexerError::Other(format!("ORE init failed: {:?}", e)))?;

        Ok(Self {
            ore,
            index_id: mapping.index_id,
            mapping: mapping.mapping,
        })
    }

    /// Create a [`TermVector`] from a single term for the current mapping
    pub fn vector_from_term(&self, term: VectorTerm) -> TermVector {
        TermVector {
            terms: vec![term],
            index_id: self.index_id,
        }
    }

    /// Encrypt a [`Record`] using ORE
    ///
    /// If the Record contains no meaningful data to encrypt for this index, this method will
    /// return `None`.
    pub fn encrypt(&mut self, record: &Record) -> Result<Option<TermVector>, IndexerError> {
        let id = record.id;

        Ok(match &self.mapping {
            Mapping::Exact { field } => {
                if let Some(plaintext) = record
                    .index_with_dot_notation(field)
                    .and_then(|x| x.as_plaintext())
                {
                    let term = plaintext.0.encrypt(&mut self.ore)?.into();

                    Some(self.vector_from_term(VectorTerm { term, link: id }))
                } else {
                    None
                }
            }

            Mapping::Range { field } => {
                if let Some(val) = record.index_with_dot_notation(field) {
                    if let Value::String(_) = val {
                        // Range isn't supported for strings (yet) - so just exclude them
                        None
                    } else if let Some(plaintext) = val.as_plaintext() {
                        let term = plaintext.0.encrypt(&mut self.ore)?.into();
                        Some(self.vector_from_term(VectorTerm { term, link: id }))
                    } else {
                        // If the current value doesn't have a plaintext representation (it may be
                        // a map or array) then just exclude it from the index.
                        None
                    }
                } else {
                    None
                }
            }

            Mapping::Match { fields, pipeline } => encrypt_string_terms(
                &mut self.ore,
                &self.index_id,
                &record.id,
                // Match only operates on specified fields and only if they are strings
                pipeline.process(record.extract_string_fields(fields)),
            )?,

            Mapping::DynamicMatch { pipeline } => encrypt_string_terms(
                &mut self.ore,
                &self.index_id,
                &record.id,
                // Dynamic match operates on all string fields
                pipeline.process(record.extract_all_string_fields()),
            )?,

            Mapping::FieldDynamicMatch { pipeline } => encrypt_string_terms(
                &mut self.ore,
                &self.index_id,
                &record.id,
                record
                    .extract_all_string_fields_and_keys()
                    .into_iter()
                    .flat_map(|(k, v)| {
                        pipeline
                            .process(vec![v])
                            .into_iter()
                            // In order to specifiy fields and terms to be searches they must be
                            // encrypted in this "field:value" format. If this isn't done querying will
                            // silently fail.
                            .map(move |t| format!("{}:{}", k, t))
                    })
                    .collect(),
            )?,
        })
    }
}

#[cfg(test)]
mod tests {
    use crate::{
        indexer::mapping::{Mapping, MappingWithMeta},
        record::Record,
        test_utils::collection,
    };

    use super::MappingIndexer;

    #[test]
    fn test_compare_exact_matches() {
        let record = Record {
            id: [0; 16],
            fields: collection! {
                "test" => "test-string"
            },
        };

        let mut left_indexer = MappingIndexer::from_mapping(MappingWithMeta {
            mapping: Mapping::Exact {
                field: "test".into(),
            },
            prp_key: [0; 16],
            prf_key: [1; 16],
            index_id: [2; 16],
        })
        .expect("Failed to gen left indexer");

        let mut right_indexer = MappingIndexer::from_mapping(MappingWithMeta {
            mapping: Mapping::Exact {
                field: "test".into(),
            },
            prp_key: [0; 16],
            prf_key: [1; 16],
            index_id: [2; 16],
        })
        .expect("Failed to gen right indexer");

        let left = left_indexer
            .encrypt(&record)
            .expect("Failed to encrypt")
            .unwrap();
        let right = right_indexer
            .encrypt(&record)
            .expect("Failed to encrypt")
            .unwrap();

        assert_eq!(left.terms[0], right.terms[0]);
    }

    #[test]
    fn test_compare_not_exact() {
        let first = Record {
            id: [0; 16],
            fields: collection! {
                "test" => "test-string"
            },
        };

        let second = Record {
            id: [1; 16],
            fields: collection! {
                "test" => "test-different-string"
            },
        };

        let mut indexer = MappingIndexer::from_mapping(MappingWithMeta {
            mapping: Mapping::Exact {
                field: "test".into(),
            },
            prp_key: [0; 16],
            prf_key: [1; 16],
            index_id: [2; 16],
        })
        .expect("Failed to gen left indexer");

        let left = indexer.encrypt(&first).expect("Failed to encrypt").unwrap();
        let right = indexer
            .encrypt(&second)
            .expect("Failed to encrypt")
            .unwrap();

        assert_ne!(left.terms[0], right.terms[0]);
    }

    #[test]
    fn test_compare_range() {
        let first = Record {
            id: [0; 16],
            fields: collection! {
                "test" => 10
            },
        };

        let second = Record {
            id: [1; 16],
            fields: collection! {
                "test" => 20
            },
        };

        let mut indexer = MappingIndexer::from_mapping(MappingWithMeta {
            mapping: Mapping::Range {
                field: "test".into(),
            },
            prp_key: [0; 16],
            prf_key: [1; 16],
            index_id: [2; 16],
        })
        .expect("Failed to gen left indexer");

        let left = indexer.encrypt(&first).expect("Failed to encrypt").unwrap();
        let right = indexer
            .encrypt(&second)
            .expect("Failed to encrypt")
            .unwrap();

        assert!(left.terms[0] < right.terms[0]);
    }
}