package main

import (
    "context"
    "fmt"
    "image"
    "image/jpeg"
    "os"

    "github.com/volcengine/ve-tos-golang-sdk/v2/tos"
    "github.com/volcengine/ve-tos-golang-sdk/v2/tos/enum"
    "github.com/volcengine/volcengine-go-sdk/service/arkruntime"
    "github.com/volcengine/volcengine-go-sdk/service/arkruntime/model"
)

const (
    targetSize          = int64(300 * 1024)       // 300KB
    originalImageFile   = "original_image.jpeg"   // 压缩前图片路径
    compressedImageFile = "compressed_image.jpeg" // 压缩后图片存放路径
    ep_id = "ep-****-***"  //配置你部署了视觉理解模型的推理接入点（Endpoint）ID
    // Bucket 对应的 Endpoint，以华北2（北京）为例
    // 公网域名地址：https://tos-cn-beijing.volces.com
    endpoint, region = "https://tos-cn-beijing.volces.com", "cn-beijing"
    // 填写 对象存储BucketName
    bucketName = "*** Provide your bucket name ***"
    // 将文件上传到 images 目录下的 compressed_image.jpeg 文件
    objectKey = "images/compressed_image.jpeg"
)

var (
    accessKey = os.Getenv("VOLC_ACCESSKEY")
    secretKey = os.Getenv("VOLC_SECRETKEY")
    apiKey    = os.Getenv("ARK_API_KEY")
)

func compressImage(inputPath, outputPath string, targetSize int64) (int, error) {
    file, err := os.Open(inputPath)
    if err != nil {
       return -1, err
    }
    defer file.Close()

    img, _, err := image.Decode(file)
    if err != nil {
       return -1, err
    }

    outputFile, err := os.Create(outputPath)
    if err != nil {
       return -1, err
    }
    defer outputFile.Close()

    originalImageInfo, err := file.Stat()
    if err != nil {
       return -1, err
    }
    quality := int(float64(targetSize) / float64(originalImageInfo.Size()) * 100)

    for {
       err = jpeg.Encode(outputFile, img, &jpeg.Options{Quality: quality})
       if err != nil {
          return -1, err
       }

       info, err := outputFile.Stat()
       if err != nil {
          return -1, err
       }

       if info.Size() <= targetSize {
          break
       }

       quality -= 10
       if quality <= 0 {
          return -1, fmt.Errorf("无法压缩到目标大小")
       }

       outputFile.Close()
       outputFile, err = os.Create(outputPath)
       if err != nil {
          return -1, err
       }
    }

    return quality, nil
}
func uploadTos(ctx context.Context, endpoint, region, bucketName, objectKey, filePath string) (*tos.PreSignedURLOutput, error) {
    // 初始化客户端
    client, err := tos.NewClientV2(endpoint, tos.WithRegion(region), tos.WithCredentials(tos.NewStaticCredentials(accessKey, secretKey)))
    if err != nil {
       return nil, err
    }

    // 将压缩后的图片上传到tos
    output, err := client.PutObjectFromFile(ctx, &tos.PutObjectFromFileInput{
       PutObjectBasicInput: tos.PutObjectBasicInput{
          Bucket: bucketName,
          Key:    objectKey,
       },
       FilePath: filePath,
    })
    if err != nil {
       return nil, err
    }
    fmt.Println("PutObjectV2 Request ID:", output.RequestID)

    // 获取预签名下载链接
    innerClient, err := tos.NewClientV2(endpoint, tos.WithRegion(region), tos.WithCredentials(tos.NewStaticCredentials(accessKey, secretKey)))
    if err != nil {
       return nil, err
    }
    return innerClient.PreSignedURL(&tos.PreSignedURLInput{
       HTTPMethod: enum.HttpMethodGet,
       Bucket:     bucketName,
       Key:        objectKey,
    })
}

func main() {
    ctx := context.Background()

    fmt.Println("----- Compress Image -----")
    quality, err := compressImage(originalImageFile, compressedImageFile, targetSize)
    if err != nil {
       panic(err)
    }

    fmt.Println("Compressed Image Quality:", quality)

    fmt.Println("----- Upload Image To TOS -----")
    preSignedUrl, err := uploadTos(ctx, endpoint, region, bucketName, objectKey, compressedImageFile)
    if err != nil {
       return
    }
    fmt.Println("PreSignedUrl:", preSignedUrl.SignedUrl)

    fmt.Println("----- Image Input Chat -----")
    client := arkruntime.NewClientWithApiKey(apiKey)
    req := model.ChatCompletionRequest{
       Model: ep_id,
       Messages: []*model.ChatCompletionMessage{
          {
             Role: model.ChatMessageRoleUser,
             Content: &model.ChatCompletionMessageContent{
                ListValue: []*model.ChatCompletionMessageContentPart{
                   {
                      Type: model.ChatCompletionMessageContentPartTypeText,
                      Text: "Which is the most secure payment app according to Americans?",
                   },
                   {
                      Type: model.ChatCompletionMessageContentPartTypeImageURL,
                      ImageURL: &model.ChatMessageImageURL{
                         URL: preSignedUrl.SignedUrl,
                      },
                   },
                },
             },
          },
       },
    }

    resp, err := client.CreateChatCompletion(ctx, req)
    if err != nil {
       fmt.Printf("standard chat error: %v
", err)
       return
    }
    fmt.Println(*resp.Choices[0].Message.Content.StringValue)
}

package com.volcengine.ark.runtime;

import com.volcengine.ark.runtime.model.completion.chat.ChatCompletionContentPart;
import com.volcengine.ark.runtime.model.completion.chat.ChatMessage;
import com.volcengine.ark.runtime.model.completion.chat.ChatMessageRole;
import com.volcengine.ark.runtime.service.ArkService;
import com.volcengine.tos.TOSV2;
import com.volcengine.tos.TOSV2ClientBuilder;
import com.volcengine.tos.TosClientException;
import com.volcengine.tos.TosServerException;
import com.volcengine.tos.comm.HttpMethod;
import com.volcengine.tos.model.object.PreSignedURLInput;
import com.volcengine.tos.model.object.PreSignedURLOutput;
import com.volcengine.tos.model.object.PutObjectInput;
import com.volcengine.tos.model.object.PutObjectOutput;
import com.volcengine.ark.runtime.model.completion.chat.ChatCompletionRequest;

import javax.imageio.ImageIO;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import javax.imageio.stream.ImageOutputStream;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;

public class VLMChatExample {

    private static final String TOS_ENDPOINT = "https://tos-cn-beijing.volces.com";
    private static final String REGION = "cn-beijing";
    private static final String ARK_API_KEY = System.getenv("ARK_API_KEY");
    private static final String VOLC_ACCESSKEY = System.getenv("VOLC_ACCESSKEY");
    private static final String VOLC_SECRETKEY = System.getenv("VOLC_SECRETKEY");
    private static final long TOS_EXPIRE_TIME = 3600;

    public static void compressImage(String inputImagePath, String outputImagePath, long targetSizeInBytes) throws IOException {
        File inputFile = new File(inputImagePath);
        BufferedImage img = ImageIO.read(inputFile);
        float quality = targetSizeInBytes * 1.0f / inputFile.length();
        try (ImageOutputStream ios = ImageIO.createImageOutputStream(new File(outputImagePath))) {
            ImageWriter writer = ImageIO.getImageWritersByFormatName("jpeg").next();
            ImageWriteParam param = writer.getDefaultWriteParam();
            param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
            param.setCompressionQuality(quality);
            writer.setOutput(ios);
            writer.write(null, new javax.imageio.IIOImage(img, null, null), param);
            writer.dispose();
        }
    }

    public static void uploadImageToTOS(String filePath, String bucketName, String objectKey) throws Throwable {

        TOSV2 tos = new TOSV2ClientBuilder().build(REGION, TOS_ENDPOINT, VOLC_ACCESSKEY, VOLC_SECRETKEY);

        // step 1. 上传本地图片到tos
        File file = new File(filePath);
        try (FileInputStream inputStream = new FileInputStream(file)) {
            PutObjectInput putObjectInput = new PutObjectInput().setBucket(bucketName)
                    .setKey(objectKey).setContent(inputStream).setContentLength(file.length());
            PutObjectOutput output = tos.putObject(putObjectInput);
            System.out.println("putObject succeed, object's etag is " + output.getEtag());
            System.out.println("putObject succeed, object's crc64 is " + output.getHashCrc64ecma());
        } catch (IOException e) {
            System.out.println("putObject read file failed");
            e.printStackTrace();
            throw e;
        } catch (TosClientException e) {
            // 操作失败，捕获客户端异常，一般情况是请求参数错误，此时请求并未发送
            System.out.println("putObject failed");
            System.out.println("Message: " + e.getMessage());
            if (e.getCause() != null) {
                e.getCause().printStackTrace();
            }
            throw e;
        } catch (TosServerException e) {
            // 操作失败，捕获服务端异常，可以获取到从服务端返回的详细错误信息
            System.out.println("putObject failed");
            System.out.println("StatusCode: " + e.getStatusCode());
            System.out.println("Code: " + e.getCode());
            System.out.println("Message: " + e.getMessage());
            System.out.println("RequestID: " + e.getRequestID());
            throw e;
        } catch (Throwable t) {
            // 作为兜底捕获其他异常，一般不会执行到这里
            System.out.println("putObject failed");
            System.out.println("unexpected exception, message: " + t.getMessage());
            throw t;
        }
    }

    public static String getPreSignedURL(String bucketName, String objectKey) throws Throwable {

        TOSV2 tos = new TOSV2ClientBuilder().build(REGION, TOS_ENDPOINT, VOLC_ACCESSKEY, VOLC_SECRETKEY);

        // 生成预签名链接
        try {
            PreSignedURLInput input = new PreSignedURLInput().setBucket(bucketName).setKey(objectKey)
                    .setHttpMethod(HttpMethod.GET).setExpires(TOS_EXPIRE_TIME);
            PreSignedURLOutput output = tos.preSignedURL(input);
            System.out.println("preSignedURL succeed, the signed url is " + output.getSignedUrl());
            System.out.println("preSignedURL succeed, the signed header is " + output.getSignedHeader());
            return output.getSignedUrl();
        } catch (TosClientException e) {
            // 操作失败，捕获客户端异常，一般情况是请求参数错误，此时请求并未发送
            System.out.println("preSignedURL failed");
            System.out.println("Message: " + e.getMessage());
            if (e.getCause() != null) {
                e.getCause().printStackTrace();
            }
            throw e;
        } catch (Throwable t) {
            // 作为兜底捕获其他异常，一般不会执行到这里
            System.out.println("preSignedURL failed");
            System.out.println("unexpected exception, message: " + t.getMessage());
            throw t;
        }
    }

    public static void main(String[] args) throws Throwable {
        String filePath = "/your/path/to/your/image.jpeg";
        String compressedPath = "/your/path/to/compress/image.jpeg";
        String tosBucket = "{your bucket name}";
        String objectKey = "{your object key}";
        // 1. 压缩图片
        try {
            compressImage(filePath, compressedPath, 300 * 1024);
        } catch (IOException e) {
            System.out.println("compressImage failed");
            e.printStackTrace();
            throw e;
        }
        // 2. 上传TOS
        try {
            uploadImageToTOS(compressedPath, tosBucket, objectKey);
        } catch (Throwable t) {
            System.out.println("uploadImageToTOS failed");
            t.printStackTrace();
            throw t;
        }
        // 3. 生成预签名链接
        String preSignedURL = "";
        try {
            preSignedURL = getPreSignedURL(tosBucket, objectKey);
        } catch (Throwable t) {
            System.out.println("getPreSignedURL failed");
            t.printStackTrace();
            throw t;
        }

        // 4. 调用大模型Chat
        ArkService service = new ArkService(ARK_API_KEY);

        System.out.println("----- image input -----");
        final List<ChatMessage> messages = new ArrayList<>();
        final List<ChatCompletionContentPart> multiParts = new ArrayList<>();
        multiParts.add(ChatCompletionContentPart.builder().type("text").text(
                "Which is the most secure payment app according to Americans?"
        ).build());
        multiParts.add(ChatCompletionContentPart.builder().type("image_url").imageUrl(
                new ChatCompletionContentPart.ChatCompletionContentPartImageURL(preSignedURL)
        ).build());
        final ChatMessage userMessage = ChatMessage.builder().role(ChatMessageRole.USER)
                .multiContent(multiParts).build();
        messages.add(userMessage);

        ChatCompletionRequest chatCompletionRequest = ChatCompletionRequest.builder()
                .model("{your ark model endpoint id}")
                .messages(messages)
                .build();

        service.createChatCompletion(chatCompletionRequest).getChoices().forEach(choice -> System.out.println(choice.getMessage().getContent()));
        // shutdown service
        service.shutdownExecutor();
    }
}