use crate::{errors::Error, indexes::Index};
use serde::{de::DeserializeOwned, Deserialize};

// TODO support https://docs.meilisearch.com/guides/advanced_guides/search_parameters.html#matches
// TODO highlighting

#[derive(Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
/// A struct containing search results and other information about the search.
pub struct SearchResults<T> {
    /// results of the query
    pub hits: Vec<T>,
    /// number of documents skipped
    pub offset: usize,
    /// number of documents to take
    pub limit: usize,
    /// total number of matches
    pub nb_hits: usize,
    /// whether nbHits is exhaustive
    pub exhaustive_nb_hits: bool,
    /// processing time of the query
    pub processing_time_ms: usize,
    /// query originating the response
    pub query: String,
}

/// A struct representing a query.
/// You can add search parameters using the builder syntax.
/// See [here](https://docs.meilisearch.com/guides/advanced_guides/search_parameters.html#query-q) for the list and description of all parameters.
///
/// # Example
///
/// ```
/// # use meilisearch_sdk::search::Query;
/// let query = Query::new("space")
///     .with_offset(42)
///     .with_limit(21);
/// ```
pub struct Query<'a> {
    /// The query parameter is the only mandatory parameter.  
    /// This is the string used by the search engine to find relevant documents.
    pub query: &'a str,
    /// A number of documents to skip. If the value of the parameter offset is n, n first documents to skip. This is helpful for pagination.  
    ///   
    /// Example: If you want to skip the first document, set offset to 1.  
    /// Default: 0
    pub offset: Option<usize>,
    /// Set a limit to the number of documents returned by search queries. If the value of the parameter limit is n, there will be n documents in the search query response. This is helpful for pagination.  
    ///   
    /// Example: If you want to get only two documents, set limit to 2.
    /// Default: 20
    pub limit: Option<usize>,
    /// Attributes to display in the returned documents. Comma-separated list of attributes whose fields will be present in the returned documents.
    /// 
    /// Example: If you want to get only the overview and title field and not the other fields, set `attributes_to_retrieve` to `overview,title`.
    /// Default: The [displayed attributes list](https://docs.meilisearch.com/guides/advanced_guides/settings.html#displayed-attributes) which contains by default all attributes found in the documents.
    pub attributes_to_retrieve: Option<&'a str>,
    /// TODO [doc](https://docs.meilisearch.com/guides/advanced_guides/search_parameters.html#attributes-to-crop)
    pub attributes_to_crop: Option<&'a str>,
    /// Number of characters to keep on each side of the start of the matching word. See [attributes_to_crop](#structfield.attributes_to_crop).  
    ///   
    /// Default: 200
    pub crop_lenght: Option<usize>,
    /// TODO [doc](https://docs.meilisearch.com/guides/advanced_guides/search_parameters.html#attributes-to-highlight)
    pub attributes_to_highlight: Option<&'a str>,
    /// Specify a filter to be used with the query. See the [dedicated guide](https://docs.meilisearch.com/guides/advanced_guides/filtering.html).
    pub filters: Option<&'a str>,
}

#[allow(missing_docs)]
impl<'a> Query<'a> {
    pub fn new(query: &'a str) -> Query<'a> {
        Query {
            query,
            offset: None,
            limit: None,
            attributes_to_retrieve: None,
            attributes_to_crop: None,
            attributes_to_highlight: None,
            crop_lenght: None,
            filters: None,
        }
    }
    pub fn with_offset(self, offset: usize) -> Query<'a> {
        Query {
            offset: Some(offset),
            ..self
        }
    }
    pub fn with_limit(self, limit: usize) -> Query<'a> {
        Query {
            limit: Some(limit),
            ..self
        }
    }
    pub fn with_attributes_to_retrieve(self, attributes_to_retrieve: &'a str) -> Query<'a> {
        Query {
            attributes_to_retrieve: Some(attributes_to_retrieve),
            ..self
        }
    }
    pub fn with_attributes_to_crop(self, attributes_to_crop: &'a str) -> Query<'a> {
        Query {
            attributes_to_crop: Some(attributes_to_crop),
            ..self
        }
    }
    pub fn with_attributes_to_highlight(self, attributes_to_highlight: &'a str) -> Query<'a> {
        Query {
            attributes_to_highlight: Some(attributes_to_highlight),
            ..self
        }
    }
    pub fn with_crop_lenght(self, crop_lenght: usize) -> Query<'a> {
        Query {
            crop_lenght: Some(crop_lenght),
            ..self
        }
    }
    pub fn with_filters(self, filters: &'a str) -> Query<'a> {
        Query {
            filters: Some(filters),
            ..self
        }
    }
}

impl<'a> Query<'a> {
    pub(crate) fn to_url(&self) -> String {
        use urlencoding::encode;
        let mut url = format!("?q={}&", encode(self.query));

        if let Some(offset) = self.offset {
            url.push_str("offset=");
            url.push_str(offset.to_string().as_str());
            url.push('&');
        }
        if let Some(limit) = self.limit {
            url.push_str("limit=");
            url.push_str(limit.to_string().as_str());
            url.push('&');
        }
        if let Some(attributes_to_retrieve) = self.attributes_to_retrieve {
            url.push_str("attributesToRetrieve=");
            url.push_str(encode(attributes_to_retrieve).as_str());
            url.push('&');
        }
        if let Some(attributes_to_crop) = self.attributes_to_crop {
            url.push_str("attributesToCrop=");
            url.push_str(encode(attributes_to_crop).as_str());
            url.push('&');
        }
        if let Some(crop_lenght) = self.crop_lenght {
            url.push_str("cropLength=");
            url.push_str(crop_lenght.to_string().as_str());
            url.push('&');
        }
        if let Some(attributes_to_highlight) = self.attributes_to_highlight {
            url.push_str("attributesToHighlight=");
            url.push_str(encode(attributes_to_highlight).as_str());
            url.push('&');
        }
        if let Some(filters) = self.filters {
            url.push_str("filters=");
            url.push_str(encode(filters).as_str());
        }

        url
    }

    /// Alias for [the Index method](../indexes/struct.Index.html#method.search).
    pub fn execute<T: DeserializeOwned>(&self, index: &Index) -> Result<SearchResults<T>, Error> {
        index.search::<T>(&self)
    }
}