// inventory-tools.service.ts
import { Injectable } from '@nestjs/common';

@Injectable()
export class InventoryTools {
  /**
   * Tool 1: Fetches problematic items from our private database.
   * Deterministic logic lives here: the SQL query defines what is "low".
   */
  async getLowStockItems() {
    console.log('--- Tool Executed: Checking Database ---');
    // Mocking a database result
    return [
      { id: 'kbd-99', name: 'Mechanical Keyboard', stock: 2, threshold: 10 }
    ];
  }

  /**
   * Tool 2: Fetches pricing from an external supplier.
   */
  async getSupplierPrice(productId: string) {
    console.log(`--- Tool Executed: Fetching Price for ${productId} ---`);
    const prices = { 'kbd-99': 45.00 };
    return { 
      productId, 
      price: prices[productId] || 0, 
      currency: 'USD',
      leadTime: '2 days' 
    };
  }
}

// inventory-agent.controller.ts
import { Controller, Post, Body } from '@nestjs/common';
import { GoogleGenerativeAI } from "@google/generative-ai";
import { InventoryTools } from './inventory-tools.service';

@Controller('agent')
export class InventoryAgentController {
  private model;

  constructor(private readonly tools: InventoryTools) {
    const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);
    
    this.model = genAI.getGenerativeModel({
      model: "gemini-1.5-flash",
      // This describes the tools so the LLM knows when to call them
      tools: [{
        functionDeclarations: [
          {
            name: "getLowStockItems",
            description: "Queries the database for products currently below their minimum stock level.",
          },
          {
            name: "getSupplierPrice",
            description: "Retrieves wholesale pricing and lead times for a specific product ID.",
            parameters: {
              type: "object",
              properties: {
                productId: { type: "string", description: "The SKU or ID of the product" }
              },
              required: ["productId"]
            }
          }
        ]
      }]
    });
  }
}

@Post('run')
async runAgent(@Body('prompt') prompt: string) {
  // Start a stateful chat session
  const chat = this.model.startChat();
  
  // Turn 1: User sends the prompt
  let result = await chat.sendMessage(prompt);
  let response = result.response;
  
  // Check if the AI wants to call a tool
  const calls = response.functionCalls();

  if (calls && calls.length > 0) {
    const call = calls[0]; // For simplicity, we handle the first call

    // 1. EXECUTE: Dynamically call the tool method in our service
    // We use bracket notation to find the method by the name the AI provided
    const toolData = await this.tools[call.name](...Object.values(call.args));

    // 2. OBSERVE: Send the real-world data back to the Agent
    // The Agent now "sees" the stock levels and prices
    const finalResult = await chat.sendMessage([{
      functionResponse: {
        name: call.name,
        response: { content: toolData }
      }
    }]);

    // Turn 2: The Agent provides the final reasoned answer
    return {
      agentResponse: finalResult.response.text(),
      actionsTaken: [call.name]
    };
  }

  return { agentResponse: response.text(), actionsTaken: [] };
}