package webutility

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"path"
	"strconv"
	"strings"
	"sync"
)

// Dictionary ...
type Dictionary struct {
	my            sync.Mutex
	locales       map[string]map[string]string
	supported     []string
	defaultLocale string
}

// NewDictionary ...
func NewDictionary() *Dictionary {
	return &Dictionary{
		locales: map[string]map[string]string{},
	}
}

// AddTranslations ...
func (d *Dictionary) AddTranslations(directory string) error {
	files, err := ioutil.ReadDir(directory)
	if err != nil {
		return err
	}

	for _, fileInfo := range files {
		fName := fileInfo.Name()
		path := directory + "/" + fName
		file, err := ioutil.ReadFile(path)
		if err != nil {
			return err
		}

		loc := stripFileExtension(fName)

		var data interface{}
		err = json.Unmarshal(file, &data)
		if err != nil {
			return err
		}

		l := map[string]string{}
		for k, v := range data.(map[string]interface{}) {
			l[k] = v.(string)
		}

		mu.Lock()
		defer mu.Unlock()
		d.locales[loc] = l
		d.supported = append(d.supported, loc)
	}

	if d.defaultLocale == "" && len(d.supported) > 0 {
		d.defaultLocale = d.supported[0]
	}

	return nil
}

// GetBestMatchLocale ...
func (d *Dictionary) GetBestMatchLocale(req *http.Request) (best string) {
	accepted := d.parseAcceptedLanguages(req.Header.Get("Accept-Language"))

	for i := range accepted {
		if accepted[i].Code == "*" {
			return d.defaultLocale
		}
		for j := range d.supported {
			if accepted[i].Code == d.supported[j] {
				return d.supported[j]
			}
		}
	}

	return d.defaultLocale
}

// Translate ...
func (d *Dictionary) Translate(loc, key string) string {
	return d.locales[loc][key]
}

// SetDefaultLocale ...
func (d *Dictionary) SetDefaultLocale(loc string) error {
	if !d.contains(loc) {
		return fmt.Errorf("locale file not loaded: %s", loc)
	}

	d.defaultLocale = loc

	return nil
}

func (d *Dictionary) contains(loc string) bool {
	for _, v := range d.supported {
		if v == loc {
			return true
		}
	}
	return false
}

// LangWeight ...
type LangWeight struct {
	Code   string
	Weight float64
}

func (d *Dictionary) parseAcceptedLanguages(accepted string) (langs []LangWeight) {
	if accepted == "" {
		langs = append(langs, LangWeight{Code: d.defaultLocale, Weight: 1.0})
		return langs
	}

	var code string
	var weight float64

	parts := strings.Split(accepted, ",")
	for i := range parts {
		parts[i] = strings.Trim(parts[i], " ")

		cw := strings.Split(parts[i], ";")
		paramCount := len(cw)

		if paramCount == 1 {
			// default weight of 1
			code = cw[0]
			weight = 1.0
		} else if paramCount == 2 {
			// parse weight
			code = cw[0]
			weight, _ = strconv.ParseFloat(cw[1][2:], 64)

		}

		langs = append(langs, LangWeight{Code: code, Weight: weight})
	}

	// TODO(marko): sort langs by weights?

	return langs
}

func stripFileExtension(full string) (stripped string) {
	extension := path.Ext(full)
	stripped = strings.TrimSuffix(full, extension)
	return stripped
}