index.ts

import { onRequest } from "firebase-functions/v2/https";
import { setGlobalOptions } from "firebase-functions/v2";
import * as admin from "firebase-admin";
import express from "express";
import cors from "cors";
import helmet from "helmet";
import rateLimit from "express-rate-limit";
import { checkGrammar } from "./services/grammarService";
import advancedGrammarService from "./services/advancedGrammarService";
import transliterationService from "./services/transliterationService";
import {
  validateApiKey,
  checkUserLimits,
  updateUserUsage,
} from "./middleware/auth";
import {
  validateTranslateRequest,
  validateGrammarRequest,
  validateChatRequest,
} from "./middleware/validation";
import { errorHandler } from "./middleware/errorHandler";
import {
  ApiResponse,
  TranslateRequest,
  GrammarRequest,
  GeminiChatRequest,
  GeminiChatResponse,
} from "./types";
import { translateText } from "./services/translationService";
import { freeTranslateText } from "./services/freeTranslationService";
import { log } from "console";
import {
  ChatSessionManager,
  generateSessionId,
} from "./manager/ChatSessionManager";
import { user } from "firebase-functions/v1/auth";

// Set global options for all functions
setGlobalOptions({
  region: "asia-south1", // Mumbai region
  maxInstances: 10,
  timeoutSeconds: 60,
  memory: "256MiB",
});

// Initialize Firebase Admin
admin.initializeApp();

const app = express();

// Security middleware
app.use(helmet());
app.use(
  cors({
    origin: process.env.ALLOWED_ORIGINS?.split(",") || [
      "http://localhost:3000",
    ],
    credentials: true,
  })
);

// Rate limiting
const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100, // Limit each IP to 100 requests per windowMs
  message: "Too many requests from this IP, please try again later.",
  standardHeaders: true,
  legacyHeaders: false,
});

app.use(limiter);
app.use(express.json({ limit: "10kb" }));

// Health check endpoint
app.get("/health", (req, res) => {
  res.json({ status: "healthy", timestamp: new Date().toISOString() });
});

// Translation endpoint
app.post(
  "/translate",
  //validateApiKey,
  validateTranslateRequest,
  //checkUserLimits("translation"),
  async (req, res) => {
    try {
      console.log("Received translation request:", req.body);

      const { text, sourceLang, targetLang }: TranslateRequest = req.body;
      //const userId = (req as any).userId;
      const userId = req.headers["userid"] as string;

      console.log(
        `Translating text for user ${userId} from ${sourceLang} to ${targetLang}`
      );

      //const translatedText = await translateText(text, from, to);
      const translatedText = await freeTranslateText(
        text,
        sourceLang,
        targetLang
      );
      console.log("Translation successful:", translatedText);

      // Update user usage
      //await updateUserUsage(userId, "translation", text.length);

      const response: ApiResponse<{ translatedText: string }> = {
        success: true,
        data: { translatedText },
        usage: {
          charactersUsed: text.length,
          remainingCharacters: (req as any).remainingCredits - text.length,
        },
      };

      res.json(response);
    } catch (error) {
      console.error("Translation error:", error);
      res.status(500).json({
        success: false,
        error: "Translation failed",
        message: error instanceof Error ? error.message : "Unknown error",
      });
    }
  }
);

// Chat with gemini

app.post(
  "/chat",
  //validateApiKey,
  validateChatRequest,
  //checkUserLimits("translation"),
  async (req, res) => {
    try {
      console.log("Received chat request:", req.body);

      const { message, sessionId, resetChat }: GeminiChatRequest = req.body;
      const userId = req.headers["userid"] as string;

      // Generate or use provided session ID
      //const currentSessionId = sessionId || generateSessionId();
      const currentSessionId = userId;
      console.log(
        `Processing chat for user ${userId}, session: ${currentSessionId}`
      );

      // Reset chat session if requested
      if (resetChat) {
        ChatSessionManager.resetSession(currentSessionId);
      }

      // Send message to Gemini and get Tibetan response
      const tibetanResponse = await ChatSessionManager.sendMessage(
        currentSessionId,
        message
      );

      console.log("Chat response generated successfully");

      // Calculate usage
      const charactersUsed = message.length + tibetanResponse.length;
      const remainingCharacters = Math.max(
        0,
        ((req as any).remainingCredits || 2000) - charactersUsed
      );

      const response: GeminiChatResponse = {
        success: true,
        data: {
          response: tibetanResponse,
          sessionId: currentSessionId,
        },
        usage: {
          charactersUsed,
          remainingCharacters,
        },
      };

      res.json(response);
    } catch (error) {
      console.error("Chat error:", error);

      res.status(500).json({
        success: false,
        error: "Chat failed",
        message:
          error instanceof Error ? error.message : "Unknown error occurred",
      });
    }
  }
);

// Additional endpoint to reset specific chat session
app.post("/chat/reset", async (req, res) => {
  try {
    const { sessionId } = req.body;

    if (!sessionId) {
      return res.status(400).json({
        success: false,
        error: "Session ID required",
      });
    }

    ChatSessionManager.resetSession(sessionId);

    return res.json({
      success: true,
      message: "Chat session reset successfully",
    });
  } catch (error) {
    console.error("Reset session error:", error);
    return res.status(500).json({
      success: false,
      error: "Failed to reset session",
    });
  }
});

// Grammar check endpoint
app.post(
  "/grammar",
  //validateApiKey,
  validateGrammarRequest,
  checkUserLimits("grammar"),
  async (req, res) => {
    try {
      const { text }: GrammarRequest = req.body;
      const userId = (req as any).userId;

      const grammarResult = await checkGrammar(text);

      // Update user usage
      //await updateUserUsage(userId, "grammar", text.length);

      const response: ApiResponse<typeof grammarResult> = {
        success: true,
        data: grammarResult,
        usage: {
          charactersUsed: text.length,
          remainingCharacters: (req as any).remainingCredits - text.length,
        },
      };

      res.json(response);
    } catch (error) {
      console.error("Grammar check error:", error);
      res.status(500).json({
        success: false,
        error: "Grammar check failed",
        message: error instanceof Error ? error.message : "Unknown error",
      });
    }
  }
);

// ============================================
// NEW PREMIUM FEATURE ENDPOINTS
// ============================================

// Advanced Tibetan Grammar Analysis Endpoint
app.post("/api/grammar/analyze", async (req, res) => {
  try {
    const { text, mode = "realtime", style = "formal", contextualInfo } = req.body;
    const userId = req.headers["userid"] as string;

    if (!text || text.trim().length === 0) {
      return res.status(400).json({
        success: false,
        error: "Text is required",
      });
    }

    const userLevel = contextualInfo?.userLevel || "intermediate";
    const documentType = contextualInfo?.documentType || "casual";

    const result = await advancedGrammarService.analyzeTibetanGrammar(
      text,
      userLevel,
      documentType
    );

    // Save to Firestore history
    try {
      const db = admin.firestore();
      const userRef = db.collection("users").doc(userId);
      const historyRef = userRef.collection("grammar_history").doc();

      await historyRef.set({
        text,
        corrections: result.corrections,
        timestamp: admin.firestore.FieldValue.serverTimestamp(),
        documentType,
        savedByUser: false,
        mode,
      });
    } catch (dbError) {
      console.error("Error saving to Firestore:", dbError);
      // Don't fail the request if Firestore fails
    }

    return res.json({
      success: true,
      data: result,
      usage: {
        charactersUsed: text.length,
      },
    });
  } catch (error) {
    console.error("Grammar analysis error:", error);
    return res.status(500).json({
      success: false,
      error: "Grammar analysis failed",
      message: error instanceof Error ? error.message : "Unknown error",
    });
  }
});

// Tone Alternatives Endpoint
app.post("/api/grammar/suggestions", async (req, res) => {
  try {
    const { text, correctionId, type } = req.body;

    if (!text) {
      return res.status(400).json({
        success: false,
        error: "Text is required",
      });
    }

    let result: any = {
      alternatives: [],
      examples: [],
      culturalNotes: "",
    };

    if (type === "alternatives") {
      const tones: Array<"formal" | "casual" | "poetic" | "religious" | "modern"> = [
        "formal",
        "casual",
        "poetic",
      ];
      for (const tone of tones) {
        const alternatives = await advancedGrammarService.getToneAlternatives(text, tone);
        result.alternatives.push({
          tone,
          suggestions: alternatives,
        });
      }
    }

    return res.json({
      success: true,
      data: result,
    });
  } catch (error) {
    console.error("Grammar suggestions error:", error);
    return res.status(500).json({
      success: false,
      error: "Failed to get suggestions",
    });
  }
});

// Transliteration Endpoints
app.post("/api/transliterate/convert", async (req, res) => {
  try {
    const { text, sourceSystem = "wylie", targetSystem = "tibetan", context = "common" } =
      req.body;
    const userId = req.headers["userid"] as string;

    if (!text) {
      return res.status(400).json({
        success: false,
        error: "Text is required",
      });
    }

    let result: any;

    // Perform conversion based on source and target systems
    if (sourceSystem === "wylie" && targetSystem === "tibetan") {
      result = transliterationService.convertWylieToTibetan(text);
    } else if (sourceSystem === "tibetan" && targetSystem === "wylie") {
      result = transliterationService.convertTibetanToWylie(text);
    } else if (targetSystem === "phonetic") {
      result = transliterationService.convertToPhonetics(text);
    } else {
      result = {
        result: text,
        alternatives: [],
        confidence: 0,
      };
    }

    // Save to Firestore history
    try {
      const db = admin.firestore();
      const userRef = db.collection("users").doc(userId);
      const historyRef = userRef.collection("transliteration_history").doc();

      await historyRef.set({
        sourceText: text,
        sourceSystem,
        targetSystem,
        result: result.result,
        timestamp: admin.firestore.FieldValue.serverTimestamp(),
        savedByUser: false,
      });
    } catch (dbError) {
      console.error("Error saving transliteration to Firestore:", dbError);
    }

    return res.json({
      success: true,
      data: result,
    });
  } catch (error) {
    console.error("Transliteration error:", error);
    return res.status(500).json({
      success: false,
      error: "Transliteration failed",
      message: error instanceof Error ? error.message : "Unknown error",
    });
  }
});

// Transliteration Database Lookup
app.post("/api/transliterate/database/lookup", async (req, res) => {
  try {
    const { query, type = "common", limit = 10 } = req.body;

    if (!query) {
      return res.status(400).json({
        success: false,
        error: "Query is required",
      });
    }

    const results = transliterationService.searchNameDatabase(query);

    return res.json({
      success: true,
      data: {
        results: results.slice(0, limit),
      },
    });
  } catch (error) {
    console.error("Transliteration lookup error:", error);
    return res.status(500).json({
      success: false,
      error: "Lookup failed",
    });
  }
});

// Enhanced Chat with Tutoring Support
app.post("/api/chat/message", async (req, res) => {
  try {
    const {
      sessionId,
      message,
      conversationMode = "general",
      tutoringLevel = "intermediate",
      documentContext,
      includeExplanation = false,
    } = req.body;
    const userId = req.headers["userid"] as string;

    if (!message) {
      return res.status(400).json({
        success: false,
        error: "Message is required",
      });
    }

    const currentSessionId = sessionId || userId;

    // Create or update session with mode
    const chat = await ChatSessionManager.getOrCreateSession(
      currentSessionId,
      conversationMode as any,
      tutoringLevel as any,
      documentContext
    );

    // Send message to Gemini
    const tibetanResponse = await ChatSessionManager.sendMessage(
      currentSessionId,
      message,
      conversationMode as any
    );

    // Save message to Firestore
    try {
      const db = admin.firestore();
      const conversationRef = db
        .collection("users")
        .doc(userId)
        .collection("conversations")
        .doc(currentSessionId);

      // Create or update conversation document
      await conversationRef.set(
        {
          mode: conversationMode,
          tutoringLevel: conversationMode === "tutoring" ? tutoringLevel : null,
          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
          messageCount: admin.firestore.FieldValue.increment(1),
          preview: message.substring(0, 100),
          lastMessageTime: admin.firestore.FieldValue.serverTimestamp(),
        },
        { merge: true }
      );

      // Add message to subcollection
      const messagesRef = conversationRef.collection("messages").doc();
      await messagesRef.set({
        sender: "user",
        content: message,
        timestamp: admin.firestore.FieldValue.serverTimestamp(),
        mode: conversationMode,
      });

      // Add response
      const responseRef = conversationRef.collection("messages").doc();
      await responseRef.set({
        sender: "assistant",
        content: tibetanResponse,
        timestamp: admin.firestore.FieldValue.serverTimestamp(),
        mode: conversationMode,
        confidence: 0.92,
      });
    } catch (dbError) {
      console.error("Error saving chat to Firestore:", dbError);
    }

    const response: GeminiChatResponse = {
      success: true,
      data: {
        response: tibetanResponse,
        sessionId: currentSessionId,
        messageId: `msg_${Date.now()}`,
      },
      usage: {
        charactersUsed: message.length + tibetanResponse.length,
      },
    };

    return res.json(response);
  } catch (error) {
    console.error("Enhanced chat error:", error);
    return res.status(500).json({
      success: false,
      error: "Chat failed",
      message: error instanceof Error ? error.message : "Unknown error",
    });
  }
});

// Chat History Endpoint
app.get("/api/chat/history", async (req, res) => {
  try {
    const userId = req.headers["userid"] as string;
    const limit = parseInt(req.query.limit as string) || 20;
    const offset = parseInt(req.query.offset as string) || 0;

    const db = admin.firestore();
    const conversationsRef = db.collection("users").doc(userId).collection("conversations");

    let query: any = conversationsRef.orderBy("updatedAt", "desc").limit(limit);

    if (offset > 0) {
      query = query.offset(offset);
    }

    const snapshot = await query.get();
    const conversations = snapshot.docs.map((doc) => ({
      conversationId: doc.id,
      ...doc.data(),
    }));

    return res.json({
      success: true,
      data: {
        conversations,
        totalCount: snapshot.size,
      },
    });
  } catch (error) {
    console.error("Chat history error:", error);
    return res.status(500).json({
      success: false,
      error: "Failed to fetch history",
    });
  }
});

// Tutoring Mode Configuration
app.post("/api/chat/tutoring/mode", async (req, res) => {
  try {
    const { sessionId, enabled, level = "beginner", topic = "grammar" } = req.body;
    const userId = req.headers["userid"] as string;

    if (enabled) {
      ChatSessionManager.updateSessionMode(sessionId || userId, "tutoring", level as any);

      const curriculum = ChatSessionManager.getTutoringCurriculum(level as any);

      return res.json({
        success: true,
        data: {
          curriculum,
          systemPrompt: `Tutoring mode activated for ${level} level`,
        },
      });
    } else {
      ChatSessionManager.updateSessionMode(sessionId || userId, "general");
      return res.json({
        success: true,
        message: "Tutoring mode disabled",
      });
    }
  } catch (error) {
    console.error("Tutoring mode error:", error);
    return res.status(500).json({
      success: false,
      error: "Failed to configure tutoring mode",
    });
  }
});

// Error handling middleware
app.use(errorHandler);

// Export the v2 function with specific configuration
export const api = onRequest(
  {
    cors: true,
    region: "asia-south1", // Mumbai region
    maxInstances: 10,
    timeoutSeconds: 60,
    memory: "256MiB",
    // Add additional options if needed
    // invoker: 'public', // Makes function publicly accessible
    // secrets: [], // Add secrets if needed
    // serviceAccount: '', // Custom service account if needed
  },
  app
);