package com.pf.test;

import java.util.List;
import java.util.Map;

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Service;

import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.service.IService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

import net.bytebuddy.ByteBuddy;
import net.bytebuddy.description.annotation.AnnotationDescription;
import net.bytebuddy.description.modifier.Visibility;
import net.bytebuddy.description.type.TypeDescription;
import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
import net.bytebuddy.implementation.MethodDelegation;
import net.bytebuddy.matcher.ElementMatchers;

public class ByteBuddyTest {

	public static void main(String[] args) {
		Class<?> entity = createEntity();
		System.out.println("entity class is created");

		Class<?> service = createService(entity);
		System.out.println("service interface is created");

		Class<?> mapper = createMapper(entity);
		System.out.println("mapper interface is created");

		createServiceImpl(mapper, entity, service);
		System.out.println("serviceImpl class is created");
	}

	private static Class<?> createEntity() {
		return new ByteBuddy().subclass(Object.class).name("com.pf.test.entity.TestEntity")
				.annotateType(AnnotationDescription.Builder.ofType(TableName.class).define("value", "test").build())
				.defineProperty("name", String.class).defineProperty("cityCode", String.class)
				.defineProperty("cityLevel", Integer.class).make()
				.load(ClassLoader.getSystemClassLoader(), ClassLoadingStrategy.Default.WRAPPER_PERSISTENT).getLoaded();
	}

	private static Class<?> createService(Class<?> entityClass) {
		return new ByteBuddy()
				.makeInterface(TypeDescription.Generic.Builder.parameterizedType(IService.class, entityClass).build())
				.name("com.pf.test.service.ITbDicService")
				.defineMethod("testMethod",
						TypeDescription.Generic.Builder
								.parameterizedType(TypeDescription.ForLoadedType.of(List.class),
										TypeDescription.Generic.Builder
												.parameterizedType(Map.class, String.class, Object.class).build())
								.build(),
						Visibility.PUBLIC)
				.withParameter(TypeDescription.Generic.Builder.parameterizedType(Map.class, String.class, Object.class)
						.build())
				.withoutCode().make()
				.load(ClassLoader.getSystemClassLoader(), ClassLoadingStrategy.Default.WRAPPER_PERSISTENT).getLoaded();
	}

	private static Class<?> createMapper(Class<?> entityClass) {
		return new ByteBuddy()
				.makeInterface(TypeDescription.Generic.Builder.parameterizedType(BaseMapper.class, entityClass).build())
				.name("com.pf.test.mapper.TbDicMapper")
				.annotateType(AnnotationDescription.Builder.ofType(Mapper.class).build())
				.defineMethod("testMethod",
						TypeDescription.Generic.Builder
								.parameterizedType(TypeDescription.ForLoadedType.of(List.class),
										TypeDescription.Generic.Builder
												.parameterizedType(Map.class, String.class, Object.class).build())
								.build(),
						Visibility.PUBLIC)
				.withParameter(TypeDescription.Generic.Builder.parameterizedType(Map.class, String.class, Object.class)
						.build())
				.annotateParameter(AnnotationDescription.Builder.ofType(Param.class).define("value", "querys").build())
				.withoutCode()
				.annotateMethod(AnnotationDescription.Builder.ofType(Select.class)
						.defineArray("value", new String[] { "select * from test" }).build())
				.make().load(ClassLoader.getSystemClassLoader(), ClassLoadingStrategy.Default.WRAPPER_PERSISTENT)
				.getLoaded();
	}

	private static Class<?> createServiceImpl(Class<?> mapperClass, Class<?> entityClass, Class<?> serviceClass) {
		return new ByteBuddy()
				.subclass(TypeDescription.Generic.Builder.parameterizedType(ServiceImpl.class, mapperClass, entityClass)
						.build())
				.implement(serviceClass).name("com.pf.test.service.impl.TbDicServiceImpl")
				.annotateType(AnnotationDescription.Builder.ofType(Service.class).build())
				.method(ElementMatchers.named("testMethod")).intercept(MethodDelegation.toField("baseMapper")).make()
				.load(ClassLoader.getSystemClassLoader(), ClassLoadingStrategy.Default.WRAPPER_PERSISTENT).getLoaded();
	}
}