/**
 * AmazonS3工具类
 */
@Slf4j
@Component
public class AmazonS3Util {

    private static String accessKey;
    private static String secretKey;
    private static String region;


    @Value("${amazon.s3.accessKey}")
    public void setAccessKey(String accessKey) {
        AmazonS3Util.accessKey = accessKey;
    }

    @Value("${amazon.s3.secretKey}")
    public void setSecretKey(String secretKey) {
        AmazonS3Util.secretKey = secretKey;
    }

    @Value("${amazon.s3.region}")
    public void setRegion(String region) {
        AmazonS3Util.region = region;
    }

    @Value("${amazon.s3.bucketName}")
    public String bucketName;

    public static volatile AmazonS3 client;

    /**
     * singleton
     *
     * @return OkHttpClient
     */
    public static AmazonS3 getInstance() {
        if (Objects.isNull(client)) {
            synchronized (AmazonS3.class) {
                if (Objects.isNull(client)) {
                    AWSCredentials credentials = new BasicAWSCredentials(accessKey, secretKey);
                    ClientConfiguration conf = new ClientConfiguration();
                    // 设置AmazonS3使用的最大连接数
                    conf.setMaxConnections(200);
                    // 设置socket超时时间
                    conf.setSocketTimeout(10000);
                    // 设置失败请求重试次数
                    conf.setMaxErrorRetry(1);
                    // 如果要用https协议，请加上下面语句
                    conf.setProtocol(Protocol.HTTPS);
                    // 设置加密版本
                    conf.setSignerOverride("AWSS3V4SignerType");
                    return AmazonS3ClientBuilder.standard()
                            .withCredentials(new AWSStaticCredentialsProvider(credentials))
                            .withRegion(region)
                            .withClientConfiguration(conf)
                            .build();
                }
            }
        }
        return client;
    }

    public String uploadFile(String contextType, String fileName, MultipartFile file) {
        try (InputStream input = new ByteArrayInputStream(file.getBytes())) {
            ObjectMetadata metadata = new ObjectMetadata();
            metadata.setContentType(contextType);
            metadata.setHttpExpiresDate(new Date(System.currentTimeMillis() + TimeUnit.DAYS.toMillis(365)));
            metadata.setContentLength(input.available());
            fileName = UUID.randomUUID().toString().replace("-", "") + fileName;
            getInstance().putObject(bucketName, fileName, input, metadata);
            return fileName;
        } catch (Exception e) {
            log.error("上传文件失败", e);
        }
        return null;
    }

    public String generateResignedUrl(String fileName) {
        URL url = getInstance().generatePresignedUrl(bucketName, fileName, new Date(System.currentTimeMillis() + TimeUnit.DAYS.toMillis(7)), HttpMethod.GET);
        return url.toString();
    }
}

/**
     * Causes this thread to begin execution; the Java Virtual Machine
     * calls the <code>run</code> method of this thread.
     * <p>
     * The result is that two threads are running concurrently: the
     * current thread (which returns from the call to the
     * <code>start</code> method) and the other thread (which executes its
     * <code>run</code> method).
     * <p>
     * It is never legal to start a thread more than once.
     * In particular, a thread may not be restarted once it has completed
     * execution.
     *
     * @exception  IllegalThreadStateException  if the thread was already
     *               started.
     * @see        #run()
     * @see        #stop()
     */
public synchronized void start() {
  /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
  if (threadStatus != 0)
    throw new IllegalThreadStateException();

  /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
  group.add(this);

  boolean started = false;
  try {
    start0();
    started = true;
  } finally {
    try {
      if (!started) {
        group.threadStartFailed(this);
      }
    } catch (Throwable ignore) {
      /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
    }
  }
}

/**
     * If this thread was constructed using a separate
     * <code>Runnable</code> run object, then that
     * <code>Runnable</code> object's <code>run</code> method is called;
     * otherwise, this method does nothing and returns.
     * <p>
     * Subclasses of <code>Thread</code> should override this method.
     *
     * @see     #start()
     * @see     #stop()
     * @see     #Thread(ThreadGroup, Runnable, String)
     */
@Override
public void run() {
  if (target != null) {
    target.run();
  }
}