package com.tianting.infoloop.utils;

import cn.hutool.core.date.LocalDateTimeUtil;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonParser;
import com.google.gson.TypeAdapter;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonWriter;
import com.google.protobuf.Message;
import com.google.protobuf.MessageOrBuilder;
import com.google.protobuf.util.JsonFormat;
import lombok.SneakyThrows;

import java.io.IOException;
import java.lang.reflect.Constructor;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class ProtoBeanUtil {

    private static Gson gson = getGson();

    /**
     * protoBean -> string
     *
     * @param sourceMessage protoBean
     * @return string
     */
    public static String protoToJson(MessageOrBuilder sourceMessage) {
        try {
            return JsonFormat.printer().includingDefaultValueFields().print(sourceMessage);
        } catch (Exception e) {
            throw new IllegalArgumentException("ProtoBeanUtil->toJson->errorMessage:proto序列化string异常", e);
        }
    }

    @SuppressWarnings("unchecked")
    public static <T extends Message> T jsonToProto(String json, Class<T> protoBean) {
        try {
            Constructor<T> declaredConstructor = protoBean.getDeclaredConstructor((Class<?>[]) null);
            declaredConstructor.setAccessible(Boolean.TRUE);
            T instance = declaredConstructor.newInstance();
            final var builder = instance.toBuilder();
            if (json == null || json.isEmpty() || json.trim().equals("{}")) {
                return (T) builder.build();
            }
            JsonFormat.parser().ignoringUnknownFields().merge(json, builder);
            return (T) builder.build();
        } catch (Exception e) {
            throw new IllegalArgumentException("json to proto error", e);
        }
    }

    @SuppressWarnings("unchecked")
    public static <T extends Message> List<T> jsonToProtoList(String jsonArray, Class<T> protoBean) {
        try {
            if (jsonArray == null || jsonArray.isEmpty() || jsonArray.trim().equals("[]")) {
                return new ArrayList<>();
            }
            Constructor<T> declaredConstructor = protoBean.getDeclaredConstructor();
            declaredConstructor.setAccessible(true);
            List<T> protoList = new ArrayList<>();
            JsonArray jsonElements = JsonParser.parseString(jsonArray).getAsJsonArray();
            for (JsonElement jsonElement : jsonElements) {
                T instance = declaredConstructor.newInstance();
                Message.Builder builder = instance.toBuilder();
                JsonFormat.parser().ignoringUnknownFields().merge(jsonElement.toString(), builder);
                protoList.add((T) builder.build());
            }
            return protoList;
        } catch (Exception e) {
            throw new IllegalArgumentException("jsonArray to protoList error", e);
        }
    }

    public static String protoListToJson(List<? extends Message> sourceList) {
        try {
            StringBuilder jsonArrayBuilder = new StringBuilder();
            jsonArrayBuilder.append("[");
            for (int i = 0; i < sourceList.size(); i++) {
                String json = protoToJson(sourceList.get(i));
                jsonArrayBuilder.append(json);
                if (i < sourceList.size() - 1) {
                    jsonArrayBuilder.append(",");
                }
            }
            jsonArrayBuilder.append("]");
            return jsonArrayBuilder.toString();
        } catch (Exception e) {
            throw new IllegalArgumentException("ProtoList to jsonArray error", e);
        }
    }

    /**
     * @desc: String 转 Builder对象
     */
    private static <M extends Message.Builder> void jsonToBuilder(M targetBuilder, String json) {
        try {
            JsonFormat.parser().ignoringUnknownFields().merge(JSONUtil.writeAsJson(json), targetBuilder);
        } catch (Exception e) {
            throw new IllegalArgumentException("ProtoBeanUtil->JsonToBuilder->errorMessage:json 转 Builder对象异常", e);
        }
    }

    /**
     * @desc: JavaBean 转 Builder对象
     */
    private static <M extends Message.Builder, T> M beanToBuilder(T beanSource, Class<M> targetBuilderClass) {
        try {
            Constructor<M> declaredConstructor = targetBuilderClass.getDeclaredConstructor((Class<?>[]) null);

            declaredConstructor.setAccessible(Boolean.TRUE);

            M instance = declaredConstructor.newInstance();

            Gson gson = getGson();

            String json = gson.toJson(beanSource);

            jsonToBuilder(instance, json);

            return instance;
        } catch (Exception e) {
            throw new IllegalArgumentException("ProtoBeanUtil->beanToBuilder->errorMessage:JavaBean 转 Builder对象异常", e);
        }
    }

    /**
     * @desc: javaBean 转 Proto
     */
    @SneakyThrows
    @SuppressWarnings("unchecked")
    public static <M extends Message, T> M beanToProto(T bean, Class<M> targetProtoClass) {

        Constructor<M> declaredConstructor = targetProtoClass.getDeclaredConstructor((Class<?>[]) null);

        declaredConstructor.setAccessible(Boolean.TRUE);

        M instance = declaredConstructor.newInstance();

        Gson gson = getGson();

        String json = gson.toJson(bean);

        Message.Builder builder = instance.toBuilder();

        jsonToBuilder(builder, json);

        return (M) builder.build();
    }

    /**
     * @desc: javaBean 列表 转 ProtoBean 列表
     */
    @SuppressWarnings("unchecked")
    public static <M, T extends Message> List<T> beanListToProtoList(Collection<M> beanSourceList, Class<T> protoBean) {
        try {
            List<T> resultList = new ArrayList<>();
            for (Object bean : beanSourceList) {

                Constructor<T> declaredConstructor = protoBean.getDeclaredConstructor((Class<?>[]) null);

                declaredConstructor.setAccessible(Boolean.TRUE);

                T instance = declaredConstructor.newInstance();

                Class<? extends Message.Builder> aClass = instance.toBuilder().getClass();

                Message.Builder builder = beanToBuilder(bean, aClass);

                resultList.add((T) builder.build());
            }
            return resultList;
        } catch (Exception e) {
            throw new IllegalArgumentException("ProtoBeanUtil->beanListToProtoList->errorMessage:javaBean 列表 转 ProtoBean 列表异常", e);
        }
    }

    private static Gson getGson() {
        if (gson != null) {
            return gson;
        }
        gson = new GsonBuilder()
                .registerTypeAdapter(LocalDateTime.class, new TypeAdapter<LocalDateTime>() {
                    @Override
                    public void write(JsonWriter out, LocalDateTime value) throws IOException {
                        if (value != null) {
                            out.value(LocalDateTimeUtil.toEpochMilli(value));
                        } else {
                            out.nullValue();
                        }
                    }

                    @Override
                    public LocalDateTime read(JsonReader in) throws IOException {
                        return LocalDateTimeUtil.of(Long.parseLong(in.nextString()));
                    }
                })
                .registerTypeAdapter(LocalDate.class, new TypeAdapter<LocalDate>() {
                            @Override
                            public void write(JsonWriter out, LocalDate value) throws IOException {
                                if (value != null) {
                                    out.value(LocalDateTimeUtil.toEpochMilli(value));
                                } else {
                                    out.nullValue();
                                }
                            }

                            @Override
                            public LocalDate read(JsonReader in) throws IOException {
                                return LocalDate.ofInstant(Instant.ofEpochMilli(Long.parseLong(in.nextString())), ZoneId.of("Asia/Shanghai"));
                            }
                        }
                ).create();
        return gson;
    }

}