package com.tianting.infoloop.utils;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.protobuf.GeneratedMessageV3;
import com.infoloop.tianting.clientcustomerorderservice.CloseTimeType;
import com.infoloop.tianting.clientcustomerorderservice.CustomerNotice;
import com.infoloop.tianting.clientcustomerorderservice.MealDetail;
import com.infoloop.tianting.clientcustomerorderservice.OrderSourceEnum;
import com.infoloop.tianting.clientcustomerorderservice.OrderStatusEnum;
import com.infoloop.tianting.clientcustomerorderservice.OrderTypeEnum;
import com.infoloop.tianting.clientcustomerorderservice.PayStatusEnum;
import com.infoloop.tianting.clientcustomerorderservice.ServeStatusEnum;
import com.infoloop.tianting.clientcustomerorderservice.SingleClientCustomerOrderDetailRpcResponse;
import com.infoloop.tianting.clientcustomerorderservice.SingleClientCustomerOrderRpcResponse;
import com.tianting.infoloop.model.db.OrderDb;
import com.tianting.infoloop.model.db.OrderDetailDb;
import java.lang.reflect.Constructor;
import java.time.ZoneOffset;
import java.util.ArrayList;
import java.util.List;

public class DbToProtoUtil {

  private static final ObjectMapper objectMapper = new ObjectMapper();

  // 将单个OrderDb对象转换为SingleClientCustomerOrderRpcResponse的ProtoBuf消息
  public static SingleClientCustomerOrderRpcResponse orderDbToProto(OrderDb orderDb) throws Exception {
    // 获取SingleClientCustomerOrderRpcResponse的Builder
    SingleClientCustomerOrderRpcResponse.Builder protoBuilder =
        SingleClientCustomerOrderRpcResponse.newBuilder();

// 基本字段赋值
    protoBuilder.setId(orderDb.getId())
        .setOrderCode(orderDb.getOrderCode())
        .setEnterpriseId(orderDb.getEnterpriseId())
        .setClientId(orderDb.getClientId())
        .setStallId(orderDb.getStallId());
    if (orderDb.getCustomerId() != null) {
      protoBuilder.setCustomerId(orderDb.getCustomerId());
    }

    if (orderDb.getOpenId()!= null) {
      protoBuilder.setOpenId(orderDb.getOpenId());
    }

    if (orderDb.getStatus()!= null) {
      protoBuilder.setStatus(OrderStatusEnum.forNumber(orderDb.getStatus()));
    }

    protoBuilder.setMenuId(orderDb.getMenuId())
        .setCloseTimeType(CloseTimeType.forNumber(orderDb.getCloseTimeType()))
        .setTotalNum(orderDb.getTotalNum());
    if(orderDb.getPayPrice() != null) {
      protoBuilder.setPayPrice(orderDb.getPayPrice());
    }

    if (orderDb.getOnlinePay()!= null) {
      protoBuilder.setOnlinePay(orderDb.getOnlinePay());
    }

    if (orderDb.getPayStatus()!= null) {
      protoBuilder.setPayStatus(PayStatusEnum.forNumber(orderDb.getPayStatus()));
    }
    if (orderDb.getErrorMsg() != null) {
      protoBuilder.setErrorMsg(orderDb.getErrorMsg());
    }

    if (orderDb.getTransactionId() != null){
      protoBuilder.setTransactionId(orderDb.getTransactionId());
    }

    if (orderDb.getMealTime()!= null) {
      protoBuilder.setMealTime(orderDb.getMealTime().toEpochSecond(ZoneOffset.UTC) * 1000);
    }

    if (orderDb.getAddress() != null) {
      protoBuilder.setAddress(orderDb.getAddress());
    }

    if(orderDb.getRoomNo() != null) {
      protoBuilder.setRoomNo(orderDb.getRoomNo());
    }

    if(orderDb.getTableCode() != null) {
      protoBuilder.setTableCode(orderDb.getTableCode());
    }

    if(orderDb.getPickupCode() != null) {
      protoBuilder.setPickupCode(orderDb.getPickupCode());
    }

    if (orderDb.getOrderType()!= null) {
      protoBuilder.setOrderType(OrderTypeEnum.forNumber(orderDb.getOrderType()));
    }

    if (orderDb.getRemark() != null) {
      protoBuilder.setRemark(orderDb.getRemark());
    }

    protoBuilder.setCreatedBy(orderDb.getCreatedBy())
        .setCreatedAt(orderDb.getCreatedAt().toEpochSecond(ZoneOffset.UTC) * 1000);

    if (orderDb.getCreationSource()!= null) {
      protoBuilder.setCreationSource(OrderSourceEnum.forNumber(orderDb.getCreationSource()));
    }

    protoBuilder.setUpdatedBy(orderDb.getUpdatedBy())
        .setUpdatedAt(orderDb.getUpdatedAt().toEpochSecond(ZoneOffset.UTC) * 1000);

    if (orderDb.getUpdateSource()!= null) {
      protoBuilder.setUpdateSource(OrderSourceEnum.forNumber(orderDb.getUpdateSource()));
    }

    if (orderDb.getIsDeleted()!= null) {
      protoBuilder.setIsDeleted(orderDb.getIsDeleted());
    }

    if (orderDb.getIsRead()!= null) {
      protoBuilder.setIsRead(orderDb.getIsRead());
    }

    if (orderDb.getIsConfirm()!= null) {
      protoBuilder.setIsConfirm(orderDb.getIsConfirm());
    }

    if (orderDb.getIsAllocation()!= null) {
      protoBuilder.setIsAllocation(orderDb.getIsAllocation());
    }

    // 处理嵌套的CustomerNotice字段
    if (orderDb.getCustomerNoticeJson()!= null) {
//      Constructor<CustomerNotice> customerNoticeConstructor =
//          CustomerNotice.class.getDeclaredConstructor();
//      customerNoticeConstructor.setAccessible(true);
//      CustomerNotice customerNoticeProto = customerNoticeConstructor.newInstance();

      CustomerNotice.Builder customerNoticeProto =
          CustomerNotice.newBuilder();

      JsonNode avoidsNode = orderDb.getCustomerNoticeJson().get("avoids");
      if (avoidsNode!= null && avoidsNode.isArray()) {
        List<String> avoidsList = new ArrayList<>(customerNoticeProto.getAvoidsList());
        for (JsonNode node : avoidsNode) {
          if (node.isTextual()) {
            avoidsList.add(node.textValue());
          }
        }
        customerNoticeProto.addAllAvoids(avoidsList);
//        ((CustomerNotice.Builder) customerNoticeProto.toBuilder()).clearAvoids().addAllAvoids(avoidsList).build();
      }

      JsonNode doctorsNode = orderDb.getCustomerNoticeJson().get("doctors");
      if (doctorsNode!= null && doctorsNode.isArray()) {
        List<String> doctorsList = new ArrayList<>(customerNoticeProto.getDoctorsList());
        for (JsonNode node : doctorsNode) {
          if (node.isTextual()) {
            doctorsList.add(node.textValue());
          }
        }
        customerNoticeProto.addAllDoctors(doctorsList).build();
//        ((CustomerNotice.Builder) customerNoticeProto.toBuilder()).clearDoctors().addAllDoctors(doctorsList).build();
      }

      protoBuilder.setCustomerNoticeJson(customerNoticeProto);
    }

    // 构建并返回最终的ProtoBuf消息
    return protoBuilder.build();
  }

  // 将List<OrderDb>转换为List<SingleClientCustomerOrderRpcResponse>的ProtoBuf消息列表
  public static List<SingleClientCustomerOrderRpcResponse> orderDbListToProtoList(List<OrderDb> orderDbList) throws Exception {
    List<SingleClientCustomerOrderRpcResponse> protoList = new ArrayList<>();
    for (OrderDb orderDb : orderDbList) {
      protoList.add(orderDbToProto(orderDb));
    }
    return protoList;
  }

  // 将单个OrderDetailDb对象转换为SingleClientCustomerOrderDetailRpcResponse的ProtoBuf消息
  public static SingleClientCustomerOrderDetailRpcResponse orderDetailDbToProto(
      OrderDetailDb orderDetailDb) throws Exception {
    // 获取SingleClientCustomerOrderDetailRpcResponse的Builder
    SingleClientCustomerOrderDetailRpcResponse.Builder protoBuilder =
        SingleClientCustomerOrderDetailRpcResponse.newBuilder();

    // 基本字段赋值
    protoBuilder.setId(orderDetailDb.getId())
        .setOrderId(orderDetailDb.getOrderId())
        .setMenuDetailId(orderDetailDb.getMenuDetailId())
        .setCount(orderDetailDb.getCount())
        .setMealId(orderDetailDb.getMealId())
        .setCategoryId(orderDetailDb.getCategoryId())
        .setSkuId(orderDetailDb.getSkuId())
        .setShowName(orderDetailDb.getShowName())
        .setPrice(orderDetailDb.getPrice())
        .setAdjustSkuRemark(orderDetailDb.getAdjustSkuRemark())
        .setCreatedBy(orderDetailDb.getCreatedBy())
        .setCreatedAt(orderDetailDb.getCreatedAt().toEpochSecond(ZoneOffset.UTC) * 1000)
        .setCreationSource(OrderSourceEnum.forNumber(orderDetailDb.getCreationSource()))
        .setUpdatedBy(orderDetailDb.getUpdatedBy())
        .setUpdatedAt(orderDetailDb.getUpdatedAt().toEpochSecond(ZoneOffset.UTC) * 1000)
        .setUpdateSource(OrderSourceEnum.forNumber(orderDetailDb.getUpdateSource()))
        .setIsDeleted(orderDetailDb.getIsDeleted())
        .setEnterpriseId(orderDetailDb.getEnterpriseId());

    if (orderDetailDb.getServeStatus() != null) {
      protoBuilder.setServeStatus(ServeStatusEnum.forNumber(orderDetailDb.getServeStatus()));
    } else {
      protoBuilder.setServeStatus(ServeStatusEnum.SERVE_NOT_START);
    }

    // 处理嵌套的MealDetail字段
    if (orderDetailDb.getMealDetailJson()!= null) {
//      Constructor<MealDetail> mealDetailConstructor =
//          MealDetail.class.getDeclaredConstructor();
//      mealDetailConstructor.setAccessible(true);
//      MealDetail mealDetailProto = mealDetailConstructor.newInstance();
      MealDetail.Builder mealDetailProto = MealDetail.newBuilder();

      JsonNode basicMaterialsNode = orderDetailDb.getMealDetailJson().get("basicMaterials");
      if (basicMaterialsNode!= null && basicMaterialsNode.isTextual()) {
        mealDetailProto.setBasicMaterials(basicMaterialsNode.textValue());
      }

      JsonNode tastesNode = orderDetailDb.getMealDetailJson().get("tastes");
      if (tastesNode!= null && tastesNode.isArray()) {
        List<String> tastesList = new ArrayList<>();
        for (JsonNode node : tastesNode) {
          if (node.isTextual()) {
            tastesList.add(node.textValue());
          }
        }
        mealDetailProto.addAllTastes(tastesList);
      }

      JsonNode efficaciesNode = orderDetailDb.getMealDetailJson().get("efficacies");
      if (efficaciesNode!= null && efficaciesNode.isArray()) {
        List<String> efficaciesList = new ArrayList<>();
        for (JsonNode node : efficaciesNode) {
          if (node.isTextual()) {
            efficaciesList.add(node.textValue());
          }
        }
        mealDetailProto.addAllEfficacies(efficaciesList);
      }

      JsonNode dockersNode = orderDetailDb.getMealDetailJson().get("dockers");
      if (dockersNode!= null && dockersNode.isArray()) {
        List<String> dockersList = new ArrayList<>();
        for (JsonNode node : dockersNode) {
          if (node.isTextual()) {
            dockersList.add(node.textValue());
          }
        }
        mealDetailProto.addAllDockers(dockersList);
      }

      JsonNode energyNode = orderDetailDb.getMealDetailJson().get("energy");
      if (energyNode!= null && energyNode.isTextual()) {
        mealDetailProto.setEnergy(energyNode.textValue());
      }

      JsonNode fatNode = orderDetailDb.getMealDetailJson().get("fat");
      if (fatNode!= null && fatNode.isTextual()) {
        mealDetailProto.setFat(fatNode.textValue());
      }

      JsonNode proteinNode = orderDetailDb.getMealDetailJson().get("protein");
      if (proteinNode!= null && proteinNode.isTextual()) {
        mealDetailProto.setProtein(proteinNode.textValue());
      }

      JsonNode carbohydrateNode = orderDetailDb.getMealDetailJson().get("carbohydrate");
      if (carbohydrateNode!= null && carbohydrateNode.isTextual()) {
        mealDetailProto.setCarbohydrate(carbohydrateNode.textValue());
      }

      JsonNode allergiesNode = orderDetailDb.getMealDetailJson().get("allergies");
      if (allergiesNode!= null && allergiesNode.isArray()) {
        List<String> allergiesList = new ArrayList<>();
        for (JsonNode node : allergiesNode) {
          if (node.isTextual()) {
            allergiesList.add(node.textValue());
          }
        }
        mealDetailProto.addAllAllergies(allergiesList);
      }

      JsonNode avoidsNode = orderDetailDb.getMealDetailJson().get("avoids");
      if (avoidsNode!= null && avoidsNode.isArray()) {
        List<String> avoidList = new ArrayList<>();
        for (JsonNode node : avoidsNode) {
          if (node.isTextual()) {
            avoidList.add(node.textValue());
          }
        }
        mealDetailProto.addAllAvoids(avoidList);
      }

      protoBuilder.setMealDetailJson(mealDetailProto);
    }

    // 构建并返回最终的ProtoBuf消息
    return protoBuilder.build();
  }

  // 将List<OrderDetailDb>转换为List<SingleClientCustomerOrderDetailRpcResponse>的ProtoBuf消息列表
  public static List<SingleClientCustomerOrderDetailRpcResponse> orderDetailDbListToProtoList(List<OrderDetailDb> orderDetailDbList) throws Exception {
    List<SingleClientCustomerOrderDetailRpcResponse> protoList = new ArrayList<>();
    for (OrderDetailDb orderDetailDb : orderDetailDbList) {
      protoList.add(orderDetailDbToProto(orderDetailDb));
    }
    return protoList;
  }
}