/*
 *  Copyright 2025 Anyware Services
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package org.ametys.plugins.ai;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;

import javax.jcr.Repository;

import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.cocoon.components.ContextHelper;
import org.apache.cocoon.environment.Request;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.Strings;
import org.apache.commons.lang3.tuple.Pair;
import org.apache.tika.Tika;

import org.ametys.cms.content.indexing.solr.SolrFieldNames;
import org.ametys.cms.search.query.DocumentTypeQuery;
import org.ametys.cms.search.query.Query;
import org.ametys.cms.search.solr.SearcherFactory;
import org.ametys.cms.search.solr.SearcherFactory.Searcher;
import org.ametys.cms.search.solr.SolrClientProvider;
import org.ametys.cms.transformation.URIResolver;
import org.ametys.cms.transformation.URIResolverExtensionPoint;
import org.ametys.core.cache.AbstractCacheManager;
import org.ametys.core.cache.Cache;
import org.ametys.core.ui.Callable;
import org.ametys.core.upload.Upload;
import org.ametys.core.upload.UploadManager;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.util.JSONUtils;
import org.ametys.plugins.ai.provider.AIProvider;
import org.ametys.plugins.ai.provider.AIProviderExtensionPoint;
import org.ametys.plugins.ai.search.AIAdditionalDataIndexer;
import org.ametys.plugins.ai.search.CacheContentVersionChunk;
import org.ametys.plugins.ai.search.VectorQuery;
import org.ametys.plugins.explorer.resources.Resource;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.provider.WorkspaceSelector;
import org.ametys.runtime.config.Config;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;
import org.ametys.runtime.plugin.component.DeferredServiceable;
import org.ametys.web.WebHelper;
import org.ametys.web.indexing.solr.SolrWebFieldNames;
import org.ametys.web.renderingcontext.RenderingContext;
import org.ametys.web.renderingcontext.RenderingContextHandler;
import org.ametys.web.repository.content.WebContent;
import org.ametys.web.repository.page.Page;
import org.ametys.web.repository.site.Site;
import org.ametys.web.repository.site.SiteManager;

import dev.langchain4j.data.message.AiMessage;
import dev.langchain4j.data.message.SystemMessage;
import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.memory.ChatMemory;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;


/**
 * This is helper to use AI as image or text generation.
 */
public class AIHelper extends AbstractLogEnabled implements Component, DeferredServiceable, Contextualizable, Serviceable, Initializable
{
    /** Avalon role */
    public static final String ROLE = AIHelper.class.getName();
    /** The site configuration parameter for the a specific image prompt  */
    public static final String SITE_CONFIG_IMAGE_PROMPT = "aiImagePrompt";
    /** The site configuration parameter for the a specific text prompt  */
    public static final String SITE_CONFIG_TEXT_PROMPT = "aiTextPrompt";
    /** The site configuration parameter for the semantic indexation activation  */
    public static final String SITE_CONFIG_SEMANTIC_INDEXATION_ACTIVATE = "aiSemanticIndexationActivate";
    /** The site configuration parameter for the chatbot activation  */
    public static final String SITE_CONFIG_CHAT_ACTIVATE = "aiChatActivate";
    /** The site configuration parameter for the chatbot prompt */
    public static final String SITE_CONFIG_CHAT_PROMPT = "aiChatPrompt";
    /** The site configuration parameter for the chatbot name */
    public static final String SITE_CONFIG_CHAT_NAME = "aiChatName";
    

    /** A security hardcoded max for the text summarize */
    private static final int __TEXT_SUMMARIZE_MAXLENGTH = 1000;
    /** The prompt used to summarize a text. It contains one parameter: {maxLength}. */
    private static final String __TEXT_SUMMARIZE_PROMPT_PREFIX =
            "Create a summary of the following user provided text in **{maxLength} characters maximum**. Do not exceed this limit."
                    + "The summary is to be used in a search results page. "
                    + "Provide the answer in the language of the text to be summarized. Not another language. "
                    + "Provide the answer without any formating, title, or quotes, just raw text. "
                    + "If the text is incomprehensible, or if it's just a few words: just return the same text.";

    /** The prompt to generate an image. It contains no parameter. */
    private static final String __IMAGE_GENERATION_PROMPT_PREFIX =
            "Generate an image/illustration/photo to illustrate the following user provided text. The image must have no text (if any it should be in the same language as the text)."; // No text in the image, since generated text are always unreadable.
    
    /** The activate param */
    private static final String CONFIG_ACTIVATE = "ai.active";
    /** The provider configuration param */
    private static final String CONFIG_PROVIDER = "ai.provider";
    
    private static final String __CHAT_SUMMARY_PREFIX = "Here is a context:";
    private static final String __CHAT_SUMMARY_SUFFIX = "With the preceding context and the following sentence, tell me what I have to search in a semantic search engine ? don't add any fluff, just the keywords. Here is the senence:";

    
    private static final String __CHAT_PROMPT_SUFFIX = "\n"
            + "For the user, you should never refer to a \"document\" but rather a \"page on the website {url}\".\n"
            + "The correspondence between the document and the page is established by looking at the first two lines of each document.\n"
            + "The first line contains the page title.\n"
            + "The second line contains the URL of the page directly behind the text in brackets [URL to view the page online].\n"
            + "The following lines correspond to the content of the page.\n"
            + "\n"
            + "To do this:\n"
            + "1. Analyze the user's request.\n"
            + "2. Search the pages provided in the store.\n"
            + "3. Select relevant passages and extract them.\n"
            + "4. Provide a clear and concise response based on this information.\n"
            + "5. Systematically retrieve the exact URLs from the beginning lines of each page and provide them as clickable links.\n"
            + "   - Strict extraction after the marker [URL to view the page online].\n"
            + "   - Validation: the page title must match the context of the request.\n"
            + "\n"
            + "You can also use certain tools if necessary:\n"
            + "- **highlightArea**: to visually mark an area in the interface.\n"
            + "- **browseToPage**: to navigate to a page, only after explicit confirmation from the user.\n"
            + "\n"
            + "# Output format\n"
            + "- Provide a brief paragraph response.\n"
            + "- Avoid unnecessary technical jargon.\n"
            + "- Provide a mandatory list of clickable links to the corresponding pages.\n"
            + "- A clickable link should use the following format: [link text](URL).\n"
            + "- If no link can be provided, explain why.\n"
            + "\n"
            + "# Additional suggestions\n"
            + "Propose 1 to 2 questions that the user might ask next. Phrase them as the user would speak to the assistant.\n"
            + "Expected format:\n"
            + "```suggestions\n"
            + "Tell me more about...\n"
            + "What is the procedure for...\n"
            + "```\n"
            + "\n"
            + "# Additional rules\n"
            + "- If no exact match is found, provide the closest information while specifying the divergence.\n"
            + "- If nothing relevant is found, simply say: \"I found no relevant information on the site\".\n"
            + "- Never mention the word \"document\" in front of the user.\n"
            + "- Be attentive to sensitive information.\n";
    
    /** The prompt to add context to the embedding. It contains one parameter: {chunks} */
    private static final String __CHAT_PROMPT_CONTEXT =
            "The context is structured in JSON format, as an array containing the documents to be used. "
                    + "Each document have:\n"
                    + "- a \"chunk_content\" field corresponding to the text to be used to formulate the response. This content is divided in fields and each field introduced by \"**label of the field**:\" : the field labels are not part of the content it self but help you understand its value,\n"
                    + "- a \"chunk_uri\" field corresponding to the URL of the page. If \"chunk_uri\" is empty, do not invent a link, just do not put a link.\n\n"
                    + "Here are the chunks: {chunks}";
    
    /** The prompt introduction. It contains one parameter: {name} */
    private static final String __CHAT_PROMPT_INTRODUCTION = "You are a siteweb assistant named {name}";

    private static final String _CACHE_ID = AIHelper.class.getName();
    
    private static final int __MAX_NUMBER_OF_CHUNKS = 20;
    
    /** The extension point providing access to registered AI providers.*/
    protected AIProviderExtensionPoint _aiProviderEP;
    
    /** The upload manager used to upload images */
    protected UploadManager _uploadManager;
    
    /** The current user provider */
    protected CurrentUserProvider _currentUserProvider;
    
    /** The JSON utils used to convert JSON to objects */
    protected JSONUtils _jsonUtils;
    
    /** The searcher factory*/
    protected SearcherFactory _searcherFactory;
    
    /** The ametys uri resolver */
    protected URIResolverExtensionPoint _uriResolverEP;
    
    /** The ametys object resolver */
    protected AmetysObjectResolver _ametysObjectResolver;
    /** The solr client provider */
    protected SolrClientProvider _solrClientProvider;
    /** The site manager */
    protected SiteManager _siteManager;
    /** The avalon context */
    protected Context _context;
    /** The workspace selector */
    protected WorkspaceSelector _workspaceSelector;
    /** The jcr repository */
    protected Repository _repository;
    /** The Ametys cache manager */
    protected AbstractCacheManager _cacheManager;
    /** The rendering context handler */
    protected RenderingContextHandler _renderingContextHandler;
    
    public void service(ServiceManager manager) throws ServiceException
    {
        _cacheManager = (AbstractCacheManager) manager.lookup(AbstractCacheManager.ROLE);
    }
    
    public void initialize() throws Exception
    {
        _cacheManager.createRequestCache(
            _CACHE_ID,
            new I18nizableText("plugin.ai", "PLUGINS_AI_CACHE_EMBEDDING_LABEL"),
            new I18nizableText("plugin.ai", "PLUGINS_AI_CACHE_EMBEDDING_DESCRIPTION"),
            true
        );
    }
    
    public void deferredService(ServiceManager manager) throws ServiceException
    {
        _aiProviderEP = (AIProviderExtensionPoint) manager.lookup(AIProviderExtensionPoint.ROLE);
        _uploadManager = (UploadManager) manager.lookup(UploadManager.ROLE);
        _currentUserProvider = (CurrentUserProvider) manager.lookup(CurrentUserProvider.ROLE);
        _siteManager = (SiteManager) manager.lookup(SiteManager.ROLE);
        _jsonUtils = (JSONUtils) manager.lookup(JSONUtils.ROLE);
        _searcherFactory = (SearcherFactory) manager.lookup(SearcherFactory.ROLE);
        _solrClientProvider = (SolrClientProvider) manager.lookup(SolrClientProvider.ROLE);
        _uriResolverEP = (URIResolverExtensionPoint) manager.lookup(URIResolverExtensionPoint.ROLE);
        _ametysObjectResolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _workspaceSelector = (WorkspaceSelector) manager.lookup(WorkspaceSelector.ROLE);
        _repository = (Repository) manager.lookup(Repository.class.getName());
        _renderingContextHandler = (RenderingContextHandler) manager.lookup(RenderingContextHandler.ROLE);
    }
    
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    
    /**
     * Checks if a configured AI provider is available and supports text summarization.
     * This includes verifying the provider exists, has a valid text model, and is properly configured.
     * @return true if all is good, false otherwise
     */
    public boolean isEnabled()
    {
        return getCurrentAIProvider() != null;
    }
    
    /**
     * Summarize a given text
     * @param text The input text to be summarized.
     * @param maxLength The maximum number of characters for the summary.
     * @return A map with the Ai-generated summary under the key "summary".
     */
    @Callable(rights = "AI_Rights_Use")
    public Map<String, String> textToSummary(String text, int maxLength)
    {
        try
        {
            if (isEnabled())
            {
                return Map.of("summary", getCurrentAIProvider().textToSummary(text, maxLength));
            }
        }
        catch (Exception e)
        {
            getLogger().error("Error while summarizing text", e);
        }
        return Map.of("error", "error");
    }
    
    /**
     * Checks if a configured AI provider is available and supports image generation.
     * This includes verifying the provider exists, has a valid text model, and is properly configured.
     * @return true if all is good, false otherwise
     */
    public boolean isImageGenerationSupported()
    {
        AIProvider aiProvider = getCurrentAIProvider();
        if (aiProvider == null)
        {
            return false;
        }
        return aiProvider.isImageGenerationSupported();
    }

    /**
     * Checks if a configured AI provider is available and supports embedding.
     * @return true if supported, false otherwise
     */
    public boolean isEmbeddingSupported()
    {
        AIProvider aiProvider = getCurrentAIProvider();
        return aiProvider != null && aiProvider.isEmbeddingSupported();
    }
    
    /**
     * Checks if a configured AI provider is available and supports embedding and semantic indexation is activated on the current site.
     * @param siteName The site to consider
     * @return true if activated
     */
    public boolean isSemanticIndexationActivated(String siteName)
    {
        AIProvider aiProvider = getCurrentAIProvider();
        if (aiProvider == null || !aiProvider.isEmbeddingSupported())
        {
            return false;
        }
        
        try
        {
            Site site = _siteManager.getSite(siteName);
            return site.getValue(SITE_CONFIG_SEMANTIC_INDEXATION_ACTIVATE) == Boolean.TRUE;
        }
        catch (UnknownAmetysObjectException e)
        {
            getLogger().warn("There is no site '{}'", siteName);
            return false;
        }
    }
    
    /**
     * Checks if a configured AI provider is available and supports embedding and semantic indexation and chatbot are activated on the current site.
     * This includes verifying the provider exists, has a valid text model, and is properly configured.
     * @param siteName The site to consider
     * @return true if all is good, false otherwise
     */
    public boolean isChatbotEnabled(String siteName)
    {
        AIProvider aiProvider = getCurrentAIProvider();
        if (aiProvider == null || !aiProvider.isEmbeddingSupported())
        {
            return false;
        }
        
        try
        {
            Site site = _siteManager.getSite(siteName);
            return site.getValue(SITE_CONFIG_CHAT_ACTIVATE) == Boolean.TRUE && site.getValue(SITE_CONFIG_SEMANTIC_INDEXATION_ACTIVATE) == Boolean.TRUE;
        }
        catch (UnknownAmetysObjectException e)
        {
            getLogger().warn("There is not site '{}'", siteName);
            return false;
        }
    }

    /**
     * Generate an image with a given text
     * @param text The input text to generate the image with.
     * @param name The name for the generated image file.
     * @return A map with the URL of the Ai-generated image under the key "image".
     */
    @Callable(rights = "AI_Rights_Use")
    public Map<String, Object> textToImage(String text, String name)
    {
        try
        {
            if (isImageGenerationSupported())
            {
                Map<String, Object> imageAsJson = new HashMap<>();
                
                Path image = getCurrentAIProvider().textToImage(text);
                try (InputStream is = Files.newInputStream(image))
                {
                    Upload storeUpload = _uploadManager.storeUpload(_currentUserProvider.getUser(), name + "-AI-generated." + StringUtils.substringAfterLast(image.toString(), "."), is);
                    _fillSuccess(storeUpload, imageAsJson);
                    return imageAsJson;
                }
                catch (Exception e)
                {
                    getLogger().error("Error while accessing to the image", e);
                    return Map.of("error", "error");
                }
                finally
                {
                    Files.delete(image);
                }
            }
        }
        catch (Exception e)
        {
            getLogger().error("Error while generating the image", e);
        }
        return Map.of("error", "error");
    }
    
    /**
     * Summarize a resource
     * @param resource the resource to be summarized.
     * @param maxLength The maximum number of characters for the summary.
     * @return the summary.
     * @throws Exception if an error occurred
     */
    public String resourceToSummary(Resource resource, int maxLength) throws Exception
    {
        if (isEnabled())
        {
            try (InputStream is = resource.getInputStream())
            {
                Tika tika = new Tika();
                tika.setMaxStringLength(-1);
                String text = tika.parseToString(is);
                
                return getCurrentAIProvider().textToSummary(text, maxLength);
            }
        }
        return null;
    }
    
    /**
     * Fill the result map.
     * @param upload The upload
     * @param result The result map to fill
     */
    private void _fillSuccess(Upload upload, Map<String, Object> result)
    {
        result.put("success", true);
        result.put("id", upload.getId());
        result.put("filename", upload.getFilename());
        result.put("size", upload.getLength());
        result.put("viewHref", _getUrlForView(upload));
        result.put("downloadHref", _getUrlForDownload(upload));
    }
    
    /**
     * Get the url for view the uploaded file
     * @param upload The file uploaded
     * @return The url for view
     */
    private String _getUrlForView(Upload upload)
    {
        return "/plugins/core/upload/file?id=" + upload.getId();
    }
    
    /**
     * Get the url for download the uploaded file
     * @param upload The file uploaded
     * @return The url for view
     */
    private String _getUrlForDownload(Upload upload)
    {
        return "/plugins/core/upload/file?id=" + upload.getId() + "&download=true";
    }
    /**
     * Get the current AI Provider class
     * @return the AI provider
     */
    protected AIProvider getCurrentAIProvider()
    {
        if (Config.getInstance().getValue(CONFIG_ACTIVATE) == Boolean.TRUE)
        {
            String providerID = Config.getInstance().getValue(CONFIG_PROVIDER);
            return _aiProviderEP.getExtension(providerID);
        }
        else
        {
            return null;
        }
    }
    
    /**
     * Initialize the prompt with a given maximum length minus 10 characters to prevent the LLM to exceed the limit.
     * @param maxLength the number of characters allowed
     * @return the text of the prompt
     */
    public String getTextSummaryPrompt(int maxLength)
    {
        String siteName = null;
        
        Request request = ContextHelper.getRequest(_context);
        if (request != null)
        {
            siteName = WebHelper.getSiteName(request);
        }
        
        String prompt = "";
        
        if (StringUtils.isNotBlank(siteName))
        {
            try
            {
                Site site = _siteManager.getSite(siteName);
                prompt = site.getValue(SITE_CONFIG_TEXT_PROMPT);
                Strings.CS.appendIfMissing(prompt, ".");
            }
            catch (UnknownAmetysObjectException e)
            {
                getLogger().warn("There is not site '{}' to generate an image prompt", siteName);
            }
            
        }

        return (__TEXT_SUMMARIZE_PROMPT_PREFIX + " " + prompt).replace("{maxLength}", Integer.toString(Math.min(maxLength, __TEXT_SUMMARIZE_MAXLENGTH)));
    }
    

    /**
     * Initialize the prompt for image generation.
     * @return the text of the prompt
     */
    public String getImageGenerationPrompt()
    {
        String siteName = null;
        
        Request request = ContextHelper.getRequest(_context);
        if (request != null)
        {
            siteName = WebHelper.getSiteName(request);
        }
        
        String prompt = "";
        
        if (StringUtils.isNotBlank(siteName))
        {
            try
            {
                Site site = _siteManager.getSite(siteName);
                prompt = site.getValue(SITE_CONFIG_IMAGE_PROMPT);
                Strings.CS.appendIfMissing(prompt, ".");
            }
            catch (UnknownAmetysObjectException e)
            {
                getLogger().warn("There is not site '{}' to generate an image prompt", siteName);
            }
            
        }
        return __IMAGE_GENERATION_PROMPT_PREFIX + " " + prompt;
    }
    
    /**
     * Get the chat prompt.
     * @return the text of the prompt
     */
    private Pair<String, String> getChatPromptAndName()
    {
        String siteName = null;
        
        Request request = ContextHelper.getRequest(_context);
        if (request != null)
        {
            siteName = WebHelper.getSiteName(request);
        }
        
        String prompt = "";
        String name = "";
        
        if (StringUtils.isNotBlank(siteName))
        {
            try
            {
                Site site = _siteManager.getSite(siteName);
                prompt = site.getValue(SITE_CONFIG_CHAT_PROMPT);
                prompt = Strings.CS.appendIfMissing(prompt, ".")
                        + __CHAT_PROMPT_SUFFIX.replace("{url}", site.getUrl());
                name = site.getValue(SITE_CONFIG_CHAT_NAME);
            }
            catch (UnknownAmetysObjectException e)
            {
                getLogger().warn("There is not site '{}' to get the chat prompt", siteName);
            }
            
        }

        return Pair.of(prompt, name);
    }

    /**
     * Get the chatbot response according to the current provider.
     * @param userMessage text
     * @param historyJson the history of the conversation in JSON format
     * @param siteName The current site name
     * @param sitemapName The current sitemap name
     * @return the chatbot response message
     * @throws IOException if an error occurs
     */
    @Callable (rights = Callable.NO_CHECK_REQUIRED)
    public String askChatbot(String userMessage,  String historyJson, String siteName, String sitemapName) throws IOException
    {
        if (!isChatbotEnabled(siteName))
        {
            return null;
        }
        
        AIProvider provider = getCurrentAIProvider();
        
        List<Object> historyList = _jsonUtils.convertJsonToList(historyJson);
        
        try
        {
            List<Float> queryVector = null;
            
            if (historyList != null && historyList.size() > 0)
            {
                ChatMemory memory = MessageWindowChatMemory.withMaxMessages(500);
                memory.add(SystemMessage.from(__CHAT_SUMMARY_PREFIX));
                _addHistoryToChatMemory(historyList, memory);
                memory.add(SystemMessage.from(__CHAT_SUMMARY_SUFFIX));
                memory.add(UserMessage.from(userMessage));
                
                String aiResponse = provider.askChatbot(memory);
                if (aiResponse != null)
                {
                    queryVector = computeEmbedding(aiResponse);
                }
            }
            if (queryVector == null)
            {
                queryVector = computeEmbedding(userMessage);
            }
            
            List<Map<String, Object>> contextChunks = new ArrayList<>();

            Query q = new VectorQuery(AIAdditionalDataIndexer.SOLR_EMBEDDING, queryVector);
            
            Searcher searcher = _searcherFactory.create()
                    .withQuery(q)
                    .addFilterQuery(new DocumentTypeQuery(AIAdditionalDataIndexer.SOLR_TYPE))
                    .addFilterQueryString(SolrWebFieldNames.SITE_NAME + ":" + siteName)
                    .addFilterQueryString(SolrFieldNames.CONTENT_LANGUAGES + ":" + sitemapName)
                    .withLimits(0, __MAX_NUMBER_OF_CHUNKS)
                    .setCheckRights(true);
            AmetysObjectIterable<CacheContentVersionChunk> chunks = searcher.search();
            for (CacheContentVersionChunk chunk : chunks)
            {
                String uri = _getContentURL(chunk.getContentId());
                
                if (StringUtils.isNotBlank(uri))
                {
                    String chunkContent = chunk.getValue(AIAdditionalDataIndexer.DATA_CHUNK_CONTENT);
                    
                    Map<String, Object> chunkMap = new HashMap<>();
                    chunkMap.put("chunk_content", chunkContent);
                    chunkMap.put("chunk_uri", uri);
                    contextChunks.add(chunkMap);
                }
            }
            
            String contextJsonString = _jsonUtils.convertObjectToJson(contextChunks);
            String context = __CHAT_PROMPT_CONTEXT.replace("{chunks}", contextJsonString);
            
            ChatMemory memory = MessageWindowChatMemory.withMaxMessages(500);

            Pair<String, String> promptAndName = getChatPromptAndName();
            memory.add(SystemMessage.from(__CHAT_PROMPT_INTRODUCTION.replace("{name}", promptAndName.getRight()) + "\n" + promptAndName.getLeft() + "\n" + context));

            _addHistoryToChatMemory(historyList, memory);
            memory.add(UserMessage.from(userMessage));

            String aiResponse = provider.askChatbot(memory);
            return aiResponse != null ? aiResponse : null;
        }
        catch (Exception e)
        {
            getLogger().error("Error while getting chatbot response", e);
            return null;
        }
    }
    
    private void _addHistoryToChatMemory(List<Object> historyList, ChatMemory memory)
    {
        if (historyList != null)
        {
            for (Object o : historyList)
            {
                @SuppressWarnings("unchecked")
                Map<String, Object> map = (Map<String, Object>) o;
                String role = (String) map.get("role");
                String text = (String) map.get("text");

                if ("user".equals(role))
                {
                    memory.add(UserMessage.from(text));
                }
                else if ("ai".equals(role))
                {
                    memory.add(AiMessage.from(text));
                }
            }
        }

    }

    private String _getContentURL(String contentId)
    {
        RenderingContext currentRenderingContext = _renderingContextHandler.getRenderingContext();
        if (currentRenderingContext == RenderingContext.BACK)
        {
            // We do not resolve uri in the BACK context since it can links to javascript: for pages, and this does not work in the chatbot rendering.
            _renderingContextHandler.setRenderingContext(RenderingContext.PREVIEW);
        }
        
        try
        {
            AmetysObject obj = _ametysObjectResolver.resolveById(contentId);
    
            if (obj instanceof WebContent webContent)
            {
                Optional<Page> firstPage = webContent.getReferencingPages().stream().findFirst();
                if (firstPage.isPresent())
                {
                    URIResolver uriResolver = _uriResolverEP.getResolverForType("page");
                    if (uriResolver != null)
                    {
                        return uriResolver.resolve(firstPage.get().getId(), false, true, false);
                    }
                }
            }
            else if (obj instanceof Resource resource)
            {
                URIResolver uriResolver = _uriResolverEP.getResolverForType("attachment-content");
                if (uriResolver != null)
                {
                    return uriResolver.resolve(resource.getId(), false, true, false);
                }
            }
        }
        catch (Exception e)
        {
            getLogger().warn("The embedding vector references an unexisting ametys object : " + contentId, e);
        }
        finally
        {
            _renderingContextHandler.setRenderingContext(currentRenderingContext);
        }

        return "";
    }
    
    /**
     * Get the embedding of a text
     * @param text The text to get the embedding for
     * @return The embedding vector for the given text or null if an error occurred or embedding is not supported
     */
    public List<Float> computeEmbedding(String text)
    {
        return _getCache().get(text, t -> {
            AIProvider provider = getCurrentAIProvider();
            if (provider != null && provider.isEmbeddingSupported())
            {
                return provider.computeEmbedding(t);
            }
            return null;
        });
    }
    
    /**
     * Get the dimension of the embedding vector
     * @return The embedding dimension or -1 if not supported
     */
    public int getEmbeddingDimension()
    {
        AIProvider provider = getCurrentAIProvider();
        if (provider != null && provider.isEmbeddingSupported())
        {
            return provider.getEmbeddingDimension();
        }
        return -1;
    }
    
    /**
     * Get a string key identifying the embedding generator. Comparing this key between two calls allows to know if an existing embedding is still valid.
     * @return The embedding generator key or null if embedding is not supported
     */
    public String getEmbeddingGeneratorKey()
    {
        AIProvider provider = getCurrentAIProvider();
        if (provider != null)
        {
            return provider.getEmbeddingKey();
        }
        return null;
    }
    
    private Cache<String, List<Float>> _getCache()
    {
        return _cacheManager.get(_CACHE_ID);
    }
}