const { GoogleGenerativeAI } = require('@google/generative-ai');
require('dotenv').config();

// Get API key from environment variables
const GEMINI_API_KEY = process.env.GEMINI_API_KEY;

// Initialize API client
const genAI = GEMINI_API_KEY ? new GoogleGenerativeAI(GEMINI_API_KEY) : null;

/**
 * Generates an embedding vector for the given text
 * @param {String} text - Text to generate embedding for
 * @returns {Array} - Embedding vector
 */
async function getEmbedding(text) {
  const model = genAI.getGenerativeModel({ model: 'text-embedding-004' });
  const result = await model.embedContent(text);
  return result.embedding.values;
}

/**
 * Retrieves product information from Weaviate vector database
 * @param {String} query - Search query
 * @returns {Array} - Product information
 */
const getProductInfo = async (query) => {
  try {
    const embedding = await getEmbedding(query);

    // Use fixed alpha value for vector search
    const alpha = 0.5;

    // Clean query text for GraphQL - make it safe
    const cleanQuery = query
      .substring(0, 100) // Keep query at reasonable length
      .replace(/[^\w\s]/gi, '') // Remove non-alphanumeric characters
      .replace(/"/g, '') // Remove double quotes
      .trim();

    const data = JSON.stringify({
      query: `{
        Get {
          Ecommerce (
            hybrid: {
              query: "${cleanQuery}"
              alpha: ${alpha},
              vector: ${JSON.stringify(embedding)},
            }
            limit: 3
          ) {
            data
            _additional { score }
          }
        }
      }`,
    });

    const config = {
      method: 'post',
      url: process.env.WEAVIATE_URL + '/v1/graphql',
      headers: {
        'Content-Type': 'application/json',
        Authorization: `Bearer ${process.env.WEAVIATE_API_KEY}`,
      },
      data: data,
    };

    const response = await axios.request(config);
    return response.data.data.Get.Ecommerce.map((item) => item.data);
  } catch (error) {
    console.error('Error during Weaviate query:', error);
    return [];
  }
};

/**
 * Creates a new conversation
 * @param {String} title - Conversation title (optional)
 * @returns {Promise<Object>} - Created conversation
 */
const createConversation = async (title = null) => {
  try {
    // Assign default title if null
    const conversationTitle = title || 'New Conversation';
    
    const conversation = new Conversation({
      title: conversationTitle,
      messages: []
    });
    
    await conversation.save();
    return conversation;
  } catch (error) {
    console.error('Error creating conversation:', error);
    throw error;
  }
};

/**
 * Adds a message to a conversation
 * @param {String} conversationId - Conversation ID
 * @param {String} role - Message role (user/assistant)
 * @param {String} content - Message content
 * @returns {Promise<Object>} - Updated conversation
 */
const addMessageToConversation = async (conversationId, role, content) => {
  try {
    const conversation = await Conversation.findById(conversationId);
    if (!conversation) {
      throw new Error(`Conversation not found with ID: ${conversationId}`);
    }
    
    conversation.messages.push({
      role,
      content,
      timestamp: new Date()
    });
    
    conversation.updatedAt = new Date();
    await conversation.save();
    return conversation;
  } catch (error) {
    console.error('Error adding message to conversation:', error);
    throw error;
  }
};

/**
 * Determines if a message is a follow-up question based on conversation history
 * @param {Array} conversationHistory - Array of previous conversation messages
 * @returns {String} - JSON string indicating if message is a follow-up (true/false)
 */
const classifierAgent = async (conversationHistory) => {
  try {
    // Format conversation history for the AI model
    const formattedHistory = conversationHistory
      .map((msg) => `${msg.role === 'user' ? 'User' : 'Assistant'}: ${msg.content}`)
      .join('\n');

    const response = await axios({
      method: 'post',
      url: 'https://openrouter.ai/api/v1/chat/completions',
      headers: {
        Authorization: `Bearer ${process.env.OPENROUTER_API_KEY}`,
        'Content-Type': 'application/json',
      },
      data: {
        model: 'google/gemini-2.0-flash-001',
        messages: [
          {
            role: 'system',
            content: `You are a sophisticated AI agent specializing in determining if a user's message is a follow-up question to a previous conversation. A follow-up question is a question that refers to or builds upon a previous question or response in the conversation. For example, if a user asks about a product and then asks about its price, the second question is a follow-up question.

            Analyze the conversation history and determine if the last user message is a follow-up question. Return only a JSON boolean value (true or false) as plain text.`,
          },
          {
            role: 'user',
            content: `Here is the conversation history:\n${formattedHistory}\n\nIs the last user message a follow-up question?`,
          },
        ],
      },
    });

    return response.data.choices[0].message.content.replace(/\n+$/, '');
  } catch (error) {
    console.error('OpenRouter API error:', error);
    return 'false';
  }
};

// If it's a follow-up question, include previous user questions
if (isFollowUp && conversationHistory.length >= 3) {
  // Find previous user messages (last 2 user messages)
  const userMessages = conversationHistory.filter((msg) => msg.role === 'user').slice(-2);

  if (userMessages.length >= 2) {
    const previousUserMessage = userMessages[0].content; // Previous user message
    searchQuery = `${await translatorAgent(previousUserMessage)} ${translatedMessage}`;
    console.log(`Expanded search query (follow-up): "${searchQuery}"`);
  }
}

/**
 * Translates user messages to English
 * @param {String} message - User message to translate
 * @returns {String} - Translated message in English
 */
const translatorAgent = async (message) => {
  try {
    const response = await axios({
      method: 'post',
      url: 'https://openrouter.ai/api/v1/chat/completions',
      headers: {
        Authorization: `Bearer ${process.env.OPENROUTER_API_KEY}`,
        'Content-Type': 'application/json',
      },
      data: {
        model: 'google/gemini-2.0-flash-001',
        messages: [
          {
            role: 'system',
            content: `You are a sophisticated AI agent specializing in translating user queries from multiple languages into English. Before translating, you identify and correct typos, grammatical errors, and punctuation mistakes in the source text to ensure clarity and readability. Your translations should maintain the original context and be culturally nuanced. Return only the translated text as plain text.`,
          },
          {
            role: 'user',
            content: message,
          },
        ],
      },
    });

    return response.data.choices[0].message.content.replace(/\n+$/, '');
  } catch (error) {
    console.error('OpenRouter API error:', error);
    return message; // Fallback to original message
  }
};

const messageContent = `
  You are a helpful shopping assistant that can answer questions about products. Based on the user's question "${prompt}", analyze the product information in the context: ${context} and return information only about the most relevant matching product(s). Answer questions related to the ${category} of the product(s). Answer as humanly as possible and in the same language as the ${prompt}, but be careful with special names such as brand, model, etc. - don't translate those.
  
  // ... additional instructions ...
`;

/**
 * Generates a response using Gemini or falls back to OpenRouter API
 * @param {String} prompt - User message
 * @param {String} context - Product information or other context
 * @param {String} category - Message category
 * @param {Array} conversationHistory - Conversation history
 * @returns {String} - AI response
 */
const generateGeminiResponse = async (prompt, context, category, conversationHistory = []) => {
  try {
    // Format conversation history for the AI model
    const formattedHistory = conversationHistory
      .map((msg) => `${msg.role === 'user' ? 'User' : 'Assistant'}: ${msg.content}`)
      .join('\n');

    const messageContent = `
      You are a helpful shopping assistant that can answer questions about products. Based on the user's question "${prompt}", analyze the product information in the context: ${context} and return information only about the most relevant matching product(s). Answer questions related to the ${category} of the product(s). Answer as humanly as possible and in the same language as the ${prompt}, but be careful with special names such as brand, model, etc. - don't translate those.
      
      If the category is [PRODUCT_INFO] and the question is about general product information (like price, features, specifications etc), include [SHOW_PRODUCT_INFO] at the end of your response so that product information can be formatted and displayed to the user.
      
      If the question is specifically about product reviews, ratings or customer feedback, do not include [SHOW_PRODUCT_INFO]. Instead, focus on providing a summary of the reviews and ratings from the available data.

      Also consider follow up questions. If the user asks a follow up question about a product mentioned earlier, your answer should be about the SAME product. Do not switch to a different product unless the user explicitly asks about a new product.

      At the end of your response, include a JSON object with an array of product IDs that you referenced in your answer, in the format: [PRODUCT_IDS]{"ids":["id1","id2"]}[/PRODUCT_IDS]

      Here is the conversation history so far:
      ${formattedHistory}
      
      User: ${prompt}
      Assistant:
    `;

    try {
      // Use Gemini API
      const model = genAI.getGenerativeModel({
        model: 'gemini-2.0-flash',
        systemInstruction: messageContent,
      });

      const res = await model.generateContent(prompt);
      return res.response.text();
    } catch (geminiError) {
      // Fall back to OpenRouter API if Gemini fails
      console.log('Gemini API failed, trying OpenRouter API...');

      const openRouterResponse = await axios.post(
        'https://openrouter.ai/api/v1/chat/completions',
        {
          model: 'anthropic/claude-3-opus:beta',
          messages: [{ role: 'user', content: messageContent }],
        },
        {
          headers: {
            Authorization: `Bearer ${process.env.OPENROUTER_API_KEY}`,
            'Content-Type': 'application/json',
          },
        }
      );

      return openRouterResponse.data.choices[0].message.content;
    }
  } catch (error) {
    console.error('Error generating AI response:', error);
    return 'Sorry, an error occurred while generating a response: ' + error.message;
  }
};

/**
 * Formats product information into HTML for display
 * @param {Array} products - Array of product objects
 * @returns {String} - HTML formatted product information
 */
const formatProductInfo = (products) => {
  if (!products || products.length === 0) {
    return 'İlgili ürün bilgisi bulunamadı.';
  }

  if (products.error) {
    return products.message;
  }

  let productsHTML = '<div class="products-container">';

  products.forEach((product) => {
    const parsedProduct = typeof product === 'string' ? JSON.parse(product) : product;

    productsHTML += `
      <div class="product-card">
        <div class="product-image">
          <img src="${parsedProduct.thumbnail || parsedProduct.images?.[0]}" 
               alt="${parsedProduct.title || 'Ürün Görseli'}" 
               loading="lazy">
        </div>
        <div class="product-info">
          <h3 class="product-title">${parsedProduct.title || 'İsim belirtilmemiş'}</h3>
          <p class="product-description">${parsedProduct.description || 'Açıklama belirtilmemiş'}</p>
          <div class="product-price-container">
            <span class="product-price">$${parsedProduct.price || 'Fiyat belirtilmemiş'}</span>
          </div>
          <a href="/product/${parsedProduct.id}" class="product-detail-button" target="_blank">
            Detaylar
          </a>
        </div>
      </div>
    `;
  });

  productsHTML += '</div>';
  return productsHTML;
};

// Extract product IDs from AI response
const productIdsMatch = response.match(/\[PRODUCT_IDS\](.*?)\[\/PRODUCT_IDS\]/);

let productsToShow;
if (productIdsMatch) {
  // Get product IDs specified by AI
  const productIds = JSON.parse(productIdsMatch[1]).ids;

  // Filter products to only show those with specified IDs
  productsToShow = products.filter((product) => {
    const parsedProduct = typeof product === 'string' ? JSON.parse(product) : product;
    return productIds.includes(parsedProduct.id.toString());
  });

  // Remove ID tags from response
  response = response.replace(/\[PRODUCT_IDS\].*?\[\/PRODUCT_IDS\]/, '');
} else {
  // Show all products if no IDs specified
  productsToShow = products;
}

// Format product information and add to response
const productInfo = productService.formatProductInfo(productsToShow);
response = response + productInfo;

/**
 * Categorizes user messages into predefined categories
 * @param {String} message - User message to categorize
 * @returns {String} - Category of the message
 */
const categorizerAgent = async (message) => {
  try {
    const response = await axios({
      method: 'post',
      url: 'https://openrouter.ai/api/v1/chat/completions',
      headers: {
        Authorization: `Bearer ${process.env.OPENROUTER_API_KEY}`,
        'Content-Type': 'application/json',
      },
      data: {
        model: 'google/gemini-2.0-flash-001',
        messages: [
          {
            role: 'system',
            content: `You are a sophisticated AI agent specializing in categorizing user queries into one of the following categories:
            [PRODUCT_INFO] - Questions about product information, features, specifications, price, etc.
            [PRODUCT_COMPARISON] - Questions comparing multiple products
            [PRODUCT_RECOMMENDATION] - Questions asking for product recommendations
            [PRODUCT_AVAILABILITY] - Questions about product availability
            [PRODUCT_REVIEWS] - Questions about product reviews or ratings
            [GENERAL_INQUIRY] - General questions not related to specific products
            [CUSTOMER_SERVICE] - Questions about customer service, shipping, returns, etc.
            [OTHER] - Any other type of question
            
            Return only the category as plain text.`,
          },
          {
            role: 'user',
            content: message,
          },
        ],
      },
    });

    return response.data.choices[0].message.content.replace(/\n+$/, '');
  } catch (error) {
    console.error('OpenRouter API error:', error);
    return '[GENERAL_INQUIRY]';
  }
};

/**
 * Processes chat messages and generates AI responses
 * @param {Object} req - Express request object
 * @param {Object} res - Express response object
 */
const processChat = async (req, res) => {
  try {
    let { message, conversationId } = req.body;

    if (!message) {
      return res.status(400).json({ error: 'Message is required' });
    }

    // Categorize the message
    const category = await categorizerAgent(message);

    // Get existing conversation or create new one
    let conversation;
    try {
      if (conversationId) {
        conversation = await conversationService.getConversationById(conversationId);
      } else {
        conversation = await conversationService.createConversation();
      }
    } catch (error) {
      // Create a new conversation in case of error
      conversation = await conversationService.createConversation();
    }

    // Add user message to conversation
    await conversationService.addMessageToConversation(conversation._id, 'user', message);

    // Get conversation history (last 4 messages)
    const conversationHistory = await conversationService.getConversationMessages(conversation._id, 4);

    // Translate message to English
    let translatedMessage = await translatorAgent(message);

    // Determine if message is a follow-up question
    let isFollowUp = false;
    if (conversationHistory.length >= 3) {
      // Use classifierAgent to determine if it's a follow-up
      const response = await classifierAgent(conversationHistory);
      const parsedResponse = JSON.parse(response);
      isFollowUp = parsedResponse;
    }

    // Prepare search query
    let searchQuery = translatedMessage;
    if (isFollowUp && conversationHistory.length >= 3) {
      // Find previous user messages (last 2 user messages)
      const userMessages = conversationHistory.filter((msg) => msg.role === 'user').slice(-2);
      if (userMessages.length >= 2) {
        const previousUserMessage = userMessages[0].content; // Previous user message
        searchQuery = `${await translatorAgent(previousUserMessage)} ${translatedMessage}`;
      }
    }

    // Get product information from Weaviate
    const products = await vectorService.getProductInfo(searchQuery);

    // Process response based on product information
    let response;
    if (products && products.length > 0) {
      // Send product information to AI in JSON format
      const productContext = JSON.stringify(products);

      // Send category and conversation history to AI
      response = await aiService.generateGeminiResponse(message, productContext, category, conversationHistory);
      
      // Clean [SHOW_PRODUCT_INFO] tag
      const cleanedResponse = response.replace('[SHOW_PRODUCT_INFO]', '');
      await conversationService.addMessageToConversation(conversation._id, 'assistant', cleanedResponse);

      // Check if product information should be displayed
      if (response.includes('[SHOW_PRODUCT_INFO]')) {
        // Process and display product information
        // ... (code omitted for brevity)
      }
    } else {
      // If no product information found
      const productInfo = JSON.stringify({ message: 'İlgili ürün bilgisi bulunamadı.' });
      response = await aiService.generateGeminiResponse(message, productInfo, category, conversationHistory);
      const cleanedResponse = response.replace('[SHOW_PRODUCT_INFO]', '');
      await conversationService.addMessageToConversation(conversation._id, 'assistant', cleanedResponse);
    }

    // Return response
    res.json({
      response: response,
      conversationId: conversation._id.toString(),
      timestamp: new Date().toISOString(),
    });
  } catch (error) {
    console.error('Chat processing error:', error);
    res.status(500).json({ error: 'Mesaj işlenirken bir hata oluştu: ' + error.message });
  }
};

<script src="https://your-domain.com/js/widget.js"></script>

// Widget initialization
function initWidget() {
  // Create widget HTML
  const widgetContainer = document.createElement('div');
  widgetContainer.innerHTML = createWidgetHTML();
  document.body.appendChild(widgetContainer);

  // Set up event listeners
  const chatForm = document.getElementById('chachaForm');
  const messageInput = document.getElementById('chachaMessageInput');
  const chatMessages = document.getElementById('chachaMessages');
  
  // Initialize conversationId as null (no longer using localStorage)
  let conversationId = null;

  // Add welcome message
  addMessage('Merhaba! Alışverişinizde size nasıl yardımcı olabilirim?', 'bot');

  // Form submission handler
  chatForm.addEventListener('submit', async (e) => {
    e.preventDefault();
    const message = messageInput.value.trim();
    if (!message) return;

    // Add user message to chat
    addMessage(message, 'user');
    messageInput.value = '';
    messageInput.style.height = 'auto';

    // Add loading indicator
    const loadingMessage = addLoadingMessage();

    try {
      // Send message to API
      const response = await fetch('/api/chat', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({
          message,
          conversationId,
        }),
      });

      // Remove loading indicator
      loadingMessage.remove();

      if (response.ok) {
        const data = await response.json();
        
        // Add AI response to chat
        if (data.response) {
          addMessage(data.response, 'bot', true);
        } else if (data.data && data.data.message) {
          addMessage(data.data.message, 'bot', true);
        } else if (data.message) {
          addMessage(data.message, 'bot', true);
        } else {
          addMessage('Üzgünüm, bir hata oluştu. Lütfen tekrar deneyin.', 'bot');
        }

        // Store conversation ID for future messages
        if (data.conversationId) {
          conversationId = data.conversationId;
        }
      } else {
        addMessage('Üzgünüm, bir hata oluştu. Lütfen tekrar deneyin.', 'bot');
      }
    } catch (error) {
      console.error('Error:', error);
      loadingMessage.remove();
      addMessage('Üzgünüm, bir hata oluştu. Lütfen tekrar deneyin.', 'bot');
    }
  });
}

### Duyarlı Tasarım

Sohbet widget'ı hem masaüstü hem de mobil cihazlarda iyi çalışacak şekilde duyarlı olarak tasarlanmıştır:

```javascript
// Mobile device detection
const isMobile = window.matchMedia('(max-width: 480px)').matches;

// Chat toggle functionality
chatToggle.addEventListener('click', () => {
  chatContainer.classList.toggle('collapsed');

  // Prevent body scroll when chat is open on mobile
  if (isMobile && !chatContainer.classList.contains('collapsed')) {
    document.body.style.overflow = 'hidden';
  } else if (isMobile) {
    document.body.style.overflow = '';
  }
});

// Window resize handler
window.addEventListener('resize', () => {
  const isMobileNow = window.matchMedia('(max-width: 480px)').matches;

  // Update body scroll behavior on resize
  if (isMobileNow && !chatContainer.classList.contains('collapsed')) {
    document.body.style.overflow = 'hidden';
  } else if (isMobileNow) {
    document.body.style.overflow = '';
  }
});

.chacha-widget {
  position: fixed;
  bottom: 20px;
  right: 20px;
  z-index: 1000;
  font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
}

.chat-toggle {
  width: 60px;
  height: 60px;
  border-radius: 50%;
  background-color: #2563EB;
  color: white;
  border: none;
  cursor: pointer;
  display: flex;
  align-items: center;
  justify-content: center;
  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
  transition: all 0.3s ease;
}

.chat-container {
  position: absolute;
  bottom: 80px;
  right: 0;
  width: 350px;
  height: 500px;
  background-color: white;
  border-radius: 12px;
  box-shadow: 0 5px 25px rgba(0, 0, 0, 0.2);
  display: flex;
  flex-direction: column;
  transition: all 0.3s ease;
  overflow: hidden;
}

/* Additional styles omitted for brevity */

{
  "info": {
    "name": "ecommerceRAG API",
    "description": "A collection for testing the ecommerceRAG API endpoints",
    "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
  },
  "item": [
    {
      "name": "Chat",
      "description": "Endpoints for chat functionality",
      "item": [
        {
          "name": "Process Chat Message",
          "request": {
            "method": "POST",
            "header": [
              {
                "key": "Content-Type",
                "value": "application/json"
              }
            ],
            "body": {
              "mode": "raw",
              "raw": "{\n    \"message\": \"What laptops do you have?\",\n    \"conversationId\": null\n}"
            },
            "url": {
              "raw": "{{baseUrl}}/api/chat",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "api",
                "chat"
              ]
            },
            "description": "Process a chat message and get a response from the AI"
          }
        },
        {
          "name": "Process Follow-up Message",
          "request": {
            "method": "POST",
            "header": [
              {
                "key": "Content-Type",
                "value": "application/json"
              }
            ],
            "body": {
              "mode": "raw",
              "raw": "{\n    \"message\": \"What is the price range?\",\n    \"conversationId\": \"{{conversationId}}\"\n}"
            },
            "url": {
              "raw": "{{baseUrl}}/api/chat",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "api",
                "chat"
              ]
            },
            "description": "Process a follow-up message in an existing conversation"
          }
        }
      ]
    },
    {
      "name": "Conversations",
      "description": "Endpoints for managing conversations",
      "item": [
        {
          "name": "Get All Conversations",
          "request": {
            "method": "GET",
            "url": {
              "raw": "{{baseUrl}}/api/conversations",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "api",
                "conversations"
              ]
            },
            "description": "Get a list of all conversations"
          }
        }
        // Additional endpoints omitted for brevity
      ]
    },
    {
      "name": "Products",
      "description": "Endpoints for product information",
      "item": [
        {
          "name": "Get Product Detail",
          "request": {
            "method": "GET",
            "url": {
              "raw": "{{baseUrl}}/product/{{productId}}",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "product",
                "{{productId}}"
              ]
            },
            "description": "Get detailed information about a specific product"
          }
        }
      ]
    }
  ]
}