import { NextResponse } from "next/server";
import { getDatabase } from "@/lib/db/mongodb";

export async function GET() {
  try {
    const db = await getDatabase();

    // Récupérer toutes les transactions
    const transactions = await db.collection("transactions").find({}).toArray();
    
    // Récupérer les conversations pour analyser les connexions utilisateurs
    const conversations = await db.collection("conversations").find({}).toArray();
    
    // Récupérer les messages pour une analyse plus précise de l'activité
    const messages = await db.collection("messages").find({}).toArray();
    
    console.log(`Total transactions trouvées: ${transactions.length}`);
    
    // Vérifier les champs de date disponibles dans les transactions
    if (transactions.length > 0) {
      const sampleTransaction = transactions[0];
      console.log("Exemple de transaction:", {
        _id: sampleTransaction._id,
        createdAt: sampleTransaction.createdAt,
        updatedAt: sampleTransaction.updatedAt,
        date: sampleTransaction.date,
        timestamp: sampleTransaction.timestamp,
        rawAmount: sampleTransaction.rawAmount,
        model: sampleTransaction.model
      });
    }

    // Calculer les tokens par jour (7 derniers jours)
    const dailyStats = [];
    const today = new Date();
    const dayNames = ["Dim", "Lun", "Mar", "Mer", "Jeu", "Ven", "Sam"];
    
    for (let i = 6; i >= 0; i--) {
      const date = new Date(today);
      date.setDate(date.getDate() - i);
      date.setHours(0, 0, 0, 0);
      
      const nextDate = new Date(date);
      nextDate.setDate(nextDate.getDate() + 1);
      
      const dayTransactions = transactions.filter(transaction => {
        // Essayer différents champs de date
        let transactionDate = null;
        
        if (transaction.createdAt) {
          transactionDate = new Date(transaction.createdAt);
        } else if (transaction.updatedAt) {
          transactionDate = new Date(transaction.updatedAt);
        } else if (transaction.date) {
          transactionDate = new Date(transaction.date);
        } else if (transaction.timestamp) {
          transactionDate = new Date(transaction.timestamp);
        } else if (transaction._id && transaction._id.getTimestamp) {
          // Utiliser le timestamp de l'ObjectId MongoDB
          transactionDate = transaction._id.getTimestamp();
        }
        
        if (!transactionDate || isNaN(transactionDate.getTime())) {
          return false;
        }
        
        return transactionDate >= date && transactionDate < nextDate;
      });
      
      const totalTokens = dayTransactions.reduce((sum, transaction) => {
        // Essayer différents champs pour les tokens
        let tokens = 0;
        if (transaction.rawAmount) {
          tokens = Math.abs(Number(transaction.rawAmount) || 0);
        } else if (transaction.amount) {
          tokens = Math.abs(Number(transaction.amount) || 0);
        } else if (transaction.tokens) {
          tokens = Math.abs(Number(transaction.tokens) || 0);
        }
        return sum + tokens;
      }, 0);
      
      console.log(`${dayNames[date.getDay()]} (${date.toISOString().split('T')[0]}): ${dayTransactions.length} transactions, ${totalTokens} tokens`);
      
      dailyStats.push({
        name: dayNames[date.getDay()],
        value: totalTokens
      });
    }

    // Calculer la répartition par modèle (vraies données)
    const modelStats = new Map<string, number>();
    
    transactions.forEach(transaction => {
      const model = transaction.model || transaction.modelName || "Inconnu";
      let tokens = 0;
      if (transaction.rawAmount) {
        tokens = Math.abs(Number(transaction.rawAmount) || 0);
      } else if (transaction.amount) {
        tokens = Math.abs(Number(transaction.amount) || 0);
      } else if (transaction.tokens) {
        tokens = Math.abs(Number(transaction.tokens) || 0);
      }
      
      if (tokens > 0) {
        modelStats.set(model, (modelStats.get(model) || 0) + tokens);
      }
    });

    // Convertir en array et trier par usage
    const modelData = Array.from(modelStats.entries())
      .map(([name, value]) => ({ name, value }))
      .sort((a, b) => b.value - a.value);

    // Calculer les connexions utilisateurs par jour (7 derniers jours)
    const dailyConnections = [];
    
    for (let i = 6; i >= 0; i--) {
      const date = new Date(today);
      date.setDate(date.getDate() - i);
      date.setHours(0, 0, 0, 0);
      
      const nextDate = new Date(date);
      nextDate.setDate(nextDate.getDate() + 1);
      
      // Analyser l'activité des utilisateurs via les messages
      const activeUsers = new Set();
      
      messages.forEach(message => {
        let messageDate = null;
        
        if (message.createdAt) {
          messageDate = new Date(message.createdAt);
        } else if (message.updatedAt) {
          messageDate = new Date(message.updatedAt);
        } else if (message._id && message._id.getTimestamp) {
          messageDate = message._id.getTimestamp();
        }
        
        if (messageDate && messageDate >= date && messageDate < nextDate) {
          if (message.user && message.isCreatedByUser) {
            activeUsers.add(message.user);
          }
        }
      });
      
      // Aussi analyser via les conversations créées ce jour-là
      conversations.forEach(conversation => {
        let convDate = null;
        
        if (conversation.createdAt) {
          convDate = new Date(conversation.createdAt);
        } else if (conversation.updatedAt) {
          convDate = new Date(conversation.updatedAt);
        } else if (conversation._id && conversation._id.getTimestamp) {
          convDate = conversation._id.getTimestamp();
        }
        
        if (convDate && convDate >= date && convDate < nextDate) {
          if (conversation.user) {
            activeUsers.add(conversation.user);
          }
        }
      });
      
      console.log(`${dayNames[date.getDay()]} (${date.toISOString().split('T')[0]}): ${activeUsers.size} utilisateurs actifs`);
      
      dailyConnections.push({
        name: dayNames[date.getDay()],
        value: activeUsers.size
      });
    }

    console.log("Statistiques calculées:", {
      dailyStats,
      dailyConnections,
      totalModels: modelData.length,
      topModel: modelData[0]
    });

    return NextResponse.json({
      dailyTokens: dailyStats,
      dailyConnections: dailyConnections,
      modelDistribution: modelData
    });
  } catch (error) {
    console.error("Erreur lors du calcul des statistiques:", error);
    return NextResponse.json({ error: "Erreur serveur" }, { status: 500 });
  }
}