package com.zy.common.i18n;

import com.core.common.Cools;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.ClassPathResource;
import org.springframework.stereotype.Service;
import org.springframework.context.i18n.LocaleContextHolder;

import java.io.File;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.text.MessageFormat;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;

@Service
public class I18nMessageService {

    private static final String MESSAGE_BUNDLE = "messages";
    private static final String LEGACY_BUNDLE = "legacy";

    private final Map<String, CacheEntry> cache = new ConcurrentHashMap<>();

    @Autowired
    private I18nProperties properties;

    public Locale getCurrentLocale() {
        Locale locale = LocaleContextHolder.getLocale();
        return locale == null ? I18nLocaleUtils.defaultLocale(properties) : locale;
    }

    public Locale resolveLocale(String requested) {
        return I18nLocaleUtils.resolveLocale(requested, properties);
    }

    public String getDefaultLocaleTag() {
        return properties.getDefaultLocale();
    }

    public List<String> getSupportedLocaleTags() {
        return properties.getSupportedLocales();
    }

    public String getMessage(String key, Object... args) {
        return getMessage(key, getCurrentLocale(), args);
    }

    public String getMessage(String key, Locale locale, Object... args) {
        if (Cools.isEmpty(key)) {
            return "";
        }
        Locale resolvedLocale = locale == null ? I18nLocaleUtils.defaultLocale(properties) : locale;
        String value = mergedBundle(resolvedLocale, MESSAGE_BUNDLE).get(key);
        if (value == null && !I18nLocaleUtils.isDefaultLocale(resolvedLocale, properties)) {
            value = mergedBundle(I18nLocaleUtils.defaultLocale(properties), MESSAGE_BUNDLE).get(key);
        }
        if (value == null) {
            return key;
        }
        return args == null || args.length == 0 ? value : MessageFormat.format(value, args);
    }

    public boolean hasMessage(String key, Locale locale) {
        return mergedBundle(locale == null ? I18nLocaleUtils.defaultLocale(properties) : locale, MESSAGE_BUNDLE).containsKey(key);
    }

    public Map<String, String> getMessages(Locale locale) {
        return new LinkedHashMap<>(mergedBundle(locale, MESSAGE_BUNDLE));
    }

    public Map<String, String> getLegacyMessages(Locale locale) {
        return new LinkedHashMap<>(mergedBundle(locale, LEGACY_BUNDLE));
    }

    public String translateLegacy(String text) {
        return translateLegacy(text, getCurrentLocale());
    }

    public String translateLegacy(String text, Locale locale) {
        if (Cools.isEmpty(text)) {
            return text;
        }
        Locale resolvedLocale = locale == null ? I18nLocaleUtils.defaultLocale(properties) : locale;
        if (I18nLocaleUtils.isDefaultLocale(resolvedLocale, properties)) {
            return text;
        }
        Map<String, String> bundle = mergedBundle(resolvedLocale, LEGACY_BUNDLE);
        String direct = directTranslate(text, bundle);
        if (!text.equals(direct)) {
            return direct;
        }
        String regex = regexTranslate(text, bundle);
        if (!text.equals(regex)) {
            return regex;
        }
        return fragmentTranslate(text, bundle);
    }

    public String resolveResourceText(String fallbackName, String code, Long id) {
        Locale locale = getCurrentLocale();
        String key = resourceKey(code, id);
        if (hasMessage(key, locale)) {
            return getMessage(key, locale);
        }
        if (!I18nLocaleUtils.isDefaultLocale(locale, properties)) {
            String humanized = I18nLocaleUtils.humanizeCode(code);
            if (!Cools.isEmpty(humanized)) {
                return humanized;
            }
        }
        return fallbackName;
    }

    public String resolvePermissionText(String fallbackName, String action, Long id) {
        Locale locale = getCurrentLocale();
        String key = permissionKey(action, id);
        if (hasMessage(key, locale)) {
            return getMessage(key, locale);
        }
        if (!I18nLocaleUtils.isDefaultLocale(locale, properties)) {
            String humanized = I18nLocaleUtils.humanizeCode(action);
            if (!Cools.isEmpty(humanized)) {
                return humanized;
            }
        }
        return fallbackName;
    }

    public String resourceKey(String code, Long id) {
        return "resource." + normalizeKey(code, id, "resource");
    }

    public String permissionKey(String action, Long id) {
        return "permission." + normalizeKey(action, id, "permission");
    }

    private Map<String, String> mergedBundle(Locale locale, String bundleName) {
        Locale resolvedLocale = locale == null ? I18nLocaleUtils.defaultLocale(properties) : locale;
        LinkedHashMap<String, String> merged = new LinkedHashMap<>();
        Locale defaultLocale = I18nLocaleUtils.defaultLocale(properties);
        merged.putAll(loadBundle(defaultLocale, bundleName));
        if (!I18nLocaleUtils.toTag(defaultLocale).equalsIgnoreCase(I18nLocaleUtils.toTag(resolvedLocale))) {
            merged.putAll(loadBundle(resolvedLocale, bundleName));
        }
        return merged;
    }

    private Map<String, String> loadBundle(Locale locale, String bundleName) {
        String localeTag = I18nLocaleUtils.toTag(locale);
        String cacheKey = localeTag + ":" + bundleName;
        CacheEntry cacheEntry = cache.get(cacheKey);
        File externalFile = externalBundle(localeTag, bundleName);
        long refreshMillis = Math.max(1, properties.getRefreshSeconds()) * 1000L;
        long externalLastModified = externalFile.exists() ? externalFile.lastModified() : -1L;
        if (cacheEntry != null
                && (System.currentTimeMillis() - cacheEntry.loadedAt) < refreshMillis
                && cacheEntry.externalLastModified == externalLastModified) {
            return cacheEntry.values;
        }
        synchronized (cache.computeIfAbsent(cacheKey, key -> new CacheEntry())) {
            CacheEntry latest = cache.get(cacheKey);
            if (latest != null
                    && (System.currentTimeMillis() - latest.loadedAt) < refreshMillis
                    && latest.externalLastModified == externalLastModified) {
                return latest.values;
            }
            LinkedHashMap<String, String> values = new LinkedHashMap<>();
            readClasspathBundle(values, localeTag, bundleName);
            readExternalBundle(values, externalFile);
            CacheEntry updated = new CacheEntry();
            updated.values = values;
            updated.loadedAt = System.currentTimeMillis();
            updated.externalLastModified = externalLastModified;
            cache.put(cacheKey, updated);
            return updated.values;
        }
    }

    private void readClasspathBundle(Map<String, String> values, String localeTag, String bundleName) {
        ClassPathResource resource = new ClassPathResource("i18n/" + localeTag + "/" + bundleName + ".properties");
        if (!resource.exists()) {
            return;
        }
        try (InputStream inputStream = resource.getInputStream()) {
            loadProperties(values, inputStream);
        } catch (IOException ex) {
            throw new IllegalStateException("Failed to load classpath i18n bundle: " + resource.getPath(), ex);
        }
    }

    private void readExternalBundle(Map<String, String> values, File file) {
        if (!file.exists() || !file.isFile()) {
            return;
        }
        try (InputStream inputStream = new FileInputStream(file)) {
            loadProperties(values, inputStream);
        } catch (IOException ex) {
            throw new IllegalStateException("Failed to load external i18n bundle: " + file.getAbsolutePath(), ex);
        }
    }

    private void loadProperties(Map<String, String> values, InputStream inputStream) throws IOException {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))) {
            String line;
            while ((line = reader.readLine()) != null) {
                parsePropertyLine(values, line);
            }
        }
    }

    private void parsePropertyLine(Map<String, String> values, String line) {
        if (line == null) {
            return;
        }
        String trimmed = line.trim();
        if (trimmed.isEmpty() || trimmed.startsWith("#") || trimmed.startsWith("!")) {
            return;
        }
        int separatorIndex = findSeparator(line);
        String rawKey = separatorIndex >= 0 ? line.substring(0, separatorIndex) : line;
        String rawValue = separatorIndex >= 0 ? line.substring(separatorIndex + 1) : "";
        while (!rawValue.isEmpty() && Character.isWhitespace(rawValue.charAt(0))) {
            rawValue = rawValue.substring(1);
        }
        String key = unescapePropertyToken(rawKey);
        String value = unescapePropertyToken(rawValue);
        if (!key.isEmpty()) {
            values.put(key, value);
        }
    }

    private int findSeparator(String line) {
        boolean escaping = false;
        for (int i = 0; i < line.length(); i++) {
            char ch = line.charAt(i);
            if (escaping) {
                escaping = false;
                continue;
            }
            if (ch == '\\') {
                escaping = true;
                continue;
            }
            if (ch == '=' || ch == ':') {
                return i;
            }
        }
        return -1;
    }

    private String unescapePropertyToken(String text) {
        StringBuilder builder = new StringBuilder(text.length());
        boolean escaping = false;
        for (int i = 0; i < text.length(); i++) {
            char ch = text.charAt(i);
            if (!escaping) {
                if (ch == '\\') {
                    escaping = true;
                } else {
                    builder.append(ch);
                }
                continue;
            }
            switch (ch) {
                case 't':
                    builder.append('\t');
                    break;
                case 'r':
                    builder.append('\r');
                    break;
                case 'n':
                    builder.append('\n');
                    break;
                case 'f':
                    builder.append('\f');
                    break;
                case 'u':
                    if (i + 4 < text.length()) {
                        String hex = text.substring(i + 1, i + 5);
                        try {
                            builder.append((char) Integer.parseInt(hex, 16));
                            i += 4;
                            break;
                        } catch (NumberFormatException ex) {
                            builder.append('u');
                            break;
                        }
                    }
                    builder.append('u');
                    break;
                default:
                    builder.append(ch);
                    break;
            }
            escaping = false;
        }
        if (escaping) {
            builder.append('\\');
        }
        return builder.toString();
    }

    private File externalBundle(String localeTag, String bundleName) {
        return new File(properties.getPackPath(), localeTag + File.separator + bundleName + ".properties");
    }

    private String directTranslate(String text, Map<String, String> bundle) {
        String trimmed = text.trim();
        String translated = bundle.get(trimmed);
        if (translated == null) {
            return text;
        }
        return preserveOuterWhitespace(text, translated);
    }

    private String regexTranslate(String text, Map<String, String> bundle) {
        String trimmed = text == null ? "" : text.trim();
        for (Map.Entry<String, String> entry : bundle.entrySet()) {
            String key = entry.getKey();
            if (Cools.isEmpty(key) || !key.startsWith("regex:")) {
                continue;
            }
            String patternText = key.substring("regex:".length());
            if (Cools.isEmpty(patternText)) {
                continue;
            }
            try {
                Pattern pattern = Pattern.compile(patternText);
                if (!trimmed.isEmpty()) {
                    Matcher trimmedMatcher = pattern.matcher(trimmed);
                    if (trimmedMatcher.matches()) {
                        return preserveOuterWhitespace(text, trimmedMatcher.replaceAll(entry.getValue()));
                    }
                }
                Matcher matcher = pattern.matcher(text);
                if (matcher.find()) {
                    return matcher.replaceAll(entry.getValue());
                }
            } catch (PatternSyntaxException ex) {
                // Ignore invalid regex entries so a bad pack does not break all translations.
            }
        }
        return text;
    }

    private String fragmentTranslate(String text, Map<String, String> bundle) {
        List<Map.Entry<String, String>> entries = new ArrayList<>(bundle.entrySet());
        entries.sort((left, right) -> Integer.compare(right.getKey().length(), left.getKey().length()));
        String result = text;
        for (Map.Entry<String, String> entry : entries) {
            if (Cools.isEmpty(entry.getKey())
                    || entry.getKey().length() < 2
                    || entry.getKey().startsWith("regex:")
                    || entry.getKey().equals(entry.getValue())) {
                continue;
            }
            result = result.replace(entry.getKey(), entry.getValue());
        }
        return result;
    }

    private String preserveOuterWhitespace(String original, String translated) {
        String trimmed = original == null ? "" : original.trim();
        if (trimmed.isEmpty()) {
            return translated;
        }
        int leading = original.indexOf(trimmed);
        int trailing = original.length() - leading - trimmed.length();
        StringBuilder builder = new StringBuilder();
        if (leading > 0) {
            builder.append(original, 0, leading);
        }
        builder.append(translated);
        if (trailing > 0) {
            builder.append(original.substring(original.length() - trailing));
        }
        return builder.toString();
    }

    private String normalizeKey(String raw, Long id, String prefix) {
        if (Cools.isEmpty(raw)) {
            return prefix + "." + (id == null ? "unknown" : id);
        }
        String normalized = raw.replaceAll("\\.html", "");
        normalized = normalized.replaceAll("[^A-Za-z0-9]+", ".");
        normalized = normalized.replaceAll("\\.+", ".");
        normalized = normalized.replaceAll("^\\.|\\.$", "");
        if (Cools.isEmpty(normalized)) {
            return prefix + "." + (id == null ? "unknown" : id);
        }
        return normalized;
    }

    private static class CacheEntry {
        private Map<String, String> values = new LinkedHashMap<>();
        private long loadedAt;
        private long externalLastModified = -1L;
    }
}