package webutility
  
  import (
  	"encoding/json"

  	"errors"

  	"io/ioutil"

  	"path"

  	"strings"

  	"sync"

  )

  type Dictionary struct {

  	my            sync.Mutex

  	locales       map[string]map[string]string
  	supported     []string
  	defaultLocale string

  }

  func NewDictionary() *Dictionary {
  	return &Dictionary{

  		locales: map[string]map[string]string{},
  	}
  }

  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)
  	}

  
  	return nil
  }

  func (d *Dictionary) GetBestMatchLocale(acceptedLanguages string) (best string) {
  	accepted := d.parseAcceptedLanguageHeader(acceptedLanguages)
  	best = accepted[0]
  	return
  }

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

  func (d *Dictionary) hasLocale(loc string) bool {

  	for _, v := range d.supported {
  		if v == loc {

  			return true
  		}
  	}
  	return false

  }

  func (d *Dictionary) setDefaultLocale(loc string) error {
  	if !d.hasLocale(loc) {

  		return errors.New("dictionary does not contain translations for " + loc)
  	}
  	d.defaultLocale = loc
  	return nil
  }

  func (d *Dictionary) getDefaultLocale() string {

  	return d.defaultLocale
  }

  func (d *Dictionary) parseAcceptedLanguageHeader(acceptedLanguages string) (langs []string) {
  	if acceptedLanguages == "" {

  		langs = append(langs, d.getDefaultLocale())

  		return
  	}

  	parts := strings.Split(acceptedLanguages, ",")

  	for _, p := range parts {
  		langs = append(langs, p)
  	}
  
  	return
  }

  
  func stripFileExtension(full string) (stripped string) {

  	extension := path.Ext(full)
  	stripped = strings.TrimSuffix(full, extension)
  	return stripped

  }