package org.rx.socks.http;

import com.alibaba.fastjson.JSON;

import com.alibaba.fastjson.JSONObject;

import net.sf.cglib.proxy.Enhancer;

import net.sf.cglib.proxy.MethodInterceptor;

import net.sf.cglib.proxy.MethodProxy;

import org.apache.commons.lang3.ArrayUtils;

import org.rx.common.Contract;

import org.rx.beans.Tuple;

import org.rx.common.App;

import org.springframework.core.ParameterNameDiscoverer;

import org.springframework.core.PrioritizedParameterNameDiscoverer;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Parameter;

import java.lang.reflect.Proxy;

import java.util.Arrays;

import java.util.HashMap;

import java.util.Map;

import java.util.function.Function;

import static org.rx.common.Contract.isNull;

public class RestClient {

    private static class DynamicProxy implements InvocationHandler, MethodInterceptor {

        private String baseUrl, proxyHost;

        private ParameterNameDiscoverer parameterNameDiscoverer = new PrioritizedParameterNameDiscoverer();

        private DynamicProxy(String baseUrl, String proxyHost) {

            this.baseUrl = baseUrl;

            this.proxyHost = proxyHost;

        }

        @Override

        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

            if (method.getDeclaringClass().equals(Object.class)) {

                return method.invoke(proxy, args);

            }

            String apiPath = method.getName(),

                    httpMethod = ArrayUtils.isEmpty(args) ? HttpClient.GetMethod : HttpClient.PostMethod;

            boolean isFormParam = args != null && args.length > 1;

            RestMethod restMethod = method.getDeclaredAnnotation(RestMethod.class);

            if (restMethod != null) {

                String temp = isNull(restMethod.path(), restMethod.value());

                if (!App.isNullOrEmpty(temp)) {

                    apiPath = temp;

                }

                if (!App.isNullOrEmpty(restMethod.method())) {

                    httpMethod = restMethod.method();

                }

                isFormParam = restMethod.isFormParam();

            }

            String url = String.format("%s/%s", baseUrl, apiPath);

            HttpClient client = new HttpClient();

            client.setProxyHost(proxyHost);

            if (App.equals(httpMethod, HttpClient.GetMethod, true)) {

                return setResult(method, client.httpGet(url));

            }

            Parameter[] parameters = method.getParameters();

            String[] parameterNames = parameterNameDiscoverer.getParameterNames(method);

            Function<Integer, String> func = offset -> !ArrayUtils.isEmpty(parameterNames)

                    && parameters.length == parameterNames.length ? parameterNames[offset]

                    : parameters[offset].getName();

            System.out.println(method.getDeclaringClass().getName() + " pNames: " + Arrays.toString(parameterNames));

            if (!isFormParam && parameters.length == 1) {

                return setResult(method, client.httpPost(url, args[0]));

            }

            if (!isFormParam) {

                JSONObject jsonEntity = new JSONObject();

                for (int i = 0; i < parameters.length; i++) {

                    Parameter p = parameters[i];

                    RestParam restParam = p.getDeclaredAnnotation(RestParam.class);

                    jsonEntity.put(restParam != null ? isNull(restParam.name(), restParam.value()) : func.apply(i),

                            args[i]);

                }

                return setResult(method, client.httpPost(url, jsonEntity));

            }

            Map<String, String> params = new HashMap<>();

            for (int i = 0; i < parameters.length; i++) {

                Parameter p = parameters[i];

                RestParam restParam = p.getDeclaredAnnotation(RestParam.class);

                params.put(restParam != null ? isNull(restParam.name(), restParam.value()) : func.apply(i),

                        Contract.toJsonString(args[i]));

            }

            return setResult(method, client.httpPost(url, params));

        }

        @Override

        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

            return invoke(o, method, objects);

        }

        private Object setResult(Method method, String resText) {

            Class<?> returnType = method.getReturnType();

            if (returnType.equals(Void.TYPE)) {

                return Void.TYPE;

            }

            Tuple<Boolean, ?> r = App.tryConvert(resText, returnType);

            System.out.println(r.left + "," + r.right + "=>" + resText + "," + returnType);

            return r.left ? r.right : JSON.toJavaObject(JSON.parseObject(resText), returnType);

        }

    }

    public static <T> T create(Class<? extends T> restInterface, String baseUrl) {

        return create(restInterface, baseUrl, null, true);

    }

    public static <T> T create(Class<? extends T> restInterface, String baseUrl, String proxyHost, boolean byCglib) {

        DynamicProxy handler = new DynamicProxy(baseUrl, proxyHost);

        return (T) (byCglib ? Enhancer.create(restInterface, handler)

                : Proxy.newProxyInstance(handler.getClass().getClassLoader(), new Class[]{restInterface}, handler));

    }

}

package org.rx.socks.http;

import java.lang.annotation.*;

@Target(ElementType.METHOD)

@Retention(RetentionPolicy.RUNTIME)

@Documented

public @interface RestMethod {

    String value() default "";

    String path() default "";

    String method() default "POST";

    boolean isFormParam() default false;

}

package org.rx.socks.http;

import java.lang.annotation.*;

@Target(ElementType.PARAMETER)

@Retention(RetentionPolicy.RUNTIME)

@Documented

public @interface RestParam {

    String value() default "";

    String name() default "";

}

package org.rx.test.bean;

import org.rx.socks.http.RestMethod;

public interface RestApi {

    @RestMethod(method = "GET")

    void test();

    int add(@org.rx.socks.http.RestParam("a") int a, @org.rx.socks.http.RestParam("b") int b);

    String login(@org.rx.socks.http.RestParam("userId") String uid, @org.rx.socks.http.RestParam("pwd") String pwd);

    @RestMethod("/add24")

    RestResult add2(RestParam param);

}

    @Test

    public void testRest() {

        String proxy = null;

        proxy = "127.0.0.1:8888";

        RestApi client = RestClient.create(RestApi.class, "http://localhost:8081", proxy, true);

        System.out.println(client.getClass());

        client.test();

        client.add(1, 1);

        client.login("Rocky", "abc123");

        RestParam p = new RestParam();

        p.setA(12);

        p.setB(12);

        client.add2(p);

    }