/**
 * Alipay.com Inc. Copyright (c) 2004-2019 All Rights Reserved.
 */
package com.alipay.easysdk.kms.aliyun;

import com.alipay.easysdk.kms.aliyun.models.RuntimeOptions;
import com.aliyun.tea.*;
import com.aliyun.tea.utils.StringUtils;
import com.google.gson.Gson;
import org.bouncycastle.util.encoders.Base64;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.text.SimpleDateFormat;
import java.util.*;

public class AliyunRpcClient {
    private final String accessKeyId;
    private final String accessKeySecret;
    private final String endpoint;
    private final String format;
    private final String signatureMethod;
    private final String signatureVersion;

    public AliyunRpcClient(Map<String, Object> config) {
        this.accessKeyId = (String) config.get("aliyunAccessKeyId");
        this.accessKeySecret = (String) config.get("aliyunAccessKeySecret");
        this.endpoint = (String) config.get("kmsEndpoint");
        this.format = "JSON";
        this.signatureMethod = "HMAC-SHA1";
        this.signatureVersion = "1.0";
    }

    public Map<String, Object> doRequest(String action, String protocol, String method, String version, Map<String, Object> query, Map<String, Object> body, RuntimeOptions runtime) throws Exception {
        Map<String, Object> runtime_ = TeaConverter.buildMap(
                new TeaPair("readTimeout", runtime.readTimeout),
                new TeaPair("connectTimeout", runtime.connectTimeout),
                new TeaPair("retry", TeaConverter.buildMap(
                        new TeaPair("maxAttempts", runtime.maxAttempts)
                )),
                new TeaPair("backoff", TeaConverter.buildMap(
                        new TeaPair("policy", runtime.backoffPolicy),
                        new TeaPair("period", runtime.backoffPeriod)
                )),
                new TeaPair("ignoreSSL", runtime.ignoreSSL)
        );

        TeaRequest _lastRequest = null;
        long _now = System.currentTimeMillis();
        int _retryTimes = 0;
        while (Tea.allowRetry((Map<String, Object>) runtime_.get("retry"), _retryTimes, _now)) {
            if (_retryTimes > 0) {
                int backoffTime = Tea.getBackoffTime(runtime_.get("backoff"), _retryTimes);
                if (backoffTime > 0) {
                    Tea.sleep(backoffTime);
                }
            }
            _retryTimes = _retryTimes + 1;
            try {
                TeaRequest request_ = new TeaRequest();
                request_.protocol = protocol;
                request_.method = method;
                request_.pathname = "/";
                request_.query = TeaConverter.merge(String.class,
                        TeaConverter.buildMap(
                                new TeaPair("Action", action),
                                new TeaPair("Format", this.format),
                                new TeaPair("Timestamp", getTimestamp()),
                                new TeaPair("Version", version),
                                new TeaPair("SignatureNonce", getNonce())
                        ),
                        query
                );
                request_.headers = TeaConverter.buildMap(
                        new TeaPair("host", this.endpoint)
                );
                if (!isUnset(body)) {
                    Map<String, Object> tmp = anyifyMapValue(body);
                    request_.body = Tea.toReadable(toFormString(tmp));
                    request_.headers.put("content-type", "application/x-www-form-urlencoded");
                }

                request_.query.put("SignatureMethod", this.signatureMethod);
                request_.query.put("SignatureVersion", this.signatureVersion);
                request_.query.put("AccessKeyId", this.accessKeyId);
                Map<String, String> signedParam = TeaConverter.merge(String.class,
                        request_.query,
                        body
                );
                request_.query.put("Signature", getSignature(signedParam, request_.method, this.accessKeySecret));


                _lastRequest = request_;
                TeaResponse response_ = Tea.doAction(request_, runtime_);

                Object obj = readAsJSON(response_.body);
                Map<String, Object> res = assertAsMap(obj);
                if (is4xx(response_.statusCode) || is5xx(response_.statusCode)) {
                    throw new TeaException(TeaConverter.buildMap(
                            new TeaPair("message", res.get("Message")),
                            new TeaPair("data", res),
                            new TeaPair("code", res.get("Code"))
                    ));
                }

                return res;
            } catch (Exception e) {
                if (Tea.isRetryable(e)) {
                    continue;
                }
                throw e;
            }
        }

        throw new TeaUnretryableException(_lastRequest);
    }

    public static String percentEncode(String value) throws UnsupportedEncodingException {
        return value != null ? URLEncoder.encode(value, "UTF-8").replace("+", "%20").replace("*", "%2A").replace("%7E", "~") : null;
    }

    private static String getSignature(Map<String, String> signedParams, String method, String secret) throws Exception {
        String[] sortedKeys = signedParams.keySet().toArray(new String[0]);
        Arrays.sort(sortedKeys);
        StringBuilder canonicalizedQueryString = new StringBuilder();

        for (String key : sortedKeys) {
            if (!StringUtils.isEmpty(signedParams.get(key))) {
                canonicalizedQueryString.append("&").append(percentEncode(key)).append("=").append(percentEncode((String) signedParams.get(key)));
            }
        }

        Mac mac = Mac.getInstance("HmacSHA1");
        mac.init(new SecretKeySpec((secret + "&").getBytes(StandardCharsets.UTF_8), "HmacSHA1"));
        String stringToSign = method +
                "&" +
                percentEncode("/") +
                "&" +
                percentEncode(canonicalizedQueryString.toString().substring(1));
        byte[] signData = mac.doFinal(stringToSign.getBytes(StandardCharsets.UTF_8));
        return Base64.toBase64String(signData);
    }

    public static Object parseJSON(String json) {
        return (new Gson()).fromJson(json, Map.class);
    }

    public static Map<String, Object> assertAsMap(Object object) {
        if (null != object && Map.class.isAssignableFrom(object.getClass())) {
            return (Map) object;
        } else {
            throw new RuntimeException("The value is not a object");
        }
    }

    public static byte[] readAsBytes(InputStream stream) throws IOException {
        if (null == stream) {
            return new byte[0];
        } else {
            ByteArrayOutputStream os = new ByteArrayOutputStream();
            byte[] buff = new byte[1024];

            while (true) {
                int read = stream.read(buff);
                if (read == -1) {
                    return os.toByteArray();
                }

                os.write(buff, 0, read);
            }
        }
    }

    public static String readAsString(InputStream stream) throws IOException {
        return new String(readAsBytes(stream), StandardCharsets.UTF_8);
    }

    public static Object readAsJSON(InputStream stream) throws IOException {
        String body = readAsString(stream);
        return parseJSON(body);
    }

    public static String getTimestamp() {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
        df.setTimeZone(new SimpleTimeZone(0, "UTC"));
        return df.format(new Date());
    }

    public static String getNonce() {
        StringBuilder uniqueNonce = new StringBuilder();
        UUID uuid = UUID.randomUUID();
        uniqueNonce.append(uuid.toString());
        uniqueNonce.append(System.currentTimeMillis());
        uniqueNonce.append(Thread.currentThread().getId());
        return uniqueNonce.toString();
    }

    public static String toFormString(Map<String, ?> map) throws UnsupportedEncodingException {
        if (null == map) {
            return "";
        }
        StringBuilder result = new StringBuilder();
        boolean first = true;
        for (Map.Entry<String, ?> entry : map.entrySet()) {
            if (StringUtils.isEmpty(entry.getValue())) {
                continue;
            }
            if (first) {
                first = false;
            } else {
                result.append("&");
            }
            result.append(URLEncoder.encode(entry.getKey(), "UTF-8"));
            result.append("=");
            result.append(URLEncoder.encode(String.valueOf(entry.getValue()), "UTF-8"));
        }
        return result.toString();
    }

    public static void validateModel(TeaModel m) throws Exception {
        if (null == m) {
            throw new ValidateException("parameter is not allowed as null");
        } else {
            m.validate();
        }
    }

    public static Map<String, Object> anyifyMapValue(Map<String, ?> map) {
        Map<String, Object> result = new HashMap<>();
        if (null == map) {
            return null;
        }
        for (Map.Entry<String, ?> entry : map.entrySet()) {
            result.put(entry.getKey(), entry.getValue());
        }
        return result;
    }

    public static boolean is4xx(Number code) {
        if (null == code) {
            return false;
        } else {
            return code.intValue() >= 400 && code.intValue() < 500;
        }
    }

    public static boolean is5xx(Number code) {
        if (null == code) {
            return false;
        } else {
            return code.intValue() >= 500 && code.intValue() < 600;
        }
    }

    public static boolean isUnset(Object object) {
        return null == object;
    }
}