@RestController
public class ChatController {

    private final WatsonxAiChatModel chatModel;

    public ChatController(WatsonxAiChatModel chatModel) {
        this.chatModel = chatModel;
    }

    @GetMapping("/chat")
    public String chat(@RequestParam String message) {
        return chatModel.call(message);
    }

    @GetMapping("/chat/stream")
    public Flux<String> chatStream(@RequestParam String message) {
        return chatModel.stream(new Prompt(message))
            .map(response -> response.getResult().getOutput().getContent());
    }
}

@RestController
public class EmbeddingController {

    private final WatsonxAiEmbeddingModel embeddingModel;

    public EmbeddingController(WatsonxAiEmbeddingModel embeddingModel) {
        this.embeddingModel = embeddingModel;
    }

    @GetMapping("/embed")
    public List<Double> embed(@RequestParam String text) {
        return embeddingModel.embed(text);
    }
}

@RestController
public class ModerationController {

    private final WatsonxAiModerationModel moderationModel;

    public ModerationController(WatsonxAiModerationModel moderationModel) {
        this.moderationModel = moderationModel;
    }

    @PostMapping("/moderate")
    public ModerationResponse moderate(@RequestBody String text) {
        ModerationPrompt prompt = new ModerationPrompt(text);
        return moderationModel.call(prompt);
    }
}

@RestController
public class RerankController {

    private final WatsonxAiDocumentReranker documentReranker;

    public RerankController(WatsonxAiDocumentReranker documentReranker) {
        this.documentReranker = documentReranker;
    }

    @PostMapping("/rerank")
    public List<Document> rerank(@RequestParam String query, @RequestBody List<Document> documents) {
        return documentReranker.rerank(documents, query);
    }
}

@Bean
@Description("Get current weather information")
public Function<WeatherRequest, WeatherResponse> getCurrentWeather() {
    return request -> {
        // Implementation to fetch weather data
        return new WeatherResponse(25.0, "sunny", request.location());
    };
}

@Configuration
public class MultiModelConfiguration {

    @Bean("creativeChatModel")
    public WatsonxAiChatModel creativeChatModel(WatsonxAiChatApi chatApi) {
        return new WatsonxAiChatModel(chatApi,
            WatsonxAiChatOptions.builder()
                .withModel("meta-llama/llama-3-70b-instruct")
                .withTemperature(1.2)
                .build());
    }
}

@GetMapping(value = "/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<ServerSentEvent<String>> streamResponse(@RequestParam String prompt) {
    return chatModel.stream(new Prompt(prompt))
        .map(response -> response.getResult().getOutput().getContent())
        .map(content -> ServerSentEvent.<String>builder().data(content).build());
}

@Service
public class ContentModerationService {

    private final WatsonxAiModerationModel moderationModel;

    public ContentModerationService(WatsonxAiModerationModel moderationModel) {
        this.moderationModel = moderationModel;
    }

    public boolean isContentSafe(String userInput) {
        ModerationPrompt prompt = new ModerationPrompt(userInput);
        ModerationResponse response = moderationModel.call(prompt);
        
        // Check if any detector flagged the content
        return !response.getResult().getOutput().getResults().get(0).isFlagged();
    }

    public ContentAnalysis analyzeContent(String text) {
        ModerationPrompt prompt = new ModerationPrompt(text);
        ModerationResponse response = moderationModel.call(prompt);
        
        var result = response.getResult().getOutput().getResults().get(0);
        CategoryScores scores = result.getCategoryScores();
        
        return new ContentAnalysis(
            result.isFlagged(),
            scores.getHate(),
            scores.getHarassment(),
            scores.getSelfHarm(),
            scores.getSexual(),
            scores.getViolence()
        );
    }
}

// Get detailed detection information
WatsonxAiModerationResponseMetadata metadata =
    (WatsonxAiModerationResponseMetadata) response.getMetadata();

List<Map<String, Object>> detections = metadata.getDetections();
for (Map<String, Object> detection : detections) {
    String detectionType = (String) detection.get("detectionType"); // "hap", "pii", etc.
    String detectedText = (String) detection.get("text");
    Float confidenceScore = (Float) detection.get("score");
    Integer startPosition = (Integer) detection.get("start");
    Integer endPosition = (Integer) detection.get("end");
    
    System.out.println(String.format(
        "Detected %s: '%s' (score: %.2f) at position %d-%d",
        detectionType, detectedText, confidenceScore, startPosition, endPosition
    ));
}

@Service
public class CustomerSupportService {

    private final WatsonxAiChatModel chatModel;

    public String handleQuery(String customerId, String query) {
        var options = WatsonxAiChatOptions.builder()
            .withModel("ibm/granite-13b-chat-v2")
            .withTemperature(0.3)
            .withFunction("getOrderStatus")
            .withFunction("createSupportTicket")
            .build();

        return chatModel.call(new Prompt(buildContextualPrompt(customerId, query), options));
    }
}

@Service
public class DocumentAnalysisService {

    private final WatsonxAiChatModel chatModel;
    private final WatsonxAiEmbeddingModel embeddingModel;

    public DocumentAnalysis analyzeDocument(String content) {
        // Generate summary
        String summary = chatModel.call("Summarize: " + content);
        
        // Generate embeddings for similarity search
        List<Double> embeddings = embeddingModel.embed(content);
        
        return new DocumentAnalysis(summary, embeddings);
    }
}

@Service
public class SafeContentPipeline {

    private final WatsonxAiModerationModel moderationModel;
    private final WatsonxAiChatModel chatModel;

    public String processUserInput(String userInput) {
        // Step 1: Check content safety
        ModerationPrompt moderationPrompt = new ModerationPrompt(userInput);
        ModerationResponse moderationResponse = moderationModel.call(moderationPrompt);
        
        if (moderationResponse.getResult().getOutput().getResults().get(0).isFlagged()) {
            return "Your input contains inappropriate content. Please revise.";
        }
        
        // Step 2: Process safe content with chat model
        return chatModel.call(userInput);
    }
}

@Service
public class RAGPipelineService {

    private final WatsonxAiChatModel chatModel;
    private final WatsonxAiEmbeddingModel embeddingModel;
    private final WatsonxAiDocumentReranker documentReranker;
    private final VectorStore vectorStore;

    public String answerQuestion(String question) {
        // Step 1: Retrieve relevant documents using embeddings
        List<Document> retrievedDocs = vectorStore.similaritySearch(
            SearchRequest.query(question).withTopK(10)
        );
        
        // Step 2: Rerank documents for better relevance
        List<Document> rerankedDocs = documentReranker.rerank(retrievedDocs, question);
        
        // Step 3: Generate answer using top reranked documents
        String context = rerankedDocs.stream()
            .limit(3)
            .map(Document::getContent)
            .collect(Collectors.joining("\n\n"));
        
        String prompt = String.format(
            "Based on the following context, answer the question.\n\nContext:\n%s\n\nQuestion: %s",
            context, question
        );
        
        return chatModel.call(prompt);
    }
}