package com.vci.ubcs.starter.web.util;


import com.vci.ubcs.starter.web.toolmodel.DateConverter;
import org.springframework.cglib.beans.BeanCopier;
import org.springframework.cglib.core.Converter;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

public class BeanUtil {
	private static final ConcurrentMap<String, BeanCopier> beanCopierMap = new ConcurrentHashMap();

	public BeanUtil() {
	}

	public static BeanCopier getBeanCopier(Class<?> source, Class<?> target, boolean useConverter) {
		String beanCopierKey = generateBeanKey(source, target);
		if (beanCopierMap.containsKey(beanCopierKey)) {
			return (BeanCopier)beanCopierMap.get(beanCopierKey);
		} else {
			BeanCopier beanCopier = BeanCopier.create(source, target, useConverter);
			beanCopierMap.putIfAbsent(beanCopierKey, beanCopier);
			return (BeanCopier)beanCopierMap.get(beanCopierKey);
		}
	}

	public static String generateBeanKey(Class<?> source, Class<?> target) {
		return source.getName() + "@" + target.getName();
	}

	public static void convert(Object source, Object target, boolean useConvert) {
		if (source != null && target != null) {
			BeanCopier beanCopier = getBeanCopier(source.getClass(), target.getClass(), useConvert);
			beanCopier.copy(source, target, useConvert ? new DeepCopyConverter(target) : null);
		}

	}

	public static void convert(Object source, Object target) {
		convert(source, target, true);
	}

	public static class DeepCopyConverter implements Converter {
		private Object target;

		public DeepCopyConverter(Object target) {
			this.target = target;
		}

		public Object convert(Object value, Class targetClazz, Object methodName) {
			if (value instanceof List) {
				List values = (List)value;
				List retList = new ArrayList(values.size());
				this.copyForCollection(values, retList, methodName);
				return retList;
			} else {
				if (value instanceof Set) {
					Set values = (Set)value;
					Set retSet = new HashSet();
					this.copyForCollection(values, retSet, methodName);
				} else if (value instanceof Vector) {
					Vector values = (Vector)value;
					Vector retVector = new Vector();
					this.copyForCollection(values, retVector, methodName);
				} else if (value instanceof Map) {
					Map values = (Map)value;
					Map retMap = new HashMap();
					Iterator var6 = values.keySet().iterator();

					while(var6.hasNext()) {
						Object key = var6.next();
						Object mapValue = values.get(key);
						String tempFieldName = methodName.toString().replace("set", "");
						String fieldName = tempFieldName.substring(0, 1).toLowerCase() + tempFieldName.substring(1);
						Class clazz = ClassUtil.getElementType(this.target.getClass(), fieldName);
						Object targetAttr = null;

						try {
							targetAttr = clazz.newInstance();
						} catch (Throwable var15) {
						}

						BeanUtil.convert(mapValue, targetAttr);
						retMap.put(key, targetAttr);
					}
				} else if (!ClassUtil.isPrimitive(targetClazz)) {
					Object targetAttr = null;

					try {
						targetAttr = targetClazz.newInstance();
					} catch (Throwable var14) {
					}

					BeanUtil.convert(value, targetAttr);
					return targetAttr;
				}

				if (value instanceof Boolean && targetClazz.equals(String.class)) {
					return String.valueOf(value);
				} else if (!(value instanceof String) || !targetClazz.equals(Boolean.class) && !targetClazz.equals(Boolean.TYPE)) {
					if (value instanceof Date && targetClazz.equals(String.class)) {
						return VciDateUtil.date2Str((Date)value, "yyyy-MM-dd HH:mm:ss.SSS");
					} else if (value instanceof String && targetClazz.equals(Date.class)) {
						DateConverter dateConverter = new DateConverter();
						dateConverter.setAsText((String)value);
						return dateConverter.getValue();
					} else {
						return value;
					}
				} else {
					return "true".equalsIgnoreCase((String)value) ? true : false;
				}
			}
		}

		private void copyForCollection(Collection<?> sourceCollection, Collection targetCollection, Object methodName) {
			Iterator var4 = sourceCollection.iterator();

			while(true) {
				while(var4.hasNext()) {
					Object source = var4.next();
					if (source instanceof Collection) {
						List<Object> targetValues = new ArrayList();
						this.copyForCollection((Collection)source, targetValues, methodName);
						targetCollection.add(targetValues);
					} else {
						String tempFieldName;
						String fieldName;
						Class clazz;
						Object targetAttr;
						if (!(source instanceof Map)) {
							tempFieldName = methodName.toString().replace("set", "");
							fieldName = tempFieldName.substring(0, 1).toLowerCase() + tempFieldName.substring(1);
							clazz = ClassUtil.getElementType(this.target.getClass(), fieldName);
							targetAttr = null;

							try {
								targetAttr = clazz.newInstance();
							} catch (Throwable var13) {
							}

							BeanUtil.convert(source, targetAttr);
							targetCollection.add(targetAttr);
						} else {
							tempFieldName = methodName.toString().replace("set", "");
							fieldName = tempFieldName.substring(0, 1).toLowerCase() + tempFieldName.substring(1);
							clazz = ClassUtil.getElementType(this.target.getClass(), fieldName);
							targetAttr = null;

							try {
								targetAttr = clazz.newInstance();
							} catch (Throwable var14) {
							}

							Map map = (Map)source;
							Iterator var11 = map.keySet().iterator();

							while(var11.hasNext()) {
								Object key = var11.next();
								VciBaseUtil.setValueForField(key.toString(), targetAttr, VciBaseUtil.getStringValueFromObject(map.get(key)));
							}

							targetCollection.add(targetAttr);
						}
					}
				}

				return;
			}
		}
	}
}