func (mh *matchHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("content-type", "application/json")
	if r.Method != http.MethodGet {
		w.WriteHeader(http.StatusNotFound)
		return
	}
	mr := &matchResponse{}
	query := r.URL.Query().Get("q")
	if query == "" {
		mr.Error = "Must supply query parameter 'q' in URL."
		response, err := json.Marshal(mr)
		if err != nil {
			w.WriteHeader(http.StatusInternalServerError)
			return
		}
		w.WriteHeader(http.StatusBadRequest)
		w.Write(response)
		return
	}
	suggester := suggest.Suggest{}

	suggester.Commands = matches
	match, err := suggester.Autocorrect(query)
	if err != nil {
		mr.Error = err.Error()
		response, err := json.Marshal(mr)
		if err != nil {
			w.WriteHeader(http.StatusInternalServerError)
			return
		}
		w.WriteHeader(http.StatusInternalServerError)
		w.Write(response)
		return
	}

	if match == "" {
		mr.Error = "No match was found"
		response, err := json.Marshal(mr)
		if err != nil {
			w.WriteHeader(http.StatusInternalServerError)
			return
		}
		w.WriteHeader(http.StatusNotFound)
		w.Write(response)
		return
	}

	mr.Changed = match != query
	mr.Match = match
	response, err := json.Marshal(mr)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		return
	}
	w.WriteHeader(http.StatusOK)
	w.Write(response)
	return
}

// TestCalculateSimilarity tests the expected distance using the default parameters
func TestCalculateSimilarity(t *testing.T) {

	s := suggest.Suggest{}

	for _, tt := range distanceTests {
		actual := s.CalculateSimilarity(tt.words[0], tt.words[1])
		if actual != tt.expected {
			t.Errorf("CalculateSimilarity(%v) = %d, want %d", tt.words, actual, tt.expected)
		}
	}
}

func simpleExample() {

	suggester := suggest.Suggest{}

	query := "fgerp"
	commands := []string{"cat", "mkdir", "fgrep", "history"}

	match, err := suggester.AutocorrectAgainst(query, commands)
	if err == nil {
		fmt.Println("Autocorrected to:", match) // "fgrep"
	}

	suggester.Commands = commands
	if match, err := suggester.Autocorrect(query); err == nil {
		fmt.Println("Also Autocorrected to:", match) // "fgrep"
	}

	query = "println"
	commands = []string{"Fprint", "Fprintf", "Fprintln", "Sprintf", "Print", "Printf", "Println"}
	suggester.Options.SimilarityMinimum = 8

	fmt.Printf("Searching %v for %s\n", query, commands)

	if result, err := suggester.QueryAgainst(query, commands); err == nil {
		if !result.Success() {
			fmt.Println("No close matches")
		} else {
			fmt.Println("Similar matches:", result.Matches) // [Println Fprintln]
			fmt.Println("Autocorrect:", result.Autocorrect) // Println

		}
	}
	os.Exit(0)
}

func TestExactMatchAgainst(t *testing.T) {

	s := suggest.Suggest{}

	for _, tt := range writeTests {
		query := tt.query
		commands := tt.commands
		actual := s.ExactMatchAgainst(query, commands)

		if actual != tt.expected {
			t.Errorf("ExactMatchAgainst(%q, %v) = %q, want %q", tt.query, tt.commands, actual, tt.expected)
		}
	}
}

func TestQueryAgainst(t *testing.T) {

	s := suggest.Suggest{}

	for _, tt := range queryTests {
		query := tt.query
		result, err := s.QueryAgainst(query, tt.commands)
		actual := result.Matches

		if err != nil {
			t.Errorf("TestQueryAgainst(%v) returned error %v", tt.query, err)
			continue
		}

		if !reflect.DeepEqual(actual, tt.expected) {
			t.Errorf("TestQueryAgainst(%q, %v) = %q, want %q", tt.query, tt.commands, actual, tt.expected)
		}
	}
}

func simpleExample3() {
	// make sure our example in doc.go works
	suggester := suggest.Suggest{}
	suggester.Options.SimilarityMinimum = 7
	suggester.Options.AutocorrectDisabled = false

	query := "proflie"
	commands := []string{"perfil", "profiel", "profile", "profil", "account"}

	suggester.Commands = commands
	if result, err := suggester.Query(query); err == nil {
		if !result.Success() {
			fmt.Println("No close matches")
		} else {
			fmt.Println("Similar matches:", result.Matches) // [profile profil profiel]
			fmt.Println("Autocorrect:", result.Autocorrect) // profile
		}
	}
	os.Exit(0)
}

func TestAutocorrectAgainst(t *testing.T) {

	s := suggest.Suggest{}

	if s.Options.AutocorrectDisabled != false {
		t.Errorf("AutocorrectDisabled should be initialized to false")
	}

	for _, tt := range autocorrectTests {
		query := tt.query
		s.Commands = tt.commands
		actual, err := s.AutocorrectAgainst(query, tt.commands)
		if err != nil {
			t.Errorf("AutocorrectAgainst(%v) returned error %v", tt.query, err)
			continue
		}
		if actual != tt.expected {
			t.Errorf("AutocorrectAgainst(%q, %v) = %q, want %q", tt.query, tt.commands, actual, tt.expected)
		}
	}
}

func simpleExample2() {
	suggester := suggest.Suggest{}

	query := "fgerp"
	commands := []string{"cat", "mkdir", "fgrep", "history"}

	suggester.Commands = commands
	if match, err := suggester.Autocorrect("mkdri"); err == nil {
		fmt.Println("Autocorrected to:", match) // "mkdir"
	}

	// Alternate autocorrect usage pattern
	match, _ := suggester.AutocorrectAgainst(query, commands)
	if match != "" {
		fmt.Println("Autocorrected to:", match) // "fgrep"
	}

	// Alternate usage pattern
	query = "printf"
	commands = []string{"Fprint", "Fprintf", "Fprintln", "Sprintf", "Printf", "Println"}
	suggester.Options.SimilarityMinimum = 8

	fmt.Printf("Searching %v in %s\n", query, commands)

	if result, err := suggester.QueryAgainst(query, commands); err == nil {
		if !result.Success() {
			fmt.Println("No close matches")

		} else {
			fmt.Println("Similar matches:", result.Matches)
			// [Println Fprintln]

			fmt.Println("Autocorrect:", result.Autocorrect)
			// Println
		}
	}
}