// Get a subset of 'active' domain objects fuzzy matching 'Chelsea'
def searchResult = searchableService.search("+active:true +Chelsea~", [offset: 20, max: 20])

println "${searchResult.total} hits:"
for (i in 0..<searchResult.results.size() {
    println "${searchResult.offset + i + 1}: ${searchResult.results[i].toString()} (score ${searchResult.scores[i]})"

}

// Find the lowest priced product matching the query '(laser OR L.A.S.E.R.) beam'
def product = Product.searchTop("(laser OR L.A.S.E.R.) beam", [sort: 'price', order: 'asc'])

// Get all articles that contain the terms 'police' OR 'doughnut',
// giving a higher score to items matching 'doughnut', and load from DB
def articles = Article.searchEvery("Police doughnut^2.0", [reload: true])

// Count the number of domain objects matching 'cow pie'
def count = searchableService.countHits("cow pie")

def searchResult = xxx.search(queryString)
def searchResult = xxx.search(queryString, options)
def searchResult = xxx.search {
    // ...
}
def searchResult = xxx.search(options) {
    // ...
}

// query string, no options
def searchResult = Book.search("white corpuscles")

// query string, with options
def searchResult = searchableService.search("Swathe of industries", [reload: true, offset: 10])

// query builder closure, no options
def searchResult = searchableService.search {
    fuzzy('name', 'lundon')
}

// query builder closure, with options
def searchResult = Book.search(offset: 25, max: 30) {
    gt('averageReview', 3)
    queryString('learning techniques')
}

def object = xxx.searchTop(queryString)
def object = xxx.searchTop(queryString, options)
def object = xxx.searchTop {
    // ...
}
def object = xxx.searchTop(options) {
    // ...
}

// query string, no options
def album = Music.searchTop("Silent Alarm")

// query string, with options
def topHit = searchableService.searchTop("seed planting times", [reload: true, offset: 10])

// query builder closure, no options
def topHit = searchableService.searchTop {
    multiPhrase('content') {
        add('tick')
        add('followed')
        add('tock')
    }
}

// query builder closure, with options
def album = Music.searchTop(reload: true, sort: 'reviewScore', order: 'reverse') {
    term('artist', 'bloc party')
    term('format', 'ALBUM')
}

def list = xxx.searchEvery(queryString)
def list = xxx.searchEvery(queryString, options)
def list = xxx.searchEvery {
    // ...
}
def list = xxx.searchEvery(options) {
    // ...
}

// query string, no options
def artists = Artist.searchEvery("Ugly Duckling")

// query string, with options
def hits = searchableService.searchEvery("Music of the Spheres", [sort: 'artistName', andDefaultOperator: true])

// query builder closure, no options
def hits = searchableService.searchEvery {
    multiPhrase('title') {
        add('Northen')
        add('Soul')
    }
}

// query builder closure, with options
def artists = Artist.searchEvery(sort: 'stars', order: 'desc') {
    queryString('Posse Cut', defaultSearchProperty: 'songs')
    term('deleted', false)
}

def every = xxx.countHits(queryString)
def every = xxx.countHits(queryString, options)
def every = xxx.countHits {
    // ...
}
def top = xxx.countHits(options) {
    // ...
}

// query string, with options
def count = Show.countHits("CSI [Las Vegas]", escape: true)

// query string, with options
def count = searchableService.countHits("CSI [Miami]", [escape: true])

// query builder closure, no options
def count = searchableService.countHits {
    term('format', 'MP3')
    multiPhrase('title') {
        add('Wrecking')
        add('Ball')
    }
}

// query builder closure
def count = Show.countHits {
    term('keywords', 'crime')
    term('keywords', 'drama')
    queryString('ongoing love interest subplot', [defaultSearchProperty: 'notes'])
}

def termFreqs = xxx.termFreqs() // returns term frequencies for all searchable properties
def termFreqs = xxx.termFreqs(propertyName) // returns term frequencies for the named domain class property
def termFreqs = xxx.termFreqs(propertyName, options) // returns term frequencies for the named property with additional options
def termFreqs = xxx.termFreqs(options) // returns term frequencies with all parameters defined by the options Map

// print all Book term frequencies
def termFreqs = Book.termFreqs()
termFreqs.each { 
    println "${it.term} occurs ${it.freq} times in the index for Book instances" 
}

// get Book term frequencies for Book#title
def termFreqs = Book.termFreqs("title")

// get Book term frequencies for Book#title, limiting the size to 100
// and normalising (UK spelling) the frequencies between 0 (minimum) and 1 (maximum)
def termFreqs = Book.termFreqs("title", size: 100, normalise: 0..1)

// get terms from all properties in the index, sorting by term and limited to the Author class
def termFreqs = searchableService.search(class: Author, sort: 'term')

// get terms from searchable "title" and "description" properties in the index,
// limiting and normalsing (US spelling this time)
def termFreqs = searchableService.search(properties: ['title', 'description'], size: 1000, normalize: 0..1)

Product.search("wireless projector *", escape: true) // without "escape: true" would throw ParseException due to trailing " *"

// Get Property instances matching "Riverside Apartment" sorted by price in ascending order
def searchResult = Property.search("Riverside Apartment", [sort: 'price', order: 'asc'])

// Find the least relevant match
def leastRelevant = searchableService.searchTop(sort: 'SCORE', direction: 'reverse') {
    fuzzy('word', "roam")
}

import org.compass.core.*

// ...

// Sort first by score (relevance), then by most votes (when the score is equal)
def hits = searchableService.searchEvery {
    queryString('reality tv')
    sort(CompassQuery.SortImplicitType.SCORE)
    sort('votes', CompassQuery.SortDirection.REVERSE)
}

search {                    // <-- create an implicit boolean query
    lt('pages', 50)         // <-- uses CompassQueryBuilder#lt, and adds a boolean "should" clause
    term('type', 'poetry')  // <-- uses CompassQueryBuilder#term, and adds a boolean "should" clause
}

search {                          // <-- creates an implicit boolean query
    lt('pages', 50)               // <-- uses CompassQueryBuilder#lt, and adds a boolean "should"
    must(term('type', 'poetry'))  // <-- uses CompassQueryBuilder#term, adds a boolean "must"
}

search {                           // <-- creates an implicit boolean query
    lt('pages', 50)                // <-- uses CompassQueryBuilder#lt, and adds a boolean "should"
    must(term('type', 'poetry'))   // <-- uses CompassQueryBuilder#term, adds a boolean "must"
    mustNot(term('theme', 'war'))  // <-- uses CompassQueryBuilder#term, adds a boolean "mustNot"
}

search {                                   // <-- creates an implicit boolean query
    must(queryString("all hands on deck")) // <-- uses CompassQueryBuilder#queryString, and adds a boolean must
    lt('pages', 50)                        // <-- uses CompassQueryBuilder#lt, and adds a boolean "should"
    must(term('type', 'poetry'))           // <-- uses CompassQueryBuilder#term, adds a boolean "must"
    mustNot(term('theme', 'war'))          // <-- uses CompassQueryBuilder#term, adds a boolean "mustNot"
}

search {                                      // <-- creates an implicit boolean query
    must(queryString("all hands on deck") {   // <-- creates a nested CompassQueryStringBuilder context
        useAndDefaultOperator()               // <-- calls CompassQueryStringBuilder#useAndDefaultOperator
        setDefaultSearchProperty('body')      // <-- calls CompassQueryStringBuilder#setDefaultSearchProperty
    })                                        // <-- added as boolean must to surrounding boolean
    lt('pages', 50)                           // <-- uses CompassQueryBuilder#lt, and adds a boolean "should"
    must(term('type', 'poetry'))              // <-- uses CompassQueryBuilder#term, adds a boolean "must"
    mustNot(term('theme', 'war'))             // <-- uses CompassQueryBuilder#term, adds a boolean "mustNot"
}

search {                                    // <-- creates an implicit boolean query
    must(queryString("all hands on deck", [useAndDefaultOperator: true, defaultSearchProperty: 'body']))
        // ^^ add a "must" nested query string, calling useAndDefaultOperator() and setDefaultSearchProperty('body')
        //    on the CompassQueryStringBuilder
    lt('pages', 50)                         // <-- uses CompassQueryBuilder#lt, and adds a boolean "should"
    must(term('type', 'poetry'))            // <-- uses CompassQueryBuilder#term, adds a boolean "must"
    mustNot(term('theme', 'war'))           // <-- uses CompassQueryBuilder#term, adds a boolean "mustNot"
}

search {                                    // <-- creates an implicit boolean query
    must(multiPhrase("body", [slop: 2]) {   // <-- creates a nested CompassMultiPhraseQueryBuilder context, calling setSlop(2)
        add('all')                          // <-- calls CompassMultiPhraseQueryBuilder#add
        add('hands')                        // <-- calls CompassMultiPhraseQueryBuilder#add
        add('on')
        add('deck')
    })                                      // <-- adds multiPhrase as boolean "must"
    lt('pages', 50)                         // <-- uses CompassQueryBuilder#lt, and adds a boolean "should"
    must(term('type', 'poetry'))            // <-- uses CompassQueryBuilder#term, adds a boolean "must"
    mustNot(term('theme', 'war'))           // <-- uses CompassQueryBuilder#term, adds a boolean "mustNot"
}

search {                                    // <-- creates an implicit boolean query
    must(multiPhrase("body", [slop: 2]) {   // <-- creates a nested CompassMultiPhraseQueryBuilder context, and calls setSlop(2)
        add('all')                          // <-- calls CompassMultiPhraseQueryBuilder#add
        add('hands')                        // <-- calls CompassMultiPhraseQueryBuilder#add
        add('on')
        add('deck')
    })                                      // <-- adds multiPhrase as boolean "must"
    must {                                  // <-- creates an nested boolean query, implicitly
        ge('pages', 50)                     // <-- uses CompassQueryBuilder#ge, adds a boolean "should"
        lt('pages', 50, [boost: 1.5])       // <-- uses CompassQueryBuilder#lt, calls setBoost(1.5f), adds a boolean "should"
    }                                       // <-- adds nested boolean as "must" clause to outer boolean
    must(term('type', 'poetry'))            // <-- uses CompassQueryBuilder#term, adds a boolean "must"
    mustNot(term('theme', 'war'))           // <-- uses CompassQueryBuilder#term, adds a boolean "mustNot"
    ge('publishedDate', new Date() - 28)
    sort(CompassQuery.SortImplicitType.SCORE)                  // <-- uses CompassQuery#addSort
    sort('authorSurname', CompassQuery.SortPropertyType.STRING) // <-- uses CompassQuery#addSort
}

// sr is the same Map returned by search, so store stuff in that
def searchResult = Song.search("summer winds", withHighlighter: { highlighter, index, sr ->
    // lazy-init the storage
    if (!sr.highlights) {
        sr.highlights = []
    }

    // store highlighted song lyrics; "lyrics" is a searchable-property of the Song domain class
    sr.highlights[index] = highlighter.fragment("lyrics")
})
assert searchResult.highlights
assert searchResult.highlights.size() == searchResult.results.size()
assert (searchResult.highlights[0].indexOf("<b>summer</b>") > -1 || searchResult.highlights[0].indexOf("<b>winds</b>") > -1)

// sr is the collection of matching domain classes, so we need to define the storage externally this time
def highlights = []
def songs = Song.searchEvery("summer winds", withHighlighter: { highlighter, index, sr ->
    // store highlighted song lyrics; "lyrics" is a searchable-property of the Song domain class
    highlights[index] = highlighter.fragment("lyrics")
})
assert highlights.size() == songs.size()
assert highlights[0].indexOf("<b>summer</b>") > -1 || searchResult.highlights[0].indexOf("<b>winds</b>") > -1)