package org.sxkj.odm.service;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.google.gson.JsonArray;
import lombok.extern.slf4j.Slf4j;
import org.apache.logging.log4j.util.Strings;
import org.jetbrains.annotations.Nullable;
import org.springblade.core.redis.cache.BladeRedis;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.*;
import org.springframework.stereotype.Component;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;
import org.sxkj.common.utils.SpringContextUtil;
import org.sxkj.odm.config.OdmProperties;
import org.sxkj.odm.constant.OdmConstant;

import java.util.Map;

/**
 * request 请求发送
 */
@Slf4j
@Component
public class WebOdmSendRequest {

	@Autowired
	private RestTemplate restTemplate;

	@Autowired
	private BladeRedis bladeRedis;

	@Autowired
	private OdmProperties odmProperties;

	/**
	 * 调用接口获取数据-get-param
	 * @param url 请求url(有参数直接拼接在后面)
	 * @param isHeader 是否需要求请求头
	 * @return
	 */
	public JSONObject sendGetRequest(String url, Boolean isHeader) {
		// 拼接 url
		url = odmProperties.getApiBaseUrl() + url;
		//设置请求头
		HttpHeaders headers = new HttpHeaders();
		headers.setContentType(MediaType.MULTIPART_FORM_DATA);
		if (isHeader){
			headers.add("Authorization", "JWT " + getOdmToken());
		}
		//封装请求头
		HttpEntity<MultiValueMap<String, Object>> formEntity = new HttpEntity<MultiValueMap<String, Object>>(headers);
		try {
			// make an HTTP GET request with headers
			ResponseEntity<String> response = restTemplate.exchange(
				url,
				HttpMethod.GET,
				formEntity,
				String.class
			);
			//获取 json
			JSONObject jsonObject = JSONObject.parseObject(response.getBody());
			// 返回
			return jsonObject;
		} catch (Exception e) {
			e.printStackTrace();
			log.error("请求异常：",e);
			tokenExceptionHandle(e.getMessage());
			throw new RuntimeException(e);
		}
	}

	/**
	 * 调用接口获取数据-get-param
	 * @param url 请求url(有参数直接拼接在后面)
	 * @param isHeader 是否需要求请求头
	 * @return
	 */
	public JSONArray sendGetRequestResArr(String url, Boolean isHeader) {
		url = odmProperties.getApiBaseUrl() + url;
		//设置请求头
		HttpHeaders headers = new HttpHeaders();
		headers.setContentType(MediaType.MULTIPART_FORM_DATA);
		if (isHeader){
			headers.add("Authorization", "JWT " + getOdmToken());
		}
		//封装请求头
		HttpEntity<MultiValueMap<String, Object>> formEntity = new HttpEntity<MultiValueMap<String, Object>>(headers);
		try {
			// make an HTTP GET request with headers
			ResponseEntity<String> response = restTemplate.exchange(
				url,
				HttpMethod.GET,
				formEntity,
				String.class
			);
			//获取 json
			String body = response.getBody();
			JSONArray objects = JSONObject.parseArray(body);
			// 返回
			return objects;
		} catch (Exception e) {
			e.printStackTrace();
			log.error("请求异常：",e);
			tokenExceptionHandle(e.getMessage());
			throw new RuntimeException(e);
		}
	}

	/**
	 * 调用接口获取数据-post-form-data
	 *
	 * @param url 请求url
	 * @param isHeader 是否需要求请求头
	 * @param map form-data 数据
	 * @return
	 */
	public JSONObject sendPostFormData(String url, Boolean isHeader, MultiValueMap<String, Object> map) {
		url = odmProperties.getApiBaseUrl() + url;
		//设置请求头
		HttpHeaders headers = new HttpHeaders();
		headers.setContentType(MediaType.MULTIPART_FORM_DATA);
		if (isHeader){
			headers.add("Authorization", "JWT " + getOdmToken());
		}
		//封装请求头
		HttpEntity<Object> entity = new HttpEntity<>(map, headers);
		try {
			//发送请求
			String result = restTemplate.postForObject(url,entity,String.class);
			JSONObject jsonObject = JSONObject.parseObject(result);
			// 返回
			return jsonObject;
		} catch (Exception e) {
			e.printStackTrace();
			log.error("请求异常：",e);
			tokenExceptionHandle(e.getMessage());
			throw new RuntimeException(e);
		}
	}

	/**
	 * token 异常处理
	 * @param message
	 */
	private void tokenExceptionHandle(String message) {
		log.error("异常消息：{}",message);
		if (message.contains("403 Forbidden:")){
			// 重新设置token
			getOdmTokenNoCheckRedis();
		}
	}

	/**
	 * 调用接口获取数据-patch-json
	 *
	 * @param url 请求url
	 * @param isHeader 是否需要求请求头
	 * @param map 数据
	 * @return
	 */
	public JSONObject sendPatchJsonByMap(String url, Boolean isHeader, Map<String, Object> map) {
		url = odmProperties.getApiBaseUrl() + url;
		//设置请求头
		HttpHeaders headers = new HttpHeaders();
		headers.setContentType(MediaType.APPLICATION_JSON);
		if (isHeader){
			headers.add("Authorization", "JWT " + getOdmToken());
		}
		String json = JSONObject.toJSONString(map);
		//封装请求头
		HttpEntity<String> entity = new HttpEntity<>(json, headers);
		try {
			//发送请求
			String result = restTemplate.patchForObject(url,entity,String.class);
			JSONObject jsonObject = JSONObject.parseObject(result);
			// 返回
			return jsonObject;
		} catch (Exception e) {
			e.printStackTrace();
			tokenExceptionHandle(e.getMessage());
		}
		return null;
	}

	/**
	 * 调用接口获取数据-post-json
	 *
	 * @param url 请求url
	 * @param isHeader 是否需要求请求头
	 * @param map 数据
	 * @return
	 */
	public JSONObject sendPostJsonByMap(String url, Boolean isHeader, Map<String, Object> map) {
		url = odmProperties.getApiBaseUrl() + url;
		//设置请求头
		HttpHeaders headers = new HttpHeaders();
		headers.setContentType(MediaType.APPLICATION_JSON);
		if (isHeader){
			headers.add("Authorization", "JWT " + getOdmToken());
		}
		String json = JSONObject.toJSONString(map);
		//封装请求头
		HttpEntity<String> entity = new HttpEntity<>(json, headers);
		try {
			//发送请求
			String result = restTemplate.postForObject(url,entity,String.class);
			JSONObject jsonObject = JSONObject.parseObject(result);
			// 返回
			return jsonObject;
		} catch (Exception e) {
			e.printStackTrace();
			tokenExceptionHandle(e.getMessage());
		}
		return null;
	}

	/**
	 * 调用接口获取数据-post-json
	 *
	 * @param url 请求url
	 * @param isHeader 是否需要求请求头
	 * @param json 数据
	 * @return
	 */
	public JSONObject sendPostJsonByJson(String url, Boolean isHeader, String json) {
		url = odmProperties.getApiBaseUrl() + url;
		//设置请求头
		HttpHeaders headers = new HttpHeaders();
		headers.setContentType(MediaType.APPLICATION_JSON);
		if (isHeader){
			headers.add("Authorization", "JWT " + getOdmToken());
		}
		//封装请求头
		HttpEntity<String> entity = new HttpEntity<>(json, headers);
		try {
			//发送请求
			String result = restTemplate.postForObject(url,entity,String.class);
			JSONObject jsonObject = JSONObject.parseObject(result);
			// 返回
			return jsonObject;
		} catch (Exception e) {
			e.printStackTrace();
			tokenExceptionHandle(e.getMessage());
		}
		return null;
	}


	/**
	 * 获取odm token
	 * @return
	 */
	public String getOdmToken() {
		// 获取odm token
		// 先从 redis 中取，如果没有则调用接口取并设置到redis
		String token = bladeRedis.get(OdmConstant.ODM_USER_TOKEN_KEY + odmProperties.getUsername());
		if (!Strings.isBlank(token)){
			return token;
		}
		return getOdmTokenNoCheckRedis();
	}

	/**
	 * 获取odm token （不验证redis）
	 * @return
	 */
	@Nullable
	private String getOdmTokenNoCheckRedis() {
		String token;// 调用接口进行查询
		MultiValueMap<String, Object> map = new LinkedMultiValueMap<>();
		map.set("username", odmProperties.getUsername());
		map.set("password", odmProperties.getPassword());
		// 发送请求
		JSONObject jsonObject = sendPostFormData(OdmConstant.AUTH_TOKEN_API, false, map);
		if (null!=jsonObject){
			token = jsonObject.getString("token");
			// 设置redis，有效时长 6 小时
			bladeRedis.setEx(OdmConstant.ODM_USER_TOKEN_KEY + odmProperties.getUsername(),token, OdmConstant.ODM_USER_TOKEN_TIME);
			// 返回
			return token;
		}
		return null;
	}
}