i18n

func CheckMissingStrings(rootPath string, localeFile string) (map[string][]string, error)

{
	localeData, err := os.Open(localeFile)
	if err != nil {
		return nil, fmt.Errorf("failed to open locale file: %w", err)
	}
	defer localeData.Close()

	definedKeys := make(map[string]bool)
	scanner := bufio.NewScanner(localeData)

	msgidRe := regexp.MustCompile(`^msgid "(.+)"$`)

	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())
		if strings.HasPrefix(line, "msgid \"") {
			matches := msgidRe.FindStringSubmatch(line)
			if len(matches) > 1 {
				definedKeys[matches[1]] = true
			}
		}
	}

	if err := scanner.Err(); err != nil {
		return nil, fmt.Errorf("error reading locale file: %w", err)
	}

	sourceRe := regexp.MustCompile(`\.Trans\("([\S.]+)"`)
	prRe := regexp.MustCompile(`pr:([\w\.]+)`)
	missing := make(map[string][]string)

	err = filepath.WalkDir(rootPath, func(path string, d fs.DirEntry, err error) error {
		if err != nil {
			return err
		}
		if d.IsDir() {
			if d.Name() == ".git" || d.Name() == "vendor" {
				return filepath.SkipDir
			}
			return nil
		}
		if !strings.HasSuffix(d.Name(), ".go") {
			return nil
		}

		content, err := os.ReadFile(path)
		if err != nil {
			return nil
		}

		matches := sourceRe.FindAllStringSubmatch(string(content), -1)
		matches = append(matches, prRe.FindAllStringSubmatch(string(content), -1)...)
		for _, match := range matches {
			if len(match) < 2 {
				continue
			}
			key := match[1]
			if !definedKeys[key] {
				seen := false
				for _, k := range missing[path] {
					if k == key {
						seen = true
						break
					}
				}
				if !seen {
					missing[path] = append(missing[path], key)
				}
			}
		}

		return nil
	})

	if err != nil {
		return nil, err
	}

	return missing, nil
}

func NewLocalizer(localeFS fs.FS, defaultDomain string, locale string) (*spreak.Localizer, error)

{
	foundLocale, err := language.Parse(locale)
	if err != nil {
		foundLocale = language.English
	}

	// we need to get the supported languages from the locales file system
	// to do so we expect a LINGUAS file to be present
	linguas, err := fs.ReadFile(localeFS, "LINGUAS")
	if err != nil {
		return nil, fmt.Errorf("no LINGUAS file found: %v", err)
	}

	// spreak.WithLanguage requires a slice of interfaces
	supportedLanguages := make([]interface{}, 0)
	for _, l := range strings.Split(string(linguas), "\n") {
		if l == "" {
			continue
		}
		supportedLanguages = append(supportedLanguages, language.MustParse(l))
	}

	// we need to create a new bundle for the localizer, here we use the RDNN
	// as the default localizer domain
	bundle, err := spreak.NewBundle(
		spreak.WithSourceLanguage(language.MustParse("qaa")),
		spreak.WithDefaultDomain(defaultDomain),
		spreak.WithFilesystemLoader(defaultDomain,
			spreak.WithFs(localeFS),
			spreak.WithPoDecoder(),
			spreak.WithMoDecoder(),
		),
		spreak.WithRequiredLanguage(foundLocale),
		spreak.WithLanguage(supportedLanguages...),
	)
	if err != nil {
		return nil, err
	}

	return spreak.NewLocalizer(bundle, foundLocale), nil
}