public class UserMessage {
    private String content;        // 文本内容（主内容）
    private List<Media> media;     // 多模态内容（图片、音频、视频等）
    private String name;           // 可选的发送者名称
}

public class Media {
    private MimeType mimeType;     // 媒体类型（image/png, audio/mp3 等）
    private Object data;           // 数据来源：Resource 或 URI
}

@Service
public class ImageAnalysisAgent {

    private final ChatModel chatModel;

    public ImageAnalysisAgent(ChatModel chatModel) {
        this.chatModel = chatModel;
    }

    /**
     * 分析图片内容
     * @param imageResource 图片资源（支持 classpath、文件系统、URL）
     * @param question 用户的问题
     * @return 模型的分析结果
     */
    public String analyzeImage(Resource imageResource, String question) {
        var userMessage = UserMessage.builder()
            .text(question)
            .media(new Media(MimeTypeUtils.IMAGE_PNG, imageResource))
            .build();

        ChatResponse response = chatModel.call(new Prompt(userMessage));
        return response.getResult().getOutput().getText();
    }
}

@Service
public class ImageAnalysisAgent {

    private final ChatClient chatClient;

    public ImageAnalysisAgent(ChatModel chatModel) {
        this.chatClient = ChatClient.builder(chatModel)
            .defaultSystem("你是一个专业的图像分析助手，能够准确描述图片内容并回答相关问题。")
            .build();
    }

    public String analyzeImage(Resource imageResource, String question) {
        return chatClient.prompt()
            .user(u -> u.text(question)
                .media(MimeTypeUtils.IMAGE_PNG, imageResource))
            .call()
            .content();
    }
}

/**
 * 对比分析两张图片
 */
public String compareImages(Resource image1, Resource image2, String comparisonCriteria) {
    return chatClient.prompt()
        .user(u -> u.text("请从以下维度对比这两张图片：" + comparisonCriteria)
            .media(MimeTypeUtils.IMAGE_JPEG, image1)
            .media(MimeTypeUtils.IMAGE_JPEG, image2))
        .call()
        .content();
}

/**
 * 分析远程图片
 */
public String analyzeRemoteImage(String imageUrl, String question) {
    return chatClient.prompt()
        .user(u -> u.text(question)
            .media(MimeTypeUtils.IMAGE_PNG, URI.create(imageUrl)))
        .call()
        .content();
}

// LangChain4j 的图片分析
import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.data.message.ImageContent;
import dev.langchain4j.data.message.TextContent;

UserMessage userMessage = UserMessage.from(
    TextContent.from("描述这张图片的内容"),
    ImageContent.from("https://example.com/image.png")  // URL 方式
);

// 或者用 base64 方式
ImageContent.from(base64EncodedImage, "image/png");

// 通过 ChatLanguageModel 发送
ChatLanguageModel model = OpenAiChatModel.builder()
    .apiKey(System.getenv("OPENAI_API_KEY"))
    .modelName("gpt-4o")
    .build();

Response<AiMessage> response = model.generate(userMessage);

@Service
public class VoiceAgent {

    private final AudioTranscriptionModel transcriptionModel;
    private final ChatClient chatClient;

    public VoiceAgent(AudioTranscriptionModel transcriptionModel,
                      ChatModel chatModel) {
        this.transcriptionModel = transcriptionModel;
        this.chatClient = ChatClient.builder(chatModel)
            .defaultSystem("你是一个专业的语音助手，请用简洁友好的语言回答问题。")
            .build();
    }

    /**
     * 语音识别 + Agent 处理的完整链路
     */
    public String processVoiceInput(Resource audioFile) {
        // 第一步：语音转文本
        AudioTranscriptionPrompt transcriptionPrompt =
            new AudioTranscriptionPrompt(audioFile);
        AudioTranscriptionResponse transcriptionResponse =
            transcriptionModel.call(transcriptionPrompt);
        String userText = transcriptionResponse.getResult().getOutput();

        // 第二步：Agent 处理
        return chatClient.prompt()
            .user(userText)
            .call()
            .content();
    }
}

@Service
public class VoiceResponseService {

    private final SpeechModel speechModel;

    public VoiceResponseService(SpeechModel speechModel) {
        this.speechModel = speechModel;
    }

    /**
     * 将文本转换为语音
     */
    public byte[] synthesizeSpeech(String text) {
        SpeechPrompt prompt = new SpeechPrompt(text);
        SpeechResponse response = speechModel.call(prompt);
        return response.getResult().getOutput();  // 返回音频字节数组
    }
}

@RestController
@RequestMapping("/api/voice")
public class VoiceAgentController {

    private final VoiceAgent voiceAgent;
    private final VoiceResponseService ttsService;

    /**
     * 完整的语音交互接口
     * 接收音频 → 语音识别 → Agent 处理 → 语音合成 → 返回音频
     */
    @PostMapping(value = "/chat", produces = MediaType.APPLICATION_OCTET_STREAM_VALUE)
    public ResponseEntity<byte[]> voiceChat(
            @RequestParam("audio") MultipartFile audioFile) throws IOException {

        // 1. 语音识别
        Resource audioResource = new ByteArrayResource(audioFile.getBytes()) {
            @Override
            public String getFilename() {
                return "audio.wav";
            }
        };
        String agentResponse = voiceAgent.processVoiceInput(audioResource);

        // 2. 语音合成
        byte[] responseAudio = ttsService.synthesizeSpeech(agentResponse);

        return ResponseEntity.ok()
            .contentType(MediaType.parseMediaType("audio/mpeg"))
            .body(responseAudio);
    }
}

@Service
public class DocumentUnderstandingAgent {

    private final ChatClient chatClient;

    /**
     * 理解文本型 PDF
     */
    public String understandPdf(Resource pdfResource, String question) throws IOException {
        // 用 PDFBox 提取文本
        try (PDDocument document = PDDocument.load(pdfResource.getInputStream())) {
            PDFTextStripper stripper = new PDFTextStripper();
            String pdfText = stripper.getText(document);

            return chatClient.prompt()
                .user(u -> u.text("以下是文档内容：\n\n" + pdfText + "\n\n问题：" + question))
                .call()
                .content();
        }
    }
}

/**
 * 理解扫描型 PDF（图片 PDF）
 */
public String understandScannedPdf(Resource pdfResource, String question) throws IOException {
    // 将 PDF 页面转为图片
    try (PDDocument document = PDDocument.load(pdfResource.getInputStream())) {
        PDFRenderer renderer = new PDFRenderer(document);
        List<Media> pageImages = new ArrayList<>();

        for (int i = 0; i < document.getNumberOfPages(); i++) {
            BufferedImage image = renderer.renderImageWithDPI(i, 200); // 200 DPI
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ImageIO.write(image, "png", baos);
            byte[] imageBytes = baos.toByteArray();

            pageImages.add(new Media(
                MimeTypeUtils.IMAGE_PNG,
                new ByteArrayResource(imageBytes)
            ));
        }

        // 将所有页面作为图片发送给多模态 LLM
        return chatClient.prompt()
            .user(u -> {
                u.text("以下是文档的各页内容，请回答问题：" + question);
                pageImages.forEach(media -> u.media(
                    MimeTypeUtils.IMAGE_PNG,
                    (Resource) media.getData()
                ));
            })
            .call()
            .content();
    }
}

// 发票数据模型
public record InvoiceInfo(
    String invoiceNumber,     // 发票号码
    String invoiceDate,       // 开票日期
    String sellerName,        // 销售方名称
    String buyerName,         // 购买方名称
    BigDecimal totalAmount,   // 价税合计
    BigDecimal taxAmount,     // 税额
    List<InvoiceItem> items   // 明细
) {
    public record InvoiceItem(
        String name,
        String specification,
        String unit,
        Integer quantity,
        BigDecimal unitPrice,
        BigDecimal amount
    ) {}
}

@Service
public class InvoiceExtractionAgent {

    private final ChatClient chatClient;

    public InvoiceExtractionAgent(ChatModel chatModel) {
        this.chatClient = ChatClient.builder(chatModel)
            .defaultSystem("你是一个专业的发票识别助手，能够准确提取发票中的所有关键信息。")
            .build();
    }

    /**
     * 从发票图片提取结构化信息
     */
    public InvoiceInfo extractInvoice(Resource invoiceImage) {
        return chatClient.prompt()
            .user(u -> u.text("请识别这张发票，提取所有关键信息。")
                .media(MimeTypeUtils.IMAGE_JPEG, invoiceImage))
            .call()
            .entity(InvoiceInfo.class);  // 结构化输出
    }
}

@Service
@Slf4j
public class MultiModalCustomerAgent {

    private final ChatClient chatClient;
    private final AudioTranscriptionModel sttModel;
    private final SpeechModel ttsModel;
    private final OrderService orderService;
    private final KnowledgeBaseService knowledgeBaseService;

    public MultiModalCustomerAgent(ChatModel chatModel,
                                    AudioTranscriptionModel sttModel,
                                    SpeechModel ttsModel,
                                    OrderService orderService,
                                    KnowledgeBaseService knowledgeBaseService) {
        this.chatClient = ChatClient.builder(chatModel)
            .defaultSystem("""
                你是一个专业的客服助手，服务于某电商平台。
                你的能力包括：
                1. 解答产品相关问题
                2. 查询订单状态
                3. 处理售后问题
                4. 分析用户发送的图片（产品问题照片、截图等）

                注意事项：
                - 用户输入可能来自语音识别，可能存在错别字，请结合上下文理解
                - 分析图片时要仔细观察细节，特别是产品缺陷、标签信息等
                - 如果无法确定用户意图，请友好地询问
                - 对于需要查询的订单信息，使用工具查询而不是猜测
                """)
            .build();
        this.sttModel = sttModel;
        this.ttsModel = ttsModel;
        this.orderService = orderService;
        this.knowledgeBaseService = knowledgeBaseService;
    }

    /**
     * 处理文字输入
     */
    public String handleText(String userMessage) {
        return chatClient.prompt()
            .user(userMessage)
            .tools(new OrderTools(orderService))
            .call()
            .content();
    }

    /**
     * 处理图片 + 文字输入
     */
    public String handleImageWithText(Resource image, String description) {
        return chatClient.prompt()
            .user(u -> u.text(description)
                .media(MimeTypeUtils.IMAGE_JPEG, image))
            .tools(new OrderTools(orderService))
            .call()
            .content();
    }

    /**
     * 处理语音输入
     */
    public String handleVoice(Resource audioFile) {
        // 语音转文字
        String userText = sttModel.call(
            new AudioTranscriptionPrompt(audioFile)
        ).getResult().getOutput();

        log.info("语音识别结果: {}", userText);

        // Agent 处理
        return chatClient.prompt()
            .user(userText)
            .tools(new OrderTools(orderService))
            .call()
            .content();
    }

    /**
     * 语音输出
     */
    public byte[] toVoice(String text) {
        return ttsModel.call(new SpeechPrompt(text))
            .getResult().getOutput();
    }
}

@RestController
@RequestMapping("/api/customer")
@RequiredArgsConstructor
public class CustomerAgentController {

    private final MultiModalCustomerAgent agent;

    @PostMapping("/text")
    public ResponseEntity<ChatResponse> textChat(@RequestBody TextRequest request) {
        String response = agent.handleText(request.getMessage());
        return ResponseEntity.ok(new ChatResponse(response));
    }

    @PostMapping("/image")
    public ResponseEntity<ChatResponse> imageChat(
            @RequestParam("image") MultipartFile image,
            @RequestParam(value = "description", defaultValue = "请分析这张图片") String description)
            throws IOException {
        Resource imageResource = new ByteArrayResource(image.getBytes()) {
            @Override public String getFilename() { return image.getOriginalFilename(); }
        };
        String response = agent.handleImageWithText(imageResource, description);
        return ResponseEntity.ok(new ChatResponse(response));
    }

    @PostMapping("/voice")
    public ResponseEntity<byte[]> voiceChat(
            @RequestParam("audio") MultipartFile audio) throws IOException {
        Resource audioResource = new ByteArrayResource(audio.getBytes()) {
            @Override public String getFilename() { return "voice.wav"; }
        };
        String textResponse = agent.handleVoice(audioResource);
        byte[] audioResponse = agent.toVoice(textResponse);
        return ResponseEntity.ok()
            .contentType(MediaType.parseMediaType("audio/mpeg"))
            .body(audioResponse);
    }
}

// 图片预处理：压缩 + 转换格式
@Service
public class ImagePreprocessor {

    /**
     * 压缩图片到指定尺寸，转换为 JPEG 以减小体积
     */
    public Resource preprocess(Resource image, int maxWidth) throws IOException {
        BufferedImage original = ImageIO.read(image.getInputStream());

        // 计算缩放比例
        double scale = Math.min(1.0, (double) maxWidth / original.getWidth());
        int newWidth = (int) (original.getWidth() * scale);
        int newHeight = (int) (original.getHeight() * scale);

        // 缩放
        BufferedImage resized = new BufferedImage(newWidth, newHeight, BufferedImage.TYPE_INT_RGB);
        resized.getGraphics().drawImage(
            original.getScaledInstance(newWidth, newHeight, Image.SCALE_SMOOTH),
            0, 0, null);

        // 转为 JPEG（比 PNG 小很多）
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ImageIO.write(resized, "jpg", baos);
        byte[] compressedBytes = baos.toByteArray();

        log.info("图片压缩: {} → {} bytes ({}% reduction)",
            image.contentLength(), compressedBytes.length,
            (1 - (double) compressedBytes.length / image.contentLength()) * 100);

        return new ByteArrayResource(compressedBytes);
    }
}

public String diagnoseWithKnowledge(Resource faultImage, String description) {
    return chatClient.prompt()
        .user(u -> u.text("""
            用户反馈了一个产品问题：%s。
            请先分析图片中的故障现象，然后根据知识库中的信息给出诊断建议。
            """.formatted(description))
            .media(MimeTypeUtils.IMAGE_JPEG, faultImage))
        .advisors(new QuestionAnswerAdvisor(vectorStore))  // RAG 检索
        .call()
        .content();
}

public String trackFromImage(Resource expressImage) {
    return chatClient.prompt()
        .user(u -> u.text("请识别这张图片中的快递单号，然后查询物流状态。")
            .media(MimeTypeUtils.IMAGE_JPEG, expressImage))
        .tools(new LogisticsTools())  // 物流查询工具
        .call()
        .content();
}

public String chatWithMemory(String sessionId, Resource image, String text) {
    return chatClient.prompt()
        .user(u -> u.text(text).media(MimeTypeUtils.IMAGE_JPEG, image))
        .advisors(new MessageChatMemoryAdvisor(chatMemory))
        .advisors(a -> a.param(CHAT_MEMORY_RETRIEVE_SIZE_KEY, 10))
        .call()
        .content();
}