package com.imyeyu.api.util;

import com.fasterxml.jackson.databind.JsonNode;
import com.imyeyu.api.annotation.MultilingualField;
import com.imyeyu.api.modules.common.entity.Multilingual;
import com.imyeyu.api.modules.common.service.MultilingualService;
import com.imyeyu.java.TimiJava;
import com.imyeyu.java.bean.Language;
import com.imyeyu.spring.TimiSpring;
import com.imyeyu.utils.StringInterpolator;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.io.File;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.nio.file.Path;
import java.time.temporal.TemporalAccessor;
import java.util.ArrayList;
import java.util.Collection;
import java.util.IdentityHashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 统一回填响应对象中的多语言字段
 *
 * @author 夜雨
 * @since 2026-07-17 00:00
 */
@Slf4j
@Component
@RequiredArgsConstructor
public class MultilingualFieldBinder {

	private static final StringInterpolator INTERPOLATOR = new StringInterpolator(StringInterpolator.SIMPLE_OBJ);
	private static final Map<Class<?>, List<Field>> TRAVERSE_CACHE = new ConcurrentHashMap<>();
	private static final Map<Class<?>, List<BindingField>> BINDING_CACHE = new ConcurrentHashMap<>();

	private final MultilingualService multilingualService;

	/**
	 * 根据当前请求语言回填对象中的多语言字段
	 *
	 * @param body 响应对象
	 */
	public void bind(Object body) {
		if (body == null) {
			return;
		}
		LinkedHashSet<String> langIdSet = new LinkedHashSet<>();
		// 第一遍只收集多语言 ID，避免递归回填时重复查询
		collectLangId(body, new IdentityHashMap<>(), langIdSet);
		if (langIdSet.isEmpty()) {
			return;
		}
		Map<String, Multilingual> multilingualMap = new LinkedHashMap<>();
		for (Multilingual item : multilingualService.listByIdList(new ArrayList<>(langIdSet))) {
			multilingualMap.put(item.getId(), item);
		}
		// 第二遍执行字段回填，模板替换也在这一遍统一完成
		fillValue(body, new IdentityHashMap<>(), multilingualMap, TimiSpring.getLanguage());
	}

	/**
	 * 递归扫描响应对象，提取所有待翻译字段依赖的多语言 ID
	 *
	 * @param current 当前对象
	 * @param visited 已访问对象，避免循环引用死递归
	 * @param langIdSet 收集到的多语言 ID
	 */
	private void collectLangId(Object current, IdentityHashMap<Object, Boolean> visited, LinkedHashSet<String> langIdSet) {
		switch (current) {
			case null -> {
				return;
			}
			case Collection<?> collection -> {
				if (visited.put(current, Boolean.TRUE) != null) {
					return;
				}
				for (Object item : collection) {
					collectLangId(item, visited, langIdSet);
				}
				return;
			}
			case Map<?, ?> map -> {
				if (visited.put(current, Boolean.TRUE) != null) {
					return;
				}
				for (Object item : map.values()) {
					collectLangId(item, visited, langIdSet);
				}
				return;
			}
			default -> {
			}
		}
		if (current.getClass().isArray()) {
			if (visited.put(current, Boolean.TRUE) != null) {
				return;
			}
			int length = Array.getLength(current);
			for (int i = 0; i < length; i++) {
				collectLangId(Array.get(current, i), visited, langIdSet);
			}
			return;
		}
		if (isSimpleValueType(current.getClass())) {
			return;
		}
		if (visited.put(current, Boolean.TRUE) != null) {
			return;
		}
		for (BindingField field : getBindingFields(current.getClass())) {
			String langId = getStringValue(field.langIdField(), current);
			if (TimiJava.isNotEmpty(langId)) {
				langIdSet.add(langId);
			}
		}
		for (Field field : getTraverseFields(current.getClass())) {
			collectLangId(getFieldValue(field, current), visited, langIdSet);
		}
	}

	/**
	 * 递归回填响应对象中的多语言展示字段
	 *
	 * @param current 当前对象
	 * @param visited 已访问对象，避免循环引用死递归
	 * @param multilingualMap 本次响应涉及的多语言缓存
	 * @param language 当前请求语言
	 */
	private void fillValue(Object current, IdentityHashMap<Object, Boolean> visited, Map<String, Multilingual> multilingualMap, Language.Enum language) {
		if (current == null) {
			return;
		}
		if (current instanceof Collection<?> collection) {
			if (visited.put(current, Boolean.TRUE) != null) {
				return;
			}
			for (Object item : collection) {
				fillValue(item, visited, multilingualMap, language);
			}
			return;
		}
		if (current instanceof Map<?, ?> map) {
			if (visited.put(current, Boolean.TRUE) != null) {
				return;
			}
			for (Object item : map.values()) {
				fillValue(item, visited, multilingualMap, language);
			}
			return;
		}
		if (current.getClass().isArray()) {
			if (visited.put(current, Boolean.TRUE) != null) {
				return;
			}
			int length = Array.getLength(current);
			for (int i = 0; i < length; i++) {
				fillValue(Array.get(current, i), visited, multilingualMap, language);
			}
			return;
		}
		if (isSimpleValueType(current.getClass())) {
			return;
		}
		if (visited.put(current, Boolean.TRUE) != null) {
			return;
		}
		for (BindingField field : getBindingFields(current.getClass())) {
			String langId = getStringValue(field.langIdField(), current);
			if (TimiJava.isEmpty(langId)) {
				continue;
			}
			Multilingual multilingual = multilingualMap.get(langId);
			if (multilingual == null) {
				continue;
			}
			String value = multilingual.getValue(language);
			if (TimiJava.isEmpty(value)) {
				value = multilingual.getZhCN();
			}
			if (TimiJava.isEmpty(value)) {
				continue;
			}
			Map<String, Object> argMap = getArgMapValue(field.argMapField(), current);
			if (!argMap.isEmpty()) {
				value = INTERPOLATOR.inject(value, argMap);
			}
			if (TimiJava.isEmpty(value)) {
				continue;
			}
			setFieldValue(field.targetField(), current, value);
		}
		for (Field field : getTraverseFields(current.getClass())) {
			fillValue(getFieldValue(field, current), visited, multilingualMap, language);
		}
	}

	private List<BindingField> getBindingFields(Class<?> clazz) {
		return BINDING_CACHE.computeIfAbsent(clazz, key -> {
			Map<String, Field> fieldMap = new LinkedHashMap<>();
			List<Field> declaredFieldList = getAllFields(key);
			for (Field field : declaredFieldList) {
				fieldMap.put(field.getName(), field);
			}
			List<BindingField> result = new ArrayList<>();
			for (Field field : declaredFieldList) {
				MultilingualField annotation = field.getAnnotation(MultilingualField.class);
				if (annotation == null) {
					continue;
				}
				Field langIdField = fieldMap.get(annotation.value());
				if (langIdField == null) {
					log.warn("MultilingualField 配置错误，类 {} 不存在字段 {}", key.getName(), annotation.value());
					continue;
				}
				Field argMapField = null;
				if (TimiJava.isNotEmpty(annotation.argMap())) {
					argMapField = fieldMap.get(annotation.argMap());
					if (argMapField == null) {
						log.warn("MultilingualField 配置错误，类 {} 不存在字段 {}", key.getName(), annotation.argMap());
						continue;
					}
					if (!Map.class.isAssignableFrom(argMapField.getType())) {
						log.warn("MultilingualField 配置错误，类 {} 字段 {} 不是 Map", key.getName(), annotation.argMap());
						continue;
					}
				}
				result.add(new BindingField(field, langIdField, argMapField));
			}
			return result;
		});
	}

	/**
	 * 生成需要继续向下遍历的字段列表
	 *
	 * @param clazz 目标类型
	 * @return 可递归字段列表
	 */
	private List<Field> getTraverseFields(Class<?> clazz) {
		return TRAVERSE_CACHE.computeIfAbsent(clazz, key -> {
			List<Field> result = new ArrayList<>();
			for (Field field : getAllFields(key)) {
				if (Modifier.isStatic(field.getModifiers()) || field.isSynthetic()) {
					continue;
				}
				if (field.getType().isArray()
						|| Collection.class.isAssignableFrom(field.getType())
						|| Map.class.isAssignableFrom(field.getType())) {
					field.setAccessible(true);
					result.add(field);
					continue;
				}
				if (isSimpleValueType(field.getType())) {
					continue;
				}
				field.setAccessible(true);
				result.add(field);
			}
			return result;
		});
	}

	private List<Field> getAllFields(Class<?> clazz) {
		List<Field> result = new ArrayList<>();
		Class<?> current = clazz;
		while (current != null && current != Object.class) {
			for (Field field : current.getDeclaredFields()) {
				if (Modifier.isStatic(field.getModifiers()) || field.isSynthetic()) {
					continue;
				}
				field.setAccessible(true);
				result.add(field);
			}
			current = current.getSuperclass();
		}
		return result;
	}

	/**
	 * 仅接受字符串类型的 langId 字段
	 *
	 * @param field 字段
	 * @param target 对象
	 * @return 多语言 ID
	 */
	private String getStringValue(Field field, Object target) {
		Object value = getFieldValue(field, target);
		if (value instanceof String string) {
			return string;
		}
		return null;
	}

	/**
	 * 仅读取 Map 类型模板参数字段，未配置时返回空 Map
	 *
	 * @param field 字段
	 * @param target 对象
	 * @return 模板参数
	 */
	@SuppressWarnings("unchecked")
	private Map<String, Object> getArgMapValue(Field field, Object target) {
		if (field == null) {
			return Map.of();
		}
		Object value = getFieldValue(field, target);
		if (value instanceof Map<?, ?> map) {
			return (Map<String, Object>) map;
		}
		return Map.of();
	}

	private Object getFieldValue(Field field, Object target) {
		try {
			return field.get(target);
		} catch (IllegalAccessException e) {
			throw new IllegalStateException("读取字段失败: %s#%s".formatted(target.getClass().getName(), field.getName()), e);
		}
	}

	private void setFieldValue(Field field, Object target, Object value) {
		try {
			field.set(target, value);
		} catch (IllegalAccessException e) {
			throw new IllegalStateException("写入字段失败: %s#%s".formatted(target.getClass().getName(), field.getName()), e);
		}
	}

	private boolean isSimpleValueType(Class<?> clazz) {
		if (clazz.isPrimitive() || clazz.isEnum() || clazz.isAnnotation()) {
			return true;
		}
		if (CharSequence.class.isAssignableFrom(clazz)
				|| Number.class.isAssignableFrom(clazz)
				|| Boolean.class == clazz
				|| Character.class == clazz
				|| UUID.class == clazz
				|| TemporalAccessor.class.isAssignableFrom(clazz)
				|| Class.class == clazz
				|| JsonNode.class.isAssignableFrom(clazz)
				|| File.class.isAssignableFrom(clazz)
				|| Path.class.isAssignableFrom(clazz)
				|| InputStream.class.isAssignableFrom(clazz)
				|| OutputStream.class.isAssignableFrom(clazz)
				|| Reader.class.isAssignableFrom(clazz)
				|| Writer.class.isAssignableFrom(clazz)) {
			return true;
		}
		Package currentPackage = clazz.getPackage();
		if (currentPackage == null) {
			return false;
		}
		String packageName = currentPackage.getName();
		return packageName.startsWith("java.")
				|| packageName.startsWith("javax.")
				|| packageName.startsWith("jakarta.")
				|| packageName.startsWith("sun.")
				|| packageName.startsWith("com.fasterxml.jackson.");
	}

	private record BindingField(Field targetField, Field langIdField, Field argMapField) {
	}
}