package kernel.bo;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;

import javax.persistence.Column;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.BeanWrapper;
import org.springframework.beans.BeanWrapperImpl;
import org.springframework.beans.NotWritablePropertyException;
import org.springframework.beans.TypeMismatchException;
import org.springframework.core.convert.ConversionService;
import org.springframework.core.convert.support.DefaultConversionService;
import org.springframework.dao.DataRetrievalFailureException;
import org.springframework.dao.InvalidDataAccessApiUsageException;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.support.JdbcUtils;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import org.springframework.util.ReflectionUtils;
import org.springframework.util.StringUtils;

/**
 * @author JORGE
 * @description 记录映射器
 */
@SuppressWarnings({"unchecked","rawtypes"})
public class RecordObjectMapper<T> implements RowMapper<T>{
	/**
	 * 映射的JAVA类型
	 * 可以是实体或字典
	 */
	private Class<T> mappedClass;
	
	/**
	 * 是否是实体类型
	 */
	private boolean isEntity=true;
	
	/**
	 * 字典入值函数
	 */
	private static Method PUT_METHOD;
	
	/**
	 * 实体类型属性集合
	 */
	private Set<String> mappedProperties;
	
	/**
	 * 是否执行严格校验
	 */
	private boolean checkFullyPopulated=false;
	
	/**
	 * 不需要做转换的boolean类型字段集
	 */
	private Set<String> excludeBooleanFields;
	
	/**
	 * 数据库字段名到实体属性名的映射表
	 */
	private Map<String, PropertyDescriptor> mappedFields;
	
	/**
	 * 如果返回映射到基本类型字段的null值则抛出异常,
	 * 设置为false则打印警告日志并忽略赋值操作(此时基本类型属性将保持固有属性值)
	 */
	private boolean primitivesDefaultedForNullValue=false;
	
	/**
	 * 能转换为逻辑值true的所有字串集合
	 */
	public static final LinkedHashSet<String> TRUE_VALUES = new LinkedHashSet<String>();
	
	/**
	 * SLF日志工具
	 */
	private static final Logger logger=LoggerFactory.getLogger(RecordObjectMapper.class);
	
	/**
	 * 从数据库字段类型到实体属性类型的类型转换服务
	 */
	public ConversionService conversionService = DefaultConversionService.getSharedInstance();
	
	static {
		TRUE_VALUES.add("Y");
		TRUE_VALUES.add("y");
		TRUE_VALUES.add("YES");
		TRUE_VALUES.add("yes");
		TRUE_VALUES.add("TRUE");
		TRUE_VALUES.add("true");
		TRUE_VALUES.add("OK");
		TRUE_VALUES.add("ok");
		TRUE_VALUES.add("1");
		
		try {
			PUT_METHOD=Map.class.getMethod("put", Object.class,Object.class);
		} catch (NoSuchMethodException | SecurityException e) {
			throw new RuntimeException(e);
		}
	}
	
	public RecordObjectMapper(Class<T> mappedClass,Set<String> excludeBooleanFields,boolean primitivesDefaultedForNullValue) {
		this.mappedClass = mappedClass;
		this.excludeBooleanFields=excludeBooleanFields;
		this.primitivesDefaultedForNullValue=primitivesDefaultedForNullValue;
		
		if(Map.class.isAssignableFrom(mappedClass)) {
			this.isEntity=false;
		}else {
			this.isEntity=true;
			this.initialize();
		}
	}
	
	/**
	 * 初始化实体映射类型
	 * @param mappedClass 实体映射类型
	 */
	private void initialize() {
		this.mappedProperties = new HashSet<String>();
		this.mappedFields = new HashMap<String,PropertyDescriptor>();
		for (PropertyDescriptor pd:BeanUtils.getPropertyDescriptors(this.mappedClass)) {
			if (null==pd.getWriteMethod()) continue;
			String fieldName=pd.getName();
			this.mappedProperties.add(fieldName);
			this.mappedFields.put(fieldName, pd);
			this.mappedFields.put(underscoreName(fieldName), pd);
			
			Field field=ReflectionUtils.findField(this.mappedClass, fieldName);
			if(null==field) continue;
			
			Column column=field.getAnnotation(Column.class);
			if(null==column) continue;
			
			String columnName=column.name();
			if(null==columnName || (columnName=columnName.trim()).isEmpty()) continue;
			
			this.mappedFields.put(columnName, pd);
		}
	}
	
	public final Class<T> getMappedClass() {
		return this.mappedClass;
	}
	
	public boolean isCheckFullyPopulated() {
		return this.checkFullyPopulated;
	}
	
	public void setMappedClass(Class<T> mappedClass) {
		this.mappedClass = mappedClass;
		initialize();
	}
	
	public ConversionService getConversionService() {
		return this.conversionService;
	}
	
	public boolean isPrimitivesDefaultedForNullValue() {
		return this.primitivesDefaultedForNullValue;
	}
	
	public void setCheckFullyPopulated(boolean checkFullyPopulated) {
		this.checkFullyPopulated = checkFullyPopulated;
	}
	
	public void setConversionService(@Nullable ConversionService conversionService) {
		this.conversionService = conversionService;
	}
	
	public void setPrimitivesDefaultedForNullValue(boolean primitivesDefaultedForNullValue) {
		this.primitivesDefaultedForNullValue = primitivesDefaultedForNullValue;
	}
	
	public static <T> RecordObjectMapper<T> newInstance(Class<T> mappedClass,boolean... primitivesDefaultedForNullValues) {
		boolean primitivesDefaultedForNullValue=(null==primitivesDefaultedForNullValues || 0==primitivesDefaultedForNullValues.length)?true:primitivesDefaultedForNullValues[0];
		return new RecordObjectMapper<T>(mappedClass,null,primitivesDefaultedForNullValue);
	}
	
	public static <T> RecordObjectMapper<T> newInstance(Class<T> mappedClass,Set<String> excludeBooleanFields,boolean... primitivesDefaultedForNullValues) {
		boolean primitivesDefaultedForNullValue=(null==primitivesDefaultedForNullValues || 0==primitivesDefaultedForNullValues.length)?true:primitivesDefaultedForNullValues[0];
		return new RecordObjectMapper<T>(mappedClass,excludeBooleanFields,primitivesDefaultedForNullValue);
	}
	
	/**
	 * 将JAVA中驼峰命名法字段名转换为下划线命名法的数据库列名
	 * @param name 实体类中的驼峰命名法字段名
	 * @return 下划线命名法的数据库列名
	 */
	private String underscoreName(String name) {
		if (!StringUtils.hasLength(name)) return "";

		StringBuilder result = new StringBuilder();
		result.append(Character.toLowerCase(name.charAt(0)));
		for (int i = 1; i < name.length(); i++) {
			char c = name.charAt(i);
			if (Character.isUpperCase(c)) {
				result.append('_').append(Character.toLowerCase(c));
			}else {
				result.append(c);
			}
		}
		
		return result.toString();
	}
	
	/**
	 * 需要忽略映射的实体类属性名
	 * @param propertyName 实体类属性名
	 */
	public void suppressProperty(String propertyName) {
		if (null==this.mappedFields) return;
		this.mappedFields.remove(propertyName);
		this.mappedFields.remove(underscoreName(propertyName));
		
		Field field=ReflectionUtils.findField(this.mappedClass, propertyName);
		if(null==field) return;
		
		Column column=field.getAnnotation(Column.class);
		if(null==column) return;
		
		String columnName=column.name();
		if(null==columnName || (columnName=columnName.trim()).isEmpty()) return;
		
		this.mappedFields.remove(columnName);
	}
	
	/**
	 * 创建实体类实例
	 * @return 实体类实例
	 * @throws SQLException
	 */
	private T constructMappedInstance() throws SQLException  {
		Assert.state(this.mappedClass != null, "Mapped class was not specified");
		return BeanUtils.instantiateClass(this.mappedClass);
	}
	
	/**
	 * 初始化Bean包装器
	 * @param bw Bean包装器
	 */
	private void initBeanWrapper(BeanWrapper bw) {
		if(null==this.conversionService) return;
		bw.setConversionService(this.conversionService);
	}
	
	@Override
	public T mapRow(ResultSet rs, int rowNum) throws SQLException {
		try {
			if(isEntity) {
				return mapToEntity(rs,rowNum);
			}else {
				return mapToDict(rs,rowNum);
			}
		}catch(Exception e) {
			throw new SQLException(e);
		}
	}
	
	/**
	 * 映射到原始字典类型
	 * @param rs 结果集
	 * @param rowNum 当前行号
	 * @return 字典对象
	 * @throws SQLException
	 */
	private T mapToDict(ResultSet rest, int rowNum) throws Exception {
		T dictInst=null;
		if(mappedClass.isInterface()) {
			dictInst=(T)new HashMap();
		}else {
			dictInst=mappedClass.newInstance();
		}
		
		ResultSetMetaData rsmd = rest.getMetaData();
		int columnCount = rsmd.getColumnCount();
		
		for (int index=1;index<=columnCount;PUT_METHOD.invoke(dictInst,JdbcUtils.lookupColumnName(rsmd, index),JdbcUtils.getResultSetValue(rest,index++)));
		
		return dictInst;
	}
	
	/**
	 * 映射到实体类型
	 * @param rs 结果集
	 * @param rowNum 当前行号
	 * @return 实体对象
	 * @throws SQLException
	 */
	private T mapToEntity(ResultSet rest, int rowNum) throws SQLException {
		BeanWrapperImpl beanWrapper = new BeanWrapperImpl();
		initBeanWrapper(beanWrapper);

		T mappedObject = constructMappedInstance();
		beanWrapper.setBeanInstance(mappedObject);

		ResultSetMetaData rsmd = rest.getMetaData();
		int columnCount = rsmd.getColumnCount();
		Set<String> populatedProperties = checkFullyPopulated?new HashSet<String>():null;

		for (int index = 1; index <= columnCount; index++) {
			String columnName = JdbcUtils.lookupColumnName(rsmd, index);
			PropertyDescriptor pd = (this.mappedFields != null ? this.mappedFields.get(StringUtils.delete(columnName, " ")):null);
			
			if (null==pd) continue;
			if (0==rowNum) logger.debug("Mapping column '"+columnName+"' to property '"+pd.getName()+"' of type '"+ClassUtils.getQualifiedName(pd.getPropertyType())+"'");
			
			String fieldName=pd.getName();
			Class<?> fieldType=pd.getPropertyType();
			try{
				if((boolean.class!=fieldType&&Boolean.class!=fieldType) || (null!=excludeBooleanFields&&excludeBooleanFields.contains(fieldName))) {
					beanWrapper.setPropertyValue(fieldName, JdbcUtils.getResultSetValue(rest,index,fieldType));
				}else {
					Object enableVal=rest.getObject(index);
					if(null==enableVal) {
						if(boolean.class==fieldType) throw new TypeMismatchException(enableVal,fieldType);
						beanWrapper.setPropertyValue(fieldName, enableVal);
					}else if(enableVal instanceof Boolean) {
						beanWrapper.setPropertyValue(fieldName, ((Boolean)enableVal).booleanValue());
					}else if(enableVal instanceof CharSequence) {
						beanWrapper.setPropertyValue(fieldName, TRUE_VALUES.contains(enableVal.toString())?true:false);
					}else{
						beanWrapper.setPropertyValue(fieldName, (1==((Number)enableVal).intValue())?true:false);
					}
				}
				if (populatedProperties != null) populatedProperties.add(fieldName);
			}catch (TypeMismatchException e) {
				if(primitivesDefaultedForNullValue) throw e;
				logger.warn("Intercepted TypeMismatchException for row "+rowNum+" and column '"+columnName + 
						"' with null value when setting property '"+fieldName+"' of type '"+ClassUtils.getQualifiedName(fieldType)+"' on object: "+mappedObject, e);
			}catch (NotWritablePropertyException e) {
				throw new DataRetrievalFailureException("Unable to map column '"+columnName+"' to property '"+fieldName+"'", e);
			}
		}

		if (populatedProperties != null && !populatedProperties.equals(this.mappedProperties)) {
			throw new InvalidDataAccessApiUsageException("Given ResultSet does not contain all fields "+"necessary to populate object of "+this.mappedClass+": "+this.mappedProperties);
		}
		
		return mappedObject;
	}
}