i18n.go

// Package i18n provides internalization and localization features.
package i18n

import (
	"net"
	"net/http"
	"os"
	"strings"
	"sync"

	"github.com/kataras/i18n/internal"

	"golang.org/x/net/publicsuffix"
	"golang.org/x/text/language"
)

// Default keeps a package-level pre-loaded `I18n` instance.
// The default glob pattern is "./locales/*/*" which accepts folder
// structure as:
// - ./locales
//   - el-GR
//   - filename.yaml
//   - filename.toml
//   - filename.json
//   - en-US
//   - ...
//   - zh-CN
//   - ...
//   - ...
//
// The default language depends on the first lookup, please use the package-level `SetDefaultLanguage`
// to set a default language as you are not able to customize the language lists from here.
//
// See `New` package-level function to declare a fresh new, customized, `I18n` instance.
var Default *I18n

func init() {
	Default, _ = New(Glob("./locales/*/*"))
}

// SetDefaultLanguage changes the default language of the `Default` `I18n` instance.
func SetDefaultLanguage(langCode string) bool {
	return Default.SetDefault(langCode)
}

type (
	// Map is just an alias of the map[string]interface{} type.
	Map = map[string]interface{}

	// Locale is the type which the `Localizer.GetLocale` method returns.
	// It serves the translations based on "key" or format. See its `GetMessage`.
	Locale = internal.Locale

	// MessageFunc is the function type to modify the behavior when a key or language was not found.
	// All language inputs fallback to the default locale if not matched.
	// This is why this signature accepts both input and matched languages, so caller
	// can provide better messages.
	//
	// The first parameter is set to the client real input of the language,
	// the second one is set to the matched language (default one if input wasn't matched)
	// and the third and forth are the translation format/key and its optional arguments.
	MessageFunc = internal.MessageFunc

	// Loader accepts a `Matcher` and should return a `Localizer`.
	// Functions that implement this type should load locale files.
	Loader func(m *Matcher) (Localizer, error)

	// Localizer is the interface which returned from a `Loader`.
	// Types that implement this interface should be able to retrieve a `Locale`
	// based on the language index.
	Localizer interface {
		// GetLocale should return a valid `Locale` based on the language index.
		// It will always match the Loader.Matcher.Languages[index].
		// It may return the default language if nothing else matches based on custom localizer's criteria.
		GetLocale(index int) *Locale
	}
)

// I18n is the structure which keeps the i18n configuration and implements Localization and internationalization features.
type I18n struct {
	localizer Localizer
	matcher   *Matcher

	loader Loader
	mu     sync.Mutex

	// If not nil, this request's context key can be used to identify the current language.
	// The found language(in this case, by path or subdomain) will be also filled with the current language on `Router` method.
	ContextKey interface{}
	// DefaultMessageFunc is the field which can be used
	// to modify the behavior when a key or language was not found.
	// All language inputs fallback to the default locale if not matched.
	// This is why this one accepts both input and matched languages,
	// so the caller can be more expressful knowing those.
	//
	// Defaults to nil.
	DefaultMessageFunc MessageFunc
	// ExtractFunc is the type signature for declaring custom logic
	// to extract the language tag name.
	ExtractFunc func(*http.Request) string
	// If not empty, it is language identifier by url query.
	URLParameter string
	// If not empty, it is language identifier by cookie of this name.
	Cookie string
	// If true then a subdomain can be a language identifier too.
	Subdomain bool
	// If true then it will return empty string when translation for a a specific language's key was not found.
	// Defaults to false, fallback defaultLang:key will be used.
	Strict bool
}

// makeTags converts language codes to language Tags.
func makeTags(languages ...string) (tags []language.Tag) {
	for _, lang := range languages {
		tag, err := language.Parse(lang)
		if err == nil && tag != language.Und {
			tags = append(tags, tag)
		}
	}

	return
}

// New returns a new `I18n` instance.
// It contains a `Router` wrapper to (local) redirect subdomains and path prefixes too.
//
// The "languages" input parameter is optional and if not empty then only these languages
// will be used for translations and the rest (if any) will be skipped.
// the first parameter of "loader" which lookups for translations inside files.
func New(loader Loader, languages ...string) (*I18n, error) {
	tags := makeTags(languages...)

	i := new(I18n)
	i.loader = loader
	i.matcher = &Matcher{
		strict:             len(tags) > 0,
		Languages:          tags,
		matcher:            language.NewMatcher(tags),
		defaultMessageFunc: i.DefaultMessageFunc,
	}

	if err := i.reload(); err != nil {
		return nil, err
	}

	return i, nil
}

// reload loads the language files from the provided Loader,
// the `New` package-level function preloads those files already.
func (i *I18n) reload() error { // May be an exported function, if requested.
	i.mu.Lock()
	defer i.mu.Unlock()

	localizer, err := i.loader(i.matcher)
	if err != nil {
		return err
	}

	i.localizer = localizer
	return nil
}

// SetDefault changes the default language.
// Please avoid using this method; the default behavior will accept
// the first language of the registered tags as the default one.
func (i *I18n) SetDefault(langCode string) bool {
	t, err := language.Parse(langCode)
	if err != nil {
		return false
	}

	if tag, index, conf := i.matcher.Match(t); conf > language.Low {
		if l, ok := i.localizer.(interface {
			SetDefault(int) bool
		}); ok {
			if l.SetDefault(index) {
				tags := i.matcher.Languages
				// set the order
				tags[index] = tags[0]
				tags[0] = tag

				i.matcher.Languages = tags
				i.matcher.matcher = language.NewMatcher(tags)
				return true
			}
		}
	}

	return false
}

// Matcher implements the languae.Matcher.
// It contains the original language Matcher and keeps an ordered
// list of the registered languages for further use (see `Loader` implementation).
type Matcher struct {
	strict    bool
	Languages []language.Tag
	matcher   language.Matcher
	// defaultMessageFunc passed by the i18n structure.
	defaultMessageFunc MessageFunc
}

var _ language.Matcher = (*Matcher)(nil)

// Match returns the best match for any of the given tags, along with
// a unique index associated with the returned tag and a confidence
// score.
func (m *Matcher) Match(t ...language.Tag) (language.Tag, int, language.Confidence) {
	return m.matcher.Match(t...)
}

// MatchOrAdd acts like Match but it checks and adds a language tag, if not found,
// when the `Matcher.strict` field is true (when no tags are provided by the caller)
// and they should be dynamically added to the list.
func (m *Matcher) MatchOrAdd(t language.Tag) (tag language.Tag, index int, conf language.Confidence) {
	tag, index, conf = m.Match(t)
	if conf <= language.Low && !m.strict {
		// not found, add it now.
		m.Languages = append(m.Languages, t)
		tag = t
		index = len(m.Languages) - 1
		conf = language.Exact
		m.matcher = language.NewMatcher(m.Languages) // reset matcher to include the new language.
	}

	return
}

// ParseLanguageFiles returns a map of language indexes and
// their associated files based on the "fileNames".
func (m *Matcher) ParseLanguageFiles(fileNames []string) (map[int][]string, error) {
	languageFiles := make(map[int][]string)

	for _, fileName := range fileNames {
		index := parsePath(m, fileName)
		if index == -1 {
			continue
		}

		languageFiles[index] = append(languageFiles[index], fileName)
	}

	return languageFiles, nil
}

func parsePath(m *Matcher, path string) int {
	if t, ok := parseLanguage(path); ok {
		if _, index, conf := m.MatchOrAdd(t); conf > language.Low {
			return index
		}
	}

	return -1
}

func parseLanguageName(m *Matcher, name string) int {
	if t, err := language.Parse(name); err == nil {
		if _, index, conf := m.MatchOrAdd(t); conf > language.Low {
			return index
		}
	}

	return -1
}

func reverseStrings(s []string) []string {
	for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
		s[i], s[j] = s[j], s[i]
	}
	return s
}

func parseLanguage(path string) (language.Tag, bool) {
	if idx := strings.LastIndexByte(path, '.'); idx > 0 {
		path = path[0:idx]
	}

	// path = strings.ReplaceAll(path, "..", "")

	names := strings.FieldsFunc(path, func(r rune) bool {
		return r == '_' || r == os.PathSeparator || r == '/' || r == '.'
	})

	names = reverseStrings(names) // see https://github.com/kataras/i18n/issues/1

	for _, s := range names {
		t, err := language.Parse(s)
		if err != nil {
			continue
		}

		return t, true
	}

	return language.Und, false
}

// TryMatchString will try to match the "s" with a registered language tag.
// It returns -1 as the language index and false if not found.
func (i *I18n) TryMatchString(s string) (language.Tag, int, bool) {
	if tag, err := language.Parse(s); err == nil {
		if tag, index, conf := i.matcher.Match(tag); conf > language.Low {
			return tag, index, true
		}
	}

	return language.Und, -1, false
}

// Tr is package-level function which calls the `Default.Tr` method.
//
// See `I18n#Tr` method for more.
func Tr(lang, format string, args ...interface{}) string {
	return Default.Tr(lang, format, args...)
}

// Tr returns a translated message based on the "lang" language code
// and its key(format) with any optional arguments attached to it.
//
// It returns an empty string if "lang" not matched, unless DefaultMessageFunc.
// It returns the default language's translation if "key" not matched, unless DefaultMessageFunc.
func (i *I18n) Tr(lang, format string, args ...interface{}) (msg string) {
	_, index, ok := i.TryMatchString(lang)
	if !ok {
		index = 0
	}

	langMatched := ""

	loc := i.localizer.GetLocale(index)
	if loc != nil {
		langMatched = loc.Language()

		msg = loc.GetMessage(format, args...)
		if msg == "" && i.DefaultMessageFunc == nil && !i.Strict && index > 0 {
			// it's not the default/fallback language and not message found for that lang:key.
			msg = i.localizer.GetLocale(0).GetMessage(format, args...)
		}
	}

	if msg == "" && i.DefaultMessageFunc != nil {
		msg = i.DefaultMessageFunc(lang, langMatched, format, args...)
	}

	return
}

const acceptLanguageHeaderKey = "Accept-Language"

// GetLocale is package-level function which calls the `Default.GetLocale` method.
//
// See `I18n#GetLocale` method for more.
func GetLocale(r *http.Request) *Locale {
	return Default.GetLocale(r)
}

// GetLocale returns the found locale of a request.
// It will return the first registered language if nothing else matched.
func (i *I18n) GetLocale(r *http.Request) *Locale {
	var (
		index int
		ok    bool
	)

	if i.ContextKey != nil {
		if v := r.Context().Value(i.ContextKey); v != nil {
			if s, isString := v.(string); isString {
				if v == "default" {
					index = 0 // no need to call `TryMatchString` and spend time.
				} else {
					_, index, _ = i.TryMatchString(s)
				}

				locale := i.localizer.GetLocale(index)
				if locale == nil {
					return nil
				}

				return locale
			}
		}
	}

	if !ok && i.ExtractFunc != nil {
		if v := i.ExtractFunc(r); v != "" {
			_, index, ok = i.TryMatchString(v)
		}
	}

	if !ok && i.URLParameter != "" {
		if v := r.URL.Query().Get(i.URLParameter); v != "" {
			_, index, ok = i.TryMatchString(v)
		}
	}

	if !ok && i.Cookie != "" {
		cookie, err := r.Cookie(i.Cookie)
		if err == nil {
			_, index, ok = i.TryMatchString(cookie.Value) // url.QueryUnescape(cookie.Value)
		}
	}

	if !ok && i.Subdomain {
		if v, _ := getSubdomain(r); v != "" {
			_, index, ok = i.TryMatchString(v)
		}
	}

	if !ok {
		if v := r.Header.Get(acceptLanguageHeaderKey); v != "" {
			desired, _, err := language.ParseAcceptLanguage(v)
			if err == nil {
				if _, idx, conf := i.matcher.Match(desired...); conf > language.Low {
					index = idx
				}
			}
		}
	}

	// if index == 0 then it defaults to the first language.
	locale := i.localizer.GetLocale(index)
	if locale == nil {
		return nil
	}

	return locale
}

// GetMessage is package-level function which calls the `Default.GetMessage` method.
//
// See `I18n#GetMessage` method for more.
func GetMessage(r *http.Request, format string, args ...interface{}) string {
	return Default.GetMessage(r, format, args...)
}

// GetMessage returns the localized text message for this "r" request based on the key "format".
// It returns an empty string if locale or format not found.
func (i *I18n) GetMessage(r *http.Request, format string, args ...interface{}) (msg string) {
	loc := i.GetLocale(r)
	langMatched := ""
	if loc != nil {
		langMatched = loc.Language()
		// it's not the default/fallback language and not message found for that lang:key.
		msg = loc.GetMessage(format, args...)
		if msg == "" && i.DefaultMessageFunc == nil && !i.Strict && loc.Index() > 0 {
			return i.localizer.GetLocale(0).GetMessage(format, args...)
		}
	}

	if msg == "" && i.DefaultMessageFunc != nil && i.ContextKey != nil {
		if v := r.Context().Value(i.ContextKey); v != nil {
			if langInput, ok := v.(string); ok {
				msg = i.DefaultMessageFunc(langInput, langMatched, format, args...)
			}
		}
	}

	return
}

// Router is package-level function which calls the `Default.Router` method.
//
// See `I18n#Router` method for more.
func Router(next http.Handler) http.Handler {
	return Default.Router(next)
}

func (i *I18n) setLang(w http.ResponseWriter, r *http.Request, lang string) {
	if i.Cookie != "" {
		http.SetCookie(w, &http.Cookie{
			Name:  i.Cookie,
			Value: lang,
			// allow subdomain sharing.
			Domain:   getDomain(getHost(r)),
			SameSite: http.SameSiteLaxMode,
		})
	} else if i.URLParameter != "" {
		q := r.URL.Query()
		q.Set(i.URLParameter, lang)
		r.URL.RawQuery = q.Encode()
	}

	r.Header.Set(acceptLanguageHeaderKey, lang)
}

// Router returns a new router wrapper.
// It compares the path prefix for translated language and
// local redirects the requested path with the selected (from the path) language to the router.
func (i *I18n) Router(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		found := false
		path := r.URL.Path[1:]

		if idx := strings.IndexByte(path, '/'); idx > 0 {
			path = path[:idx]
		}

		if path != "" {
			if tag, _, ok := i.TryMatchString(path); ok {
				lang := tag.String()

				path = r.URL.Path[len(path)+1:]
				if path == "" {
					path = "/"
				}

				r.RequestURI = path
				r.URL.Path = path
				i.setLang(w, r, lang)
				found = true
			}
		}

		if !found && i.Subdomain {
			host := getHost(r)
			if dotIdx := strings.IndexByte(host, '.'); dotIdx > 0 {
				if subdomain := host[0:dotIdx]; subdomain != "" {
					if tag, _, ok := i.TryMatchString(subdomain); ok {
						host = host[dotIdx+1:]
						r.URL.Host = host
						r.Host = host
						i.setLang(w, r, tag.String())
					}
				}
			}
		}

		next.ServeHTTP(w, r)
	})
}

func getHost(r *http.Request) string {
	// contains subdomain.
	if host := r.URL.Host; host != "" {
		return host
	}
	return r.Host
}

// GetDomain resolves and returns the server's domain.
func getDomain(hostport string) string {
	host := hostport
	if tmp, _, err := net.SplitHostPort(hostport); err == nil {
		host = tmp
	}

	switch host {
	// We could use the netutil.LoopbackRegex but leave it as it's for now, it's faster.
	case "localhost", "127.0.0.1", "0.0.0.0", "::1", "[::1]", "0:0:0:0:0:0:0:0", "0:0:0:0:0:0:0:1":
		// loopback.
		return "localhost"
	default:
		if domain, err := publicsuffix.EffectiveTLDPlusOne(host); err == nil {
			host = domain
		}

		return host
	}
}

func getSubdomain(r *http.Request) (subdomain, host string) {
	host = getHost(r)

	if index := strings.IndexByte(host, '.'); index > 0 {
		if subdomain = host[0:index]; subdomain != "" {
			host = host[index+1:]
		}
	}

	return
}