module util

import term
import strings

// Possibility is a simple pair of a string, with a similarity coefficient
// determined by the editing distance to a wanted value.
struct Possibility {
    value  string
    svalue string
mut:
    similarity f32 // 0.0 .. 1.0; 0.0 means the strings have nothing in common, and 1.0 means exactly equal strings
}

// CalculateSuggestionSimilarityFN is the type of the similarity comparison function, that will be used to determine what suggestions are best
pub type CalculateSuggestionSimilarityFN = fn (s1 string, s2 string) f32

// Suggestion is set of known possibilities and a wanted string.
// It has helper methods for making educated guesses based on the possibilities,
// on which of them match best the wanted string.
struct Suggestion {
mut:
    known                []Possibility
    wanted               string
    swanted              string
    similarity_threshold f32
    similarity_fn        CalculateSuggestionSimilarityFN = strings.dice_coefficient
}

// SuggestionParams contains the defaults for the optional parameters of new_suggestion.
@[params]
pub struct SuggestionParams {
pub mut:
    similarity_threshold f32 = 0.5                      // only items for which the similarity is above similarity_threshold, will be shown
    similarity_fn        CalculateSuggestionSimilarityFN = strings.dice_coefficient // see also strings.hamming_similarity
}

// new_suggestion creates a new Suggestion, given a wanted value and a list of possibilities.
pub fn new_suggestion(wanted string, possibilities []string, params SuggestionParams) Suggestion {
    mut s := Suggestion{
        known:                []Possibility{cap: int(max_suggestions_limit)}
        wanted:               wanted
        swanted:              short_module_name(wanted)
        similarity_threshold: params.similarity_threshold
        similarity_fn:        params.similarity_fn
    }
    s.add_many(possibilities)
    s.sort()
    return s
}

const max_suggestions_limit = $d('max_suggestions_limit', 200)

// add adds the `val` to the list of known possibilities of the suggestion.
// It calculates the similarity metric towards the wanted value.
pub fn (mut s Suggestion) add(val string) {
    if s.known.len >= max_suggestions_limit {
        return
    }
    if val in [s.wanted, s.swanted] {
        return
    }
    sval := short_module_name(val)
    if sval in [s.wanted, s.swanted] {
        return
    }
    // round to 3 decimal places to avoid float comparison issues
    similarity := f32(int(s.similarity_fn(s.swanted, sval) * 1000)) / 1000
    s.known << Possibility{
        value:      val
        svalue:     sval
        similarity: similarity
    }
}

// add adds all of the `many` to the list of known possibilities of the suggestion
pub fn (mut s Suggestion) add_many(many []string) {
    for x in many {
        if s.known.len >= max_suggestions_limit {
            break
        }
        s.add(x)
    }
}

// sort sorts the list of known possibilities, based on their similarity metric.
// Equal strings will be first, followed by less similar ones, very distinct ones will be last.
pub fn (mut s Suggestion) sort() {
    s.known.sort(a.similarity < b.similarity)
}

// say produces a final suggestion message, based on the preset `wanted` and
// `possibilities` fields, accumulated in the Suggestion.
pub fn (s Suggestion) say(msg string) string {
    mut res := msg
    mut found := false
    if s.known.len > 0 {
        top_possibility := s.known.last()
        if top_possibility.similarity > s.similarity_threshold {
            val := top_possibility.value
            if !val.starts_with('[]') {
                res += '.\nDid you mean `${highlight_suggestion(val)}`?'
                found = true
            }
        }
    }
    if !found {
        if s.known.len > 0 {
            mut values := s.known.map('`${highlight_suggestion(it.svalue)}`')
            values.sort()
            if values.len == 1 {
                res += '.\n1 possibility: ${values[0]}.'
            } else if values.len < 25 {
                // it is hard to read/use too many suggestions
                res += '.\n${values.len} possibilities: ' + values.join(', ') + '.'
            }
        }
    }
    return res
}

// short_module_name returns a shortened version of the fully qualified `name`,
// i.e. `xyz.def.abc.symname` -> `abc.symname`
pub fn short_module_name(name string) string {
    if !name.contains('.') {
        return name
    }
    vals := name.split('.')
    if vals.len < 2 {
        return name
    }
    mname := vals[vals.len - 2]
    symname := vals.last()
    return '${mname}.${symname}'
}

// highlight_suggestion returns a colorfull/highlighted version of `message`,
// but only if the standard error output allows for color messages, otherwise
// the plain message will be returned.
pub fn highlight_suggestion(message string) string {
    return term.ecolorize(term.bright_blue, message)
}