package i18n

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"git.noahlan.cn/noahlan/ntool/nlog"
	"github.com/BurntSushi/toml"
	"github.com/nicksnyder/go-i18n/v2/i18n"
	"github.com/radovskyb/watcher"
	"golang.org/x/text/language"
	"gopkg.in/yaml.v3"
	"os"
	"strings"
	"sync"
	"time"
)

// Translator is a struct storing translating data.
type Translator struct {
	BundleConfig

	bundle          *i18n.Bundle
	localizerMap    map[string]*i18n.Localizer
	supportedFormat []string

	mu sync.RWMutex
}

type Option func(*Translator)

func NewTranslator(opts ...Option) *Translator {
	ret := &Translator{
		localizerMap: make(map[string]*i18n.Localizer),
		BundleConfig: defaultBundleConfig,
	}

	for _, opt := range opts {
		opt(ret)
	}

	ret.bundle = i18n.NewBundle(ret.DefaultLanguage)
	ret.RegisterUnmarshalFunc("json", json.Unmarshal)
	ret.RegisterUnmarshalFunc("toml", toml.Unmarshal)
	ret.RegisterUnmarshalFunc("yaml", yaml.Unmarshal)

	// init and watcher
	files := ret.watcher()
	lngs := make([]string, len(files))
	for i, file := range files {
		lngs[i] = filenameWithoutExt(file.Name)
		if err := ret.loadFileByPath(file.Path); err != nil {
			nlog.Debugf("load locale file err: %v\n", err)
		}
	}
	ret.configLocalizer(lngs...)

	return ret
}

func (l *Translator) RegisterUnmarshalFunc(format string, fn i18n.UnmarshalFunc) {
	if l.supportedFormat == nil {
		l.supportedFormat = make([]string, 0)
	}
	l.supportedFormat = append(l.supportedFormat, format)
	l.bundle.RegisterUnmarshalFunc(format, fn)
}

// Trans translates the message of message's ID
func (l *Translator) Trans(ctx context.Context, messageID string) string {
	s, err := l.TransAny(ctx, messageID)
	if err != nil || s == "" {
		return messageID
	}

	return s
}

// TransAny translates the message of any param
func (l *Translator) TransAny(ctx context.Context, param any) (string, error) {
	lngTag := l.TagGetter(ctx)
	if lngTag == "" {
		lngTag = l.DefaultLanguage.String()
	}
	localizer := l.getLocalizerByTag(lngTag)

	config, err := l.getLocalizeConfig(param)
	if err != nil {
		return "", err
	}

	message, err := localizer.Localize(config)
	if err != nil {
		return "", err
	}

	return message, nil
}

func (l *Translator) loadFileByPath(path string) error {
	buf, err := l.FileLoader.LoadMessage(path)
	if err != nil {
		return err
	}
	if _, err = l.bundle.ParseMessageFileBytes(buf, path); err != nil {
		return err
	}
	return nil
}

// watcher 监控给定Path的文件数据变化，实时更改localizer，以实现语言文件热更新
func (l *Translator) watcher() []struct {
	Path string
	Name string
} {
	w := watcher.New()
	w.FilterOps(watcher.Create, watcher.Remove, watcher.Write, watcher.Rename)
	w.AddFilterHook(func(info os.FileInfo, fullPath string) error {
		if info.IsDir() {
			return watcher.ErrSkip
		}
		if info.Size() <= 0 {
			return watcher.ErrSkip
		}
		name := info.Name()

		for _, format := range l.supportedFormat {
			if strings.HasSuffix(name, format) {
				return nil
			}
		}

		// 文件后缀不支持，直接跳过
		return watcher.ErrSkip
	})

	go func() {
		for {
			select {
			case event := <-w.Event:
				if event.IsDir() {
					continue
				}

				filePrefix := filenameWithoutExt(event.Name())
				lang, err := language.Parse(filePrefix)
				if err != nil {
					nlog.Debugf("cannot parse filename:%s to language.Tag, process will continue.", filePrefix)
					continue
				}
				path := event.Path
				switch event.Op {
				case watcher.Remove:
					l.removeLocalizer(lang.String())
				case watcher.Create, watcher.Write:
					if err := l.loadFileByPath(path); err != nil {
						nlog.Debugf("load locale file err [Create] or [Write], %+v", err)
						continue
					}
					l.configLocalizer(lang.String())
				case watcher.Rename:
					l.removeLocalizer(lang.String())

					newLangStr := filenameWithoutExt(path)
					newLang, err := language.Parse(newLangStr)
					if err != nil {
						continue
					}
					if err := l.loadFileByPath(path); err != nil {
						nlog.Debugf("load locale file err [Rename], %+v", err)
						continue
					}
					l.configLocalizer(newLang.String())
				}
			case err := <-w.Error:
				nlog.Errorf("watch locale file err: %+v", err)
			case <-w.Closed:
				nlog.Debugf("i18n watcher closed...")
				return
			}
		}
	}()

	if err := w.Add(l.RootPath); err != nil {
		nlog.Errorf("[i18n] watching %s err:%v", l.RootPath, err)
		w.Closed <- struct{}{}
		return nil
	}

	go func() {
		_ = w.Start(time.Second * 5)
	}()

	watchedFiles := w.WatchedFiles()

	ret := make([]struct {
		Path string
		Name string
	}, 0, len(watchedFiles))

	for path, info := range watchedFiles {
		if info.IsDir() {
			continue
		}
		if info.Size() <= 0 {
			continue
		}
		name := info.Name()

		for _, format := range l.supportedFormat {
			if strings.HasSuffix(name, format) {
				ret = append(ret, struct {
					Path string
					Name string
				}{Path: path, Name: info.Name()})
			}
		}
	}
	return ret
}

// getLocalizerByTag get localizer by language
func (l *Translator) getLocalizerByTag(tag string) *i18n.Localizer {
	l.mu.RLock()
	defer l.mu.RUnlock()

	if localizer, ok := l.localizerMap[tag]; ok {
		return localizer
	}
	return l.localizerMap[l.DefaultLanguage.String()]
}

// getLocalizerByTag get localizer by language
func (l *Translator) getLocalizeConfig(param any) (*i18n.LocalizeConfig, error) {
	switch t := param.(type) {
	case string:
		return &i18n.LocalizeConfig{
			DefaultMessage: &i18n.Message{ID: t},
		}, nil
	case *MessageWithParameter:
		// 转化 template data
		return &i18n.LocalizeConfig{
			TemplateData:   l.buildTemplateData(t.Params, t.ParamsWithName),
			DefaultMessage: &i18n.Message{ID: t.MessageID},
		}, nil
	case *i18n.LocalizeConfig:
		return t, nil
	}

	// extends localizerConfig getter
	if ret := l.LocalizeConfigGetter(l.BundleConfig, param); ret != nil {
		return ret, nil
	}

	return nil, errors.New(fmt.Sprintf("un supported localize param: %v", param))
}

// buildTemplateData 构建TemplateData
func (l *Translator) buildTemplateData(params []any, paramsWithName map[string]any) map[string]any {
	if len(params) == 0 {
		return paramsWithName
	}
	data := make(map[string]any)
	for i, param := range params {
		data[fmt.Sprintf("%s%d", l.SortedParameterPrefix, i)] = param
	}
	return data
}

// configLocalizer set localizer by language
func (l *Translator) configLocalizer(acceptLanguage ...string) {
	l.mu.Lock()
	defer l.mu.Unlock()

	for _, lng := range acceptLanguage {
		if lng == "" {
			continue
		}
		if _, ok := l.localizerMap[lng]; !ok {
			l.localizerMap[lng] = l.newLocalizer(lng)
		}
	}

	// configure default
	defaultLng := l.DefaultLanguage.String()
	if _, ok := l.localizerMap[defaultLng]; !ok {
		l.localizerMap[defaultLng] = l.newLocalizer(defaultLng)
	}
}

// removeLocalizer remove localizer by tag string
func (l *Translator) removeLocalizer(lang ...string) {
	l.mu.Lock()
	defer l.mu.Unlock()

	for _, lng := range lang {
		delete(l.localizerMap, lng)
	}
}

// newLocalizer create a localizer by language
func (l *Translator) newLocalizer(lng string) *i18n.Localizer {
	lngDefault := l.DefaultLanguage.String()
	lngs := []string{lng}

	if lng != lngDefault {
		lngs = append(lngs, lngDefault)
	}

	localizer := i18n.NewLocalizer(
		l.bundle,
		lngs...,
	)
	return localizer
}