package main

import (
	"log"
	"regexp"
	"strconv"
	"strings"

	"github.com/gocolly/colly"
)

func stringInSlice(a string, list []string) bool {
	for _, b := range list {
		if b == a {
			return true
		}
	}
	return false
}

func detect_spirit_type(name string) string {
	matched, err := regexp.MatchString(`(^|\s)Gin(\s|$)`, name)
	if err != nil {
		log.Fatal(err)
	}
	if matched {
		return "Gin"
	}
	matched, err = regexp.MatchString(`(^|\s)Rh?um(\s|$)`, name)
	if err != nil {
		log.Fatal(err)
	}
	if matched {
		return "Rum"
	}
	matched, err = regexp.MatchString(`(^|\s)[VW]odka(\s|$)`, name)
	if err != nil {
		log.Fatal(err)
	}
	if matched {
		return "Wodka"
	}
	matched, err = regexp.MatchString(`(^|\s)Whiske?y(\s|$)`, name)
	if err != nil {
		log.Fatal(err)
	}
	if matched {
		return "Whisky"
	}
	matched, err = regexp.MatchString(`(^|\s)Champagner(\s|$)`, name)
	if err != nil {
		log.Fatal(err)
	}
	if matched {
		return "Champagner"
	}
	matched, err = regexp.MatchString(`(^|\s)Cognac(\s|$)`, name)
	if err != nil {
		log.Fatal(err)
	}
	if matched {
		return "Cognac"
	}
	matched, err = regexp.MatchString(`(^|\s)Grappa(\s|$)`, name)
	if err != nil {
		log.Fatal(err)
	}
	if matched {
		return "Grappa"
	}
	matched, err = regexp.MatchString(`(^|\s)Likör(\s|$)`, name)
	if err != nil {
		log.Fatal(err)
	}
	if matched {
		return "Likör"
	}

	return "Verschiedenes"
}

func extract_volume(volume string) (float32, error) {
	r_liter, err := regexp.Compile(`[0-9]+([,.][0-9]+)?( )?[lL](iter)?`)
	if err != nil {
		log.Fatal(err)
	}
	volume_noisy := r_liter.FindString(volume)

	r_liter2, err := regexp.Compile(`[0-9]+([,.][0-9]+)?`)
	if err != nil {
		log.Fatal(err)
	}
	volume_noisy = r_liter2.FindString(volume_noisy)
	volume_noisy = strings.Replace(volume_noisy, ",", ".", 1)
	volume64, err := strconv.ParseFloat(volume_noisy, 32)
	if err != nil {
		return 0, err
	}

	return float32(volume64), err
}

func extract_abv(abv_noisy string) (float32, error) {
	if strings.Contains(abv_noisy, "%") {
		abv_noisy = strings.Replace(abv_noisy, "%", "", 1)
	}
	if strings.Contains(abv_noisy, "vol") {
		abv_noisy = strings.Replace(abv_noisy, "vol", "", 1)
	}
	if strings.Contains(abv_noisy, "Vol") {
		abv_noisy = strings.Replace(abv_noisy, "Vol", "", 1)
	}
	abv_noisy = strings.Replace(abv_noisy, ",", ".", 1)
	abv_noisy = strings.TrimSpace(abv_noisy)
	r_abv, err := regexp.Compile(`[0-9]+([,.][0-9]+)?`)
	if err != nil {
		log.Fatal(err)
	}
	abv_noisy = r_abv.FindString(abv_noisy)

	abv64, err := strconv.ParseFloat(abv_noisy, 32)
	if err != nil {
		return 0, err
	}

	return float32(abv64), nil
}

/*
 * In litre, but float.
 */
func get_volume(e *colly.HTMLElement) float32 {

	volume_noisy := e.Request.Ctx.Get("volume")

	matched, err := regexp.MatchString(`[lL](iter)?`, volume_noisy)
	if err != nil {
		log.Fatal(err)
	}
	if !matched {
		log.Println("get_volume: not matched: " + volume_noisy)
		return 0
	}

	volume, err := extract_volume(volume_noisy)
	if err != nil {
		log.Println("get_volume: " + volume_noisy)
		log.Fatal(err)
	}

	return volume
}

/*
 * In procent. (float)
 */
func get_abv(e *colly.HTMLElement) float32 {

	abv_noisy := e.Request.Ctx.Get("abv")

	if abv_noisy == "" {
		return 0
	}
	//	abv_noisy = strings.Replace(abv_noisy, ".", ",", 1)

	abv, err := extract_abv(abv_noisy)
	if err != nil {
		log.Println("get_abv: " + abv_noisy)
		log.Fatal(err)
	}

	return abv
}

/*
 * In cents. (int)
 */
func get_base_price(e *colly.HTMLElement) int {

	base_price_noisy := e.Request.Ctx.Get("base_price")

	if base_price_noisy == "" {
		return 0
	}

	base_price, err := sanitize_base_price(base_price_noisy)
	if err != nil {
		log.Println("get_base_price: " + base_price_noisy)
		log.Fatal(err)
	}

	return base_price
}