package com.vincent.rsf.openApi.service.phyz.impl;

import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.cfg.CoercionAction;
import com.fasterxml.jackson.databind.cfg.CoercionInputShape;
import com.vincent.rsf.framework.exception.CoolException;
import com.vincent.rsf.openApi.config.PlatformProperties;
import com.vincent.rsf.openApi.entity.constant.PhyzMesConstant;
import com.vincent.rsf.openApi.entity.dto.CommonResponse;
import com.vincent.rsf.openApi.entity.phyz.*;
import com.vincent.rsf.openApi.service.phyz.MesReportService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;

import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.springframework.http.client.ClientHttpResponse;
import java.util.Objects;

@Service
@Slf4j
public class MesReportServiceImpl implements MesReportService {

    private static String MES_REPORT_URL;

    @Resource
    private PlatformProperties.MesApi mesApi;
    @Resource
    private RestTemplate restTemplate;

    @PostConstruct
    public void init() {
        MES_REPORT_URL = mesApi.getMesUrl();
    }

    /**
     * 获取token
     *
     * @return token字符串
     */
    private String getToken() {
        String mesUrl = MES_REPORT_URL + PhyzMesConstant.TOKEN;
        try {
            HttpHeaders headers = new HttpHeaders();
            headers.add("Content-Type", "application/x-www-form-urlencoded");

            // 准备表单数据
            MultiValueMap<String, String> map = new LinkedMultiValueMap<>();
            map.add("grant_type", "password");
            map.add("username", PhyzMesConstant.TOKEN_USER);
            map.add("password", PhyzMesConstant.TOKEN_PASSWORD);
            map.add("client_id", "global");
            map.add("client_secret", "cs");

            HttpEntity<Object> httpEntity = new HttpEntity<>(map, headers);
            ResponseEntity<String> exchange = restTemplate.exchange(mesUrl, HttpMethod.POST, httpEntity, String.class);
            if (Objects.isNull(exchange.getBody())) {
                throw new CoolException("请求失败！！");
            }

            try {
                ObjectMapper objectMapper = new ObjectMapper();
                objectMapper.coercionConfigDefaults().setCoercion(CoercionInputShape.EmptyString, CoercionAction.AsEmpty);
                JSONObject jsonObject = objectMapper.readValue(exchange.getBody(), JSONObject.class);
                return jsonObject.getString("access_token");
            } catch (JsonProcessingException e) {
                log.error("Mes解析响应失败", e);
                throw new CoolException("Mes解析响应失败：" + e.getMessage());
            }
        } catch (Exception e) {
            log.error("Mes解析token响应失败", e);
            return StringUtils.EMPTY;
        }
    }

    /**
     * 托盘信息同步
     *
     * @param params 托盘信息参数
     * @return 响应结果
     */
    public CommonResponse syncPalletInfo(Object params) {
        if (Objects.isNull(params)) {
            throw new CoolException("托盘信息参数不能为空！！");
        }

        // TODO: 参数转换
        List<Pallet> pallets = new ArrayList<>();
        // 将传入的 params 转换为 Pallet 对象列表
        if (params instanceof List) {
            for (Object obj : (List<?>) params) {
                if (obj instanceof Map) {
                    Map<String, Object> map = (Map<String, Object>) obj;
                    Pallet pallet = new Pallet();
                    pallet.setBarCode((String) map.get("BarCode"));
                    pallet.setPalletCode((String) map.get("PalletCode"));
                    pallet.setPalletName((String) map.get("PalletName"));
                    pallet.setPalletTypeCode((String) map.get("PalletTypeCode"));
                    pallet.setPalletTypeName((String) map.get("PalletTypeName"));
                    pallet.setCreatedBy((String) map.get("CreatedBy"));
                    pallets.add(pallet);
                } else if (obj instanceof Pallet) {
                    pallets.add((Pallet) obj);
                }
            }
        }
        
        MesReportList<Pallet> reportList = new MesReportList<>();
        reportList.setCommand(new MesReportList.CommandData<Pallet>().setDataList(pallets));
        
        String mesUrl = MES_REPORT_URL + PhyzMesConstant.PALLET_SYN;
        log.info("Mes托盘信息同步： {}， 请求参数： {}", mesUrl, JSONObject.toJSONString(reportList));
        try {
            JSONObject jsonObject = postRequest(mesUrl, reportList, getToken());
            boolean sendSuccess = jsonObject.getBoolean("Succeeded");

            if (sendSuccess) {
                return CommonResponse.ok();
            } else {
                // TODO：失败后记录重发
                return CommonResponse.error(jsonObject.getJSONObject("Error").getString("ErrorMessage"));
            }
        } catch (Exception e) {
            log.error("Mes解析托盘信息同步响应失败", e);
            throw new CoolException("Mes解析响应失败：" + e.getMessage());
        }
    }

    /**
     * 接驳口信息同步（站点信息同步）
     *
     * @param params 站点信息参数
     * @return 响应结果
     */
    public CommonResponse syncStationInfo(Object params) {
        if (Objects.isNull(params)) {
            throw new CoolException("站点信息参数不能为空！！");
        }

        // TODO：参数转换
        List<Station> stations = new ArrayList<>();
        if (params instanceof List) {
            for (Object obj : (List<?>) params) {
                if (obj instanceof Map) {
                    Map<String, Object> map = (Map<String, Object>) obj;
                    Station station = new Station();
                    station.setConnPortCode((String) map.get("ConnPortCode"));
                    station.setConnPortName((String) map.get("ConnPortName"));
                    station.setWorkshopCode((String) map.get("WorkshopCode"));
                    station.setWorkshopName((String) map.get("WorkshopName"));
                    station.setProductionLineCode((String) map.get("ProductionLineCode"));
                    station.setProductionLineName((String) map.get("ProductionLineName"));
                    station.setCreatedBy((String) map.get("CreatedBy"));
                    stations.add(station);
                } else if (obj instanceof Station) {
                    stations.add((Station) obj);
                }
            }
        }

        MesReportList<Station> reportList = new MesReportList<>();
        reportList.setCommand(new MesReportList.CommandData<Station>().setDataList(stations));

        String mesUrl = MES_REPORT_URL + PhyzMesConstant.STATION_SYN;
        log.info("Mes站点信息同步： {}， 请求参数： {}", mesUrl, JSONObject.toJSONString(reportList));
        try {
            JSONObject jsonObject = postRequest(mesUrl, reportList, getToken());
            boolean sendSuccess = jsonObject.getBoolean("Succeeded");

            if (sendSuccess) {
                return CommonResponse.ok();
            } else {
                // TODO：失败后记录重发
                return CommonResponse.error(jsonObject.getJSONObject("Error").getString("ErrorMessage"));
            }
        } catch (Exception e) {
            log.error("Mes解析站点信息同步响应失败", e);
            throw new CoolException("Mes解析响应失败：" + e.getMessage());
        }
    }

    /**
     * 托盘任务回调（任务执行上报）
     *
     * @param params 任务执行参数
     * @return 响应结果
     */
    public CommonResponse reportTaskExecute(Object params) {
        if (Objects.isNull(params)) {
            throw new CoolException("任务执行参数不能为空！！");
        }

        // TODO：参数转换
        TaskResult taskResult = new TaskResult();
        if (params instanceof TaskResult) {
            TaskResult task = (TaskResult) params;
            taskResult.setTaskNo(task.getTaskNo());
            taskResult.setStatus(task.getStatus());
        } else if (params instanceof Map) {
            Map<String, Object> map = (Map<String, Object>) params;
            taskResult.setTaskNo((String) map.get("TaskNo"));
            taskResult.setStatus((Integer) map.get("Status"));
        }

        MesReportOne<TaskResult> reportOne = new MesReportOne<>();
        reportOne.setCommand(taskResult);
        
        String mesUrl = MES_REPORT_URL + PhyzMesConstant.TASK_EXECUTE_REPORT;
        log.info("Mes任务执行上报： {}， 请求参数： {}", mesUrl, JSONObject.toJSONString(reportOne));
        try {
            JSONObject jsonObject = postRequest(mesUrl, reportOne, getToken());
            boolean sendSuccess = jsonObject.getBoolean("Succeeded");

            if (sendSuccess) {
                return CommonResponse.ok();
            } else {
                // TODO：失败后记录重发
                return CommonResponse.error(jsonObject.getJSONObject("Error").getString("ErrorMessage"));
            }
        } catch (Exception e) {
            log.error("Mes解析任务执行上报响应失败", e);
            throw new CoolException("Mes解析响应失败：" + e.getMessage());
        }
    }

    /**
     * 通用HTTP POST请求方法
     *
     * @param url 请求URL
     * @param params 请求参数
     * @param token token
     * @return 响应结果
     */
    public JSONObject postRequest(String url, Object params, String token) {
        if (StringUtils.isBlank(url)) {
            throw new CoolException("请求URL不能为空！！");
        }
        if (Objects.isNull(params)) {
            throw new CoolException("请求参数不能为空！！");
        }
        
        log.info("Mes POST请求： {}， 请求参数： {}", url, JSONObject.toJSONString(params));
        
        HttpHeaders headers = new HttpHeaders();
        headers.add("Content-Type", "application/json;charset=utf-8");    //
        headers.add("Authorization", "Bearer " + token);
        
        HttpEntity<Object> httpEntity = new HttpEntity<>(params, headers);
        
        try {
            // 创建自定义的ResponseErrorHandler来处理非200状态码
            RestTemplate customRestTemplate = new RestTemplate();
            customRestTemplate.setRequestFactory(restTemplate.getRequestFactory());
            
            // 设置错误处理器，不抛出异常，而是返回响应体
            customRestTemplate.setErrorHandler(new org.springframework.web.client.DefaultResponseErrorHandler() {
                @Override
                public boolean hasError(ClientHttpResponse response) throws IOException {
                    // 不管状态码如何，都不视为错误
                    return false;
                }
            });
            
            ResponseEntity<String> exchange = customRestTemplate.exchange(url, HttpMethod.POST, httpEntity, String.class);
            log.info("Mes POST请求响应结果： {}", exchange);

            if (Objects.isNull(exchange.getBody()) || exchange.getBody().isEmpty()) {
                throw new CoolException("请求失败！！");
            }

            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.coercionConfigDefaults().setCoercion(CoercionInputShape.EmptyString, CoercionAction.AsEmpty);
            return objectMapper.readValue(exchange.getBody(), JSONObject.class);
        } catch (Exception e) { //JsonProcessingException
            log.error("Mes解析响应失败", e);
            throw new CoolException("Mes解析响应失败：" + e.getMessage());
        }
    }

}