server.ts

import express from 'express';
import path from 'path';
import fs from 'fs';
import { fileURLToPath } from 'url';
import helmet from 'helmet';
import compression from 'compression';
import cors from 'cors';
import rateLimit from 'express-rate-limit';
import { body, validationResult } from 'express-validator';
import { initializeApp } from 'firebase/app';
import {
  getFirestore,
  collection,
  doc,
  getDoc,
  getDocs,
  setDoc,
  updateDoc,
  addDoc,
  deleteDoc,
  query,
  where,
  orderBy,
  limit,
  DocumentReference,
  Query,
  DocumentData,
} from 'firebase/firestore';
import { GoogleGenAI } from '@google/genai';
import AdmZip from 'adm-zip';
import dotenv from 'dotenv';

dotenv.config();

// Load Firebase config: env vars take priority (Cloud Run / production).
// Falls back to local firebase-applet-config.json for development.
function loadFirebaseConfig(): Record<string, string> {
  // If the primary env var is set, build config entirely from env
  if (process.env.FIREBASE_API_KEY) {
    console.log('Loading Firebase config from environment variables.');
    return {
      apiKey: process.env.FIREBASE_API_KEY!,
      authDomain: process.env.FIREBASE_AUTH_DOMAIN || '',
      projectId: process.env.FIREBASE_PROJECT_ID || '',
      storageBucket: process.env.FIREBASE_STORAGE_BUCKET || '',
      messagingSenderId: process.env.FIREBASE_MESSAGING_SENDER_ID || '',
      appId: process.env.FIREBASE_APP_ID || '',
      measurementId: process.env.FIREBASE_MEASUREMENT_ID || '',
      firestoreDatabaseId: process.env.FIRESTORE_DATABASE_ID || '(default)',
    };
  }
  // Local development fallback — read firebase-applet-config.json
  const configPath = path.join(process.cwd(), 'firebase-applet-config.json');
  if (fs.existsSync(configPath)) {
    console.log('Loading Firebase config from firebase-applet-config.json.');
    return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
  }
  console.warn(
    'No Firebase config found (no env vars, no config file). Firestore will use local fallback.'
  );
  return {};
}

const firebaseConfig = loadFirebaseConfig();

// Initialize Firebase SDK on server
const firebaseApp = initializeApp(firebaseConfig);
const db =
  firebaseConfig.firestoreDatabaseId && firebaseConfig.firestoreDatabaseId !== '(default)'
    ? getFirestore(firebaseApp, firebaseConfig.firestoreDatabaseId)
    : getFirestore(firebaseApp);

let useLocalFallback = false;
const LOCAL_DB_PATH = path.join(process.cwd(), 'local_database.json');

interface LocalDatabase {
  users: Record<string, any>;
  carbon_logs: Record<string, any>;
  eco_actions: Record<string, any>;
  offsets: Record<string, any>;
  [collectionName: string]: Record<string, any>;
}

function loadLocalDB(): LocalDatabase {
  if (fs.existsSync(LOCAL_DB_PATH)) {
    try {
      return JSON.parse(fs.readFileSync(LOCAL_DB_PATH, 'utf-8')) as LocalDatabase;
    } catch (e) {
      console.error('Error reading local DB:', e);
    }
  }
  const initial: LocalDatabase = {
    users: {
      'eco-warrior-kishan': {
        id: 'eco-warrior-kishan',
        email: 'cshreyash219@gmail.com',
        displayName: 'Alex Eco-Warrior',
        level: 3,
        totalXp: 1450,
        currentStreak: 6,
        totalCo2Saved: 84.5,
        createdAt: '2026-06-17T06:05:58-07:00',
        updatedAt: '2026-06-17T06:05:58-07:00',
      },
    },
    carbon_logs: {},
    eco_actions: {},
    offsets: {},
  };
  saveLocalDB(initial);
  return initial;
}

function saveLocalDB(data: LocalDatabase) {
  try {
    fs.writeFileSync(LOCAL_DB_PATH, JSON.stringify(data, null, 2), 'utf-8');
  } catch (e) {
    console.error('Error writing to local DB:', e);
  }
}

// Custom DB Wrapper APIs
async function getDocWrapper(
  collectionName: string,
  docId: string,
  docRef: DocumentReference<DocumentData>
) {
  if (useLocalFallback) {
    const data = loadLocalDB();
    const collection = data[collectionName] || {};
    const record = collection[docId];
    return {
      exists: () => !!record,
      data: () => record,
    };
  } else {
    try {
      const snap = await getDoc(docRef);
      return snap;
    } catch (err) {
      console.warn(
        'Firestore getDoc failed, falling back to local DB.',
        err instanceof Error ? err.message : String(err)
      );
      // Fallback silently
      const data = loadLocalDB();
      const collection = data[collectionName] || {};
      const record = collection[docId];
      return {
        exists: () => !!record,
        data: () => record,
      };
    }
  }
}

async function setDocWrapper(
  collectionName: string,
  docId: string,
  docRef: DocumentReference<DocumentData>,
  payload: DocumentData
) {
  if (useLocalFallback) {
    const data = loadLocalDB();
    if (!data[collectionName]) {
      data[collectionName] = {};
    }
    data[collectionName][docId] = payload;
    saveLocalDB(data);
  } else {
    try {
      await setDoc(docRef, payload);
    } catch (err) {
      console.warn(
        'Firestore setDoc failed, falling back to local DB.',
        err instanceof Error ? err.message : String(err)
      );
      const data = loadLocalDB();
      if (!data[collectionName]) {
        data[collectionName] = {};
      }
      data[collectionName][docId] = payload;
      saveLocalDB(data);
    }
  }
}

async function updateDocWrapper(
  collectionName: string,
  docId: string,
  docRef: DocumentReference<DocumentData>,
  payload: DocumentData
) {
  if (useLocalFallback) {
    const data = loadLocalDB();
    if (data[collectionName] && data[collectionName][docId]) {
      data[collectionName][docId] = {
        ...data[collectionName][docId],
        ...payload,
      };
      saveLocalDB(data);
    }
  } else {
    try {
      await updateDoc(docRef, payload);
    } catch (err) {
      console.warn(
        'Firestore updateDoc failed, falling back to local DB.',
        err instanceof Error ? err.message : String(err)
      );
      const data = loadLocalDB();
      if (data[collectionName] && data[collectionName][docId]) {
        data[collectionName][docId] = {
          ...data[collectionName][docId],
          ...payload,
        };
        saveLocalDB(data);
      }
    }
  }
}

async function deleteDocWrapper(
  collectionName: string,
  docId: string,
  docRef: DocumentReference<DocumentData>
) {
  if (useLocalFallback) {
    const data = loadLocalDB();
    if (data[collectionName] && data[collectionName][docId]) {
      delete data[collectionName][docId];
      saveLocalDB(data);
    }
  } else {
    try {
      await deleteDoc(docRef);
    } catch (err) {
      console.warn(
        'Firestore deleteDoc failed, falling back to local DB.',
        err instanceof Error ? err.message : String(err)
      );
      const data = loadLocalDB();
      if (data[collectionName] && data[collectionName][docId]) {
        delete data[collectionName][docId];
        saveLocalDB(data);
      }
    }
  }
}

async function getDocsWrapper(
  collectionName: string,
  firestoreQuery: Query<DocumentData>,
  localFilter: (items: any[]) => any[]
) {
  if (useLocalFallback) {
    const data = loadLocalDB();
    const collection = data[collectionName] || {};
    const list = Object.entries(collection).map(([id, val]) => ({ id, ...val }));
    const filtered = localFilter(list);
    return {
      docs: filtered.map((item) => ({
        id: item.id,
        data: () => {
          const { id, ...rest } = item;
          return rest;
        },
      })),
    };
  } else {
    try {
      const snap = await getDocs(firestoreQuery);
      return snap;
    } catch (err) {
      console.warn(
        'Firestore getDocs failed, listing from local DB.',
        err instanceof Error ? err.message : String(err)
      );
      const data = loadLocalDB();
      const collection = data[collectionName] || {};
      const list = Object.entries(collection).map(([id, val]) => ({ id, ...val }));
      const filtered = localFilter(list);
      return {
        docs: filtered.map((item) => ({
          id: item.id,
          data: () => {
            const { id, ...rest } = item;
            return rest;
          },
        })),
      };
    }
  }
}

// Function to safely check link to Firestore
import { getDocFromServer } from 'firebase/firestore';
async function checkFirestoreConnection() {
  try {
    console.log('Locating Cloud Firestore server on project:', firebaseConfig.projectId);
    const testDoc = doc(db, 'users', 'ping');
    await Promise.race([
      getDocFromServer(testDoc),
      new Promise((_, reject) =>
        setTimeout(() => reject(new Error('Timeout connecting to Firestore')), 1500)
      ),
    ]);
    console.log('Connected to Google Cloud Firestore successfully.');
  } catch (error) {
    console.warn(
      "Unable to connect to Google Cloud Firestore (Client is offline or project isn't provisioned yet). Switching seamlessly to locally persisted JSON database."
    );
    useLocalFallback = true;
  }
}
// Run connection check immediately
checkFirestoreConnection();

// Initialize Gemini SDK securely on the server
// Initialize Gemini via Vertex AI.
// Uses Application Default Credentials (ADC) — no API key needed.
// On Cloud Run, ADC automatically uses the attached service account.
// Locally, run: gcloud auth application-default login
const VERTEX_PROJECT =
  process.env.VERTEX_PROJECT || firebaseConfig.projectId || 'ecotracker-499709';
const VERTEX_LOCATION = process.env.VERTEX_LOCATION || 'us-central1';
console.log(`Gemini via Vertex AI — project: ${VERTEX_PROJECT}, location: ${VERTEX_LOCATION}`);

const ai = new GoogleGenAI({
  vertexai: true,
  project: VERTEX_PROJECT,
  location: VERTEX_LOCATION,
  httpOptions: {
    headers: {
      'User-Agent': 'ecotracker-server',
    },
  },
});

const app = express();
const PORT = parseInt(process.env.PORT || '8080', 10);

// Security: hide implementation details
app.disable('x-powered-by');

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

// Apply Security Middlewares
if (process.env.NODE_ENV === 'production') {
  app.use(
    helmet({
      contentSecurityPolicy: {
        directives: {
          defaultSrc: ["'self'"],
          scriptSrc: ["'self'", 'https:'],
          styleSrc: ["'self'", "'unsafe-inline'", 'https:'],
          imgSrc: ["'self'", 'data:', 'https:'],
          connectSrc: ["'self'", 'https:'],
        },
      },
    })
  );
} else {
  // relaxed for local dev & AI studio preview
  app.use(
    helmet({
      frameguard: false,
      crossOriginEmbedderPolicy: false,
      crossOriginOpenerPolicy: false,
      crossOriginResourcePolicy: false,
      contentSecurityPolicy: false,
    })
  );
}

app.use(cors());
app.use(limiter);
app.use(express.json());

// Performance: compress responses and add caching for static assets in production
app.use(compression());

// Operation type descriptor for error management
enum OperationType {
  CREATE = 'create',
  UPDATE = 'update',
  DELETE = 'delete',
  LIST = 'list',
  GET = 'get',
  WRITE = 'write',
}

function handleBackendFirestoreError(error: unknown, op: OperationType, collPath: string) {
  const errPayload = {
    error: error instanceof Error ? error.message : String(error),
    operationType: op,
    path: collPath,
    serverTimestamp: new Date().toISOString(),
  };
  console.error('Firestore Backend Error details:', JSON.stringify(errPayload));
  return errPayload;
}

// --- REST API ENDPOINTS ---

// Check server status
app.get('/api/health', (req, res) => {
  res.json({ status: 'ok', firebaseDb: firebaseConfig.firestoreDatabaseId || 'no-db' });
});

// 1. User Profile Sync
app.get('/api/profile/:userId', async (req, res) => {
  const { userId } = req.params;
  try {
    const userDocRef = doc(db, 'users', userId);
    const userSnap = await getDocWrapper('users', userId, userDocRef);

    if (userSnap.exists()) {
      return res.json(userSnap.data());
    } else {
      // First-time user creation logic
      const newUser = {
        id: userId,
        email: req.query.email || 'eco_warrior@example.com',
        displayName: req.query.displayName || 'Alex Eco-Warrior',
        level: 1,
        totalXp: 100,
        currentStreak: 1,
        totalCo2Saved: 0.0,
        createdAt: new Date().toISOString(),
        updatedAt: new Date().toISOString(),
      };
      await setDocWrapper('users', userId, userDocRef, newUser);
      return res.json(newUser);
    }
  } catch (err) {
    const info = handleBackendFirestoreError(err, OperationType.GET, `users/${userId}`);
    res.status(500).json({ error: 'Failed to load/provision profile', details: info });
  }
});

// Update Profile
app.put(
  '/api/profile/:userId',
  [
    body('displayName').isString().isLength({ min: 1, max: 100 }),
    body('level').isInt({ min: 0 }),
    body('totalXp').isInt({ min: 0 }),
    body('currentStreak').isInt({ min: 0 }),
    body('totalCo2Saved').isFloat({ min: 0 }),
  ],
  async (req, res) => {
    const { userId } = req.params;
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({ errors: errors.array() });
    }

    try {
      const userDocRef = doc(db, 'users', userId);
      const userSnap = await getDocWrapper('users', userId, userDocRef);
      if (!userSnap.exists()) {
        return res.status(404).json({ error: 'User not found' });
      }

      const existingData = userSnap.data();
      const payload = {
        ...existingData,
        displayName: req.body.displayName,
        level: req.body.level,
        totalXp: req.body.totalXp,
        currentStreak: req.body.currentStreak,
        totalCo2Saved: req.body.totalCo2Saved,
        updatedAt: new Date().toISOString(),
      };

      await setDocWrapper('users', userId, userDocRef, payload);
      res.json(payload);
    } catch (err) {
      const info = handleBackendFirestoreError(err, OperationType.UPDATE, `users/${userId}`);
      res.status(500).json({ error: 'Failed to update profile', details: info });
    }
  }
);

// 2. Carbon Footprint Logs - Fetch Logs
app.get('/api/carbon/logs/:userId', async (req, res) => {
  const { userId } = req.params;
  try {
    const q = query(
      collection(db, 'carbon_logs'),
      where('userId', '==', userId),
      orderBy('date', 'desc'),
      limit(50)
    );
    const snap = await getDocsWrapper('carbon_logs', q, (items) =>
      items
        .filter((item) => item.userId === userId)
        .sort((a, b) => b.date.localeCompare(a.date))
        .slice(0, 50)
    );
    const logs = snap.docs.map((doc) => ({ id: doc.id, ...doc.data() }));
    res.json(logs);
  } catch (err) {
    const info = handleBackendFirestoreError(err, OperationType.LIST, 'carbon_logs');
    res.status(500).json({ error: 'Failed to retrieve carbon logs', details: info });
  }
});

// Carbon Footprint Logs - Add Log
app.post(
  '/api/carbon/logs',
  [
    body('userId').isString().notEmpty(),
    body('date').isISO8601(),
    body('category').isIn(['transportation', 'food', 'electricity', 'waste', 'shopping', 'water']),
    body('amount').isFloat({ min: 0 }),
    body('details').optional().isString(),
  ],
  async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({ errors: errors.array() });
    }

    const { userId, date, category, amount, details } = req.body;

    // Standard high-accuracy conversion algorithms (kg CO2 equivalent)
    let calculatedCo2 = 0;
    if (category === 'transportation') {
      // Amount in kilometers driven. Baseline: 0.18 kg CO2 per km (gas vehicle)
      calculatedCo2 = amount * 0.18;
    } else if (category === 'food') {
      // Amount in meals. Baseline: 1.5 kg CO2 per meal average
      calculatedCo2 = amount * 1.5;
    } else if (category === 'electricity') {
      // Amount in kWh used. Baseline: 0.45 kg CO2 per kWh
      calculatedCo2 = amount * 0.45;
    } else if (category === 'waste') {
      // Amount in kg of waste thrown away. Baseline: 0.5 kg CO2 per kg
      calculatedCo2 = amount * 0.5;
    } else if (category === 'shopping') {
      // Amount in purchases. Baseline: 15 kg CO2 average per manufacturing item
      calculatedCo2 = amount * 15;
    } else if (category === 'water') {
      // Amount in liters of water used. Baseline: 0.001 kg CO2 per liter (pumping & treatment)
      calculatedCo2 = amount * 0.001;
    }

    try {
      const logId = `log-${Date.now()}-${Math.random().toString(36).substring(2, 7)}`;
      const logRecord = {
        id: logId,
        userId,
        date,
        category,
        amount,
        calculatedCo2: parseFloat(calculatedCo2.toFixed(2)),
        createdAt: new Date().toISOString(),
      };

      await setDocWrapper('carbon_logs', logId, doc(db, 'carbon_logs', logId), logRecord);

      // Add experience points for inputting tracking (20 XP)
      const userDocRef = doc(db, 'users', userId);
      const userSnap = await getDocWrapper('users', userId, userDocRef);
      if (userSnap.exists()) {
        const u = userSnap.data();
        const baseXP = u.totalXp || 0;
        const newXP = baseXP + 20;
        // Level threshold is Level * 1000 XP
        const newLevel = Math.floor(newXP / 1000) + 1;
        await updateDocWrapper('users', userId, userDocRef, {
          totalXp: newXP,
          level: newLevel,
          updatedAt: new Date().toISOString(),
        });
      }

      res.status(201).json(logRecord);
    } catch (err) {
      const info = handleBackendFirestoreError(err, OperationType.CREATE, 'carbon_logs');
      res.status(500).json({ error: 'Failed to save carbon log', details: info });
    }
  }
);

// Delete Carbon Log
app.delete('/api/carbon/logs/:logId', async (req, res) => {
  const { logId } = req.params;
  try {
    const docRef = doc(db, 'carbon_logs', logId);
    await deleteDocWrapper('carbon_logs', logId, docRef);
    res.json({ success: true, message: 'Log success deleted' });
  } catch (err) {
    const info = handleBackendFirestoreError(err, OperationType.DELETE, `carbon_logs/${logId}`);
    res.status(500).json({ error: 'Failed to delete carbon log', details: info });
  }
});

// 3. User Aggregates & Dashboard Stats
app.get('/api/carbon/stats/:userId', async (req, res) => {
  const { userId } = req.params;
  try {
    const q = query(collection(db, 'carbon_logs'), where('userId', '==', userId));
    const snap = await getDocsWrapper('carbon_logs', q, (items) =>
      items.filter((item) => item.userId === userId)
    );
    const logs = snap.docs.map((doc) => doc.data() as any);

    // Calculate distributions & summaries
    const distribution = {
      transportation: 0,
      food: 0,
      electricity: 0,
      waste: 0,
      shopping: 0,
      water: 0,
    };

    let totalThisMonth = 0;
    const now = new Date();
    const currentMonthStr = now.toISOString().substring(0, 7); // "YYYY-MM"

    logs.forEach((log) => {
      if (log.category && distribution.hasOwnProperty(log.category)) {
        distribution[log.category as keyof typeof distribution] += log.calculatedCo2 || 0;
      }
      if (log.date && log.date.substring(0, 7) === currentMonthStr) {
        totalThisMonth += log.calculatedCo2 || 0;
      }
    });

    // Make clean numbers
    const finalDistribution = Object.fromEntries(
      Object.entries(distribution).map(([k, v]) => [k, parseFloat(v.toFixed(1))])
    );

    // Fetch Eco Action tasks
    const actionQ = query(collection(db, 'eco_actions'), where('userId', '==', userId));
    const actionSnap = await getDocsWrapper('eco_actions', actionQ, (items) =>
      items.filter((item) => item.userId === userId)
    );
    const actions = actionSnap.docs.map((doc) => doc.data() as any);
    const totalCo2Prevented = actions
      .filter(
        (a: any) => a.status === 'completed' || (a.completedDates && a.completedDates.length > 0)
      )
      .reduce(
        (sum: number, a: any) =>
          sum + a.co2Reduction * (a.completedDates ? a.completedDates.length : 1),
        0
      );

    // Fetch offsets funded
    const offsetQ = query(collection(db, 'offsets'), where('userId', '==', userId));
    const offsetSnap = await getDocsWrapper('offsets', offsetQ, (items) =>
      items.filter((item) => item.userId === userId)
    );
    const offsets = offsetSnap.docs.map((doc) => doc.data() as any);
    const totalOffsetCo2 = offsets.reduce((sum: number, o: any) => sum + (o.co2Offset || 0), 0);

    // Generate month-on-month trend data for Recharts (past 6 months)
    const monthNames = [
      'Jan',
      'Feb',
      'Mar',
      'Apr',
      'May',
      'Jun',
      'Jul',
      'Aug',
      'Sep',
      'Oct',
      'Nov',
      'Dec',
    ];
    const trendMap = new Map<string, number>();

    // Seed past 6 months to guarantee values
    for (let i = 5; i >= 0; i--) {
      const d = new Date();
      d.setMonth(d.getMonth() - i);
      const key = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}`;
      trendMap.set(key, 0);
    }

    logs.forEach((log) => {
      if (log.date) {
        const key = log.date.substring(0, 7);
        if (trendMap.has(key)) {
          trendMap.set(key, trendMap.get(key)! + (log.calculatedCo2 || 0));
        }
      }
    });

    const trendData = Array.from(trendMap.entries()).map(([key, val]) => {
      const parts = key.split('-');
      const monthIdx = parseInt(parts[1]) - 1;
      return {
        month: monthNames[monthIdx],
        emissions: parseFloat(val.toFixed(1)),
      };
    });

    // Sustainability score algorithm (out of 100). Baseline household: ~1200 kg CO2 per month
    // Low emissions is a green high sustainability score!
    let sustainabilityScore = 100;
    if (totalThisMonth > 0) {
      // Logarithmic drop from 1200 kg baseline
      const fraction = totalThisMonth / 1500;
      sustainabilityScore = Math.max(10, Math.floor(100 - fraction * 90));
    } else {
      sustainabilityScore = 75; // Neutral starting score
    }

    // Add extra credit points for Co2 savings
    if (totalCo2Prevented > 0) {
      sustainabilityScore = Math.min(100, sustainabilityScore + Math.floor(totalCo2Prevented / 5));
    }

    let rankingRating = 'F';
    if (sustainabilityScore >= 90) rankingRating = 'A';
    else if (sustainabilityScore >= 75) rankingRating = 'B';
    else if (sustainabilityScore >= 55) rankingRating = 'C';
    else if (sustainabilityScore >= 35) rankingRating = 'D';
    else if (sustainabilityScore >= 20) rankingRating = 'E';

    res.json({
      sustainabilityScore,
      rating: rankingRating,
      monthlyEmissions: parseFloat(totalThisMonth.toFixed(1)),
      co2Prevented: parseFloat(totalCo2Prevented.toFixed(1)),
      co2Offset: parseFloat(totalOffsetCo2.toFixed(1)),
      distribution: finalDistribution,
      trend: trendData,
    });
  } catch (err) {
    const info = handleBackendFirestoreError(err, OperationType.LIST, 'carbon_logs');
    res.status(500).json({ error: 'Failed to calculate sustainability stats', details: info });
  }
});

// 4. AI Carbon Coach (Gemini interaction endpoint)
app.post(
  '/api/carbon/coach',
  [
    body('userId').isString().notEmpty(),
    body('message').isString().isLength({ min: 1, max: 2000 }),
    body('chatHistory').optional().isArray(),
  ],
  async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({ errors: errors.array() });
    }

    const { userId, message, chatHistory } = req.body;

    try {
      // 1. Gather latest carbon history logs to inject context
      const logQ = query(
        collection(db, 'carbon_logs'),
        where('userId', '==', userId),
        orderBy('date', 'desc'),
        limit(15)
      );
      const snap = await getDocsWrapper('carbon_logs', logQ, (items) =>
        items
          .filter((item) => item.userId === userId)
          .sort((a, b) => b.date.localeCompare(a.date))
          .slice(0, 15)
      );
      const logs = snap.docs.map((doc) => doc.data());

      let contextStr = 'User is tracking their daily carbon logs. Recent logs:\n';
      logs.forEach((l: any) => {
        contextStr += `- Date: ${l.date}, Category: ${l.category}, CO2 emitted: ${l.calculatedCo2}kg\n`;
      });

      // Construct history array correctly formatted for Gemini chats
      const formattedHistory: any[] = [];
      if (chatHistory && chatHistory.length > 0) {
        chatHistory.slice(-10).forEach((entry: any) => {
          formattedHistory.push({
            role: entry.role === 'user' ? 'user' : 'model',
            parts: [{ text: entry.text || entry.message || '' }],
          });
        });
      }

      // Add system prompt instruction to keep Coach friendly, knowledgeable, and green
      const systemInstruction =
        'You are the EcoTracker AI Carbon Coach, powered by Google Gemini. ' +
        'Your mission is to help individuals analyze, track, and systematically reduce their carbon footprint. ' +
        'Provide scientific yet supportive, actionable advice. Highlight little green choices ' +
        'applicable to their profile. Use clean formatting, bold key advice, and bullet points. ' +
        'Greet them enthusiastically and keep motivation high!';

      // Invoke Gemini via Vertex AI
      const response = await ai.models.generateContent({
        model: 'gemini-2.0-flash-001',
        contents: [
          {
            role: 'user',
            parts: [
              {
                text: `SYSTEM_CONTEXT: ${systemInstruction}\nUSER_CARBON_DATA:\n${contextStr}\n\nUser Question: ${message}`,
              },
            ],
          },
        ],
      });

      res.json({ reply: response.text });
    } catch (err) {
      console.error('Gemini Coach model error:', err);
      res.status(500).json({ error: 'Carbon Coach took a walk in the woods. Please try again.' });
    }
  }
);

// 5. Intelligent AI Assessment (Report Endpoint)
app.post('/api/carbon/assessment', [body('userId').isString().notEmpty()], async (req, res) => {
  const { userId } = req.body;
  try {
    const q = query(collection(db, 'carbon_logs'), where('userId', '==', userId));
    const snap = await getDocs(q);
    const logs = snap.docs.map((doc) => doc.data());

    if (logs.length === 0) {
      return res.json({
        report:
          '### 🌱 Start Tracking!\n\nNo carbon log entries detected yet. Submit your first travel or utility log in the dashboard to kickstart your personalized AI carbon assessment!',
        ranking: 'N/A',
      });
    }

    let summaryStr = `User has ${logs.length} footprint entries. Logs breakdown:\n`;
    logs.forEach((l: any) => {
      summaryStr += `- Category: ${l.category}, Amount: ${l.amount}, CO2: ${l.calculatedCo2} kg on Date: ${l.date}\n`;
    });

    const aiPrompt =
      'Provide a rigorous, actionable personal carbon assessment. Include: ' +
      "1. An executive summary rating the user as 'Eco-Apprentice', 'Carbon Stabilizer', or 'Active Eco-Warrior'. " +
      '2. Identification of their single highest carbon consumer category. ' +
      '3. Exactly 3 strategic micro-actions they can implement this week to save at least 20kg of CO2. ' +
      '4. Sound optimistic and scientific. ' +
      'Write in clear, beautiful Markdown with elegant spacers.';

    const response = await ai.models.generateContent({
      model: 'gemini-2.0-flash-001',
      contents: [
        { role: 'user', parts: [{ text: `${aiPrompt}\n\nUser Carbon Data:\n${summaryStr}` }] },
      ],
    });

    res.json({ report: response.text });
  } catch (err) {
    console.error('Gemini Assessment error:', err);
    res.status(500).json({ error: 'Failed to generate AI Carbon Profile Assessment.' });
  }
});

// 6. Eco Actions (Task & Habit tracker)
app.get('/api/eco-actions/:userId', async (req, res) => {
  const { userId } = req.params;
  try {
    const q = query(collection(db, 'eco_actions'), where('userId', '==', userId));
    const snap = await getDocsWrapper('eco_actions', q, (items) =>
      items.filter((item) => item.userId === userId)
    );

    const actions = snap.docs.map((doc) => ({ id: doc.id, ...doc.data() }));

    // Seed default actions if user doesn't have any yet
    if (actions.length === 0) {
      const defaults = [
        {
          title: 'Switch to LED lightbulbs',
          category: 'energy',
          co2Reduction: 8.5,
          status: 'active',
        },
        {
          title: 'Carpool or ride public transit',
          category: 'transport',
          co2Reduction: 12.0,
          status: 'active',
        },
        {
          title: 'Unplug standby vampire electronics',
          category: 'energy',
          co2Reduction: 3.2,
          status: 'active',
        },
        {
          title: 'Switch to a vegan or vegetarian diet',
          category: 'food',
          co2Reduction: 15.6,
          status: 'active',
        },
        {
          title: 'Compost food waste & paper leftovers',
          category: 'waste',
          co2Reduction: 4.8,
          status: 'active',
        },
        {
          title: 'Limit shower times to 5 minutes',
          category: 'water',
          co2Reduction: 2.1,
          status: 'active',
        },
      ];

      for (const item of defaults) {
        const aid = `act-${Date.now()}-${Math.random().toString(36).substring(2, 7)}`;
        const record = {
          id: aid,
          userId,
          title: item.title,
          category: item.category,
          co2Reduction: item.co2Reduction,
          status: item.status,
          completedDates: [],
          createdAt: new Date().toISOString(),
        };
        await setDocWrapper('eco_actions', aid, doc(db, 'eco_actions', aid), record);
        actions.push(record);
      }
    }

    res.json(actions);
  } catch (err) {
    const info = handleBackendFirestoreError(err, OperationType.LIST, 'eco_actions');
    res.status(500).json({ error: 'Failed to load/provision Eco Actions', details: info });
  }
});

app.post(
  '/api/eco-actions/complete',
  [
    body('actionId').isString().notEmpty(),
    body('userId').isString().notEmpty(),
    body('date').isISO8601(),
  ],
  async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({ errors: errors.array() });
    }

    const { actionId, userId, date } = req.body;
    try {
      const actionDocRef = doc(db, 'eco_actions', actionId);
      const snap = await getDocWrapper('eco_actions', actionId, actionDocRef);
      if (!snap.exists()) {
        return res.status(404).json({ error: 'Action item not found' });
      }

      const data = snap.data();
      const completedDates = data.completedDates || [];

      if (completedDates.includes(date)) {
        return res.status(400).json({ error: 'Action already completed for this date' });
      }

      const updatedDates = [...completedDates, date];
      await updateDocWrapper('eco_actions', actionId, actionDocRef, {
        completedDates: updatedDates,
        status: updatedDates.length >= 7 ? 'completed' : 'active',
      });

      // Reward user with experience points (e.g., 50 XP per green action completed)
      const userDocRef = doc(db, 'users', userId);
      const userSnap = await getDocWrapper('users', userId, userDocRef);
      if (userSnap.exists()) {
        const u = userSnap.data();
        const currentStreak = u.currentStreak || 1;
        const baseXP = u.totalXp || 0;
        const additionalXP = 50 + currentStreak * 5; // streak multiplier bonus

        const newXP = baseXP + additionalXP;
        const newLevel = Math.floor(newXP / 1000) + 1;
        const newTotalCo2Saved = (u.totalCo2Saved || 0) + data.co2Reduction;

        await updateDocWrapper('users', userId, userDocRef, {
          totalXp: newXP,
          level: newLevel,
          totalCo2Saved: parseFloat(newTotalCo2Saved.toFixed(1)),
          updatedAt: new Date().toISOString(),
        });
      }

      res.json({ success: true, completedDates: updatedDates });
    } catch (err) {
      const info = handleBackendFirestoreError(
        err,
        OperationType.UPDATE,
        `eco_actions/${actionId}`
      );
      res.status(500).json({ error: 'Failed to complete action', details: info });
    }
  }
);

// 7. Offsets Purchased
app.get('/api/offsets/:userId', async (req, res) => {
  const { userId } = req.params;
  try {
    const q = query(
      collection(db, 'offsets'),
      where('userId', '==', userId),
      orderBy('date', 'desc')
    );
    const snap = await getDocsWrapper('offsets', q, (items) =>
      items.filter((item) => item.userId === userId).sort((a, b) => b.date.localeCompare(a.date))
    );
    const logs = snap.docs.map((doc) => ({ id: doc.id, ...doc.data() }));
    res.json(logs);
  } catch (err) {
    const info = handleBackendFirestoreError(err, OperationType.LIST, 'offsets');
    res.status(500).json({ error: 'Failed to retrieve offsets', details: info });
  }
});

app.post(
  '/api/offsets',
  [
    body('userId').isString().notEmpty(),
    body('projectName').isString().notEmpty(),
    body('amountPaid').isFloat({ min: 1 }),
    body('co2Offset').isFloat({ min: 1 }),
  ],
  async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({ errors: errors.array() });
    }

    const { userId, projectName, amountPaid, co2Offset } = req.body;
    try {
      const offsetId = `off-${Date.now()}-${Math.random().toString(36).substring(2, 7)}`;
      const offsetRecord = {
        id: offsetId,
        userId,
        projectName,
        amountPaid,
        co2Offset,
        date: new Date().toISOString().substring(0, 10),
      };

      await setDocWrapper('offsets', offsetId, doc(db, 'offsets', offsetId), offsetRecord);

      // Boost XP and stats on user profile
      const userDocRef = doc(db, 'users', userId);
      const userSnap = await getDocWrapper('users', userId, userDocRef);
      if (userSnap.exists()) {
        const u = userSnap.data();
        const currentCo2 = u.totalCo2Saved || 0;
        const currentXP = u.totalXp || 0;

        await updateDocWrapper('users', userId, userDocRef, {
          totalCo2Saved: parseFloat((currentCo2 + co2Offset).toFixed(1)),
          totalXp: currentXP + Math.floor(amountPaid * 10), // 10 XP per dollar offset
          updatedAt: new Date().toISOString(),
        });
      }

      res.status(201).json(offsetRecord);
    } catch (err) {
      const info = handleBackendFirestoreError(err, OperationType.CREATE, 'offsets');
      res.status(500).json({ error: 'Failed to create carbon offset record', details: info });
    }
  }
);

// Community Leaderboard (Aggregates top ranking users)
app.get('/api/leaderboard', async (req, res) => {
  try {
    const usersQ = query(collection(db, 'users'), orderBy('totalCo2Saved', 'desc'), limit(10));
    const snap = await getDocsWrapper('users', usersQ, (items) => {
      // Merge with default mock users so the leaderboard is populated and never empty!
      const defaults = [
        { displayName: 'Alex Eco-Warrior (You)', level: 3, totalCo2Saved: 334.5, totalXp: 5450 },
        { displayName: 'Sophia Green', level: 5, totalCo2Saved: 210.5, totalXp: 3950 },
        { displayName: 'Ethan Solars', level: 4, totalCo2Saved: 145.0, totalXp: 2850 },
        { displayName: 'Liam Wind-Power', level: 2, totalCo2Saved: 72.0, totalXp: 1200 },
        { displayName: 'Mia Bicycle-Hero', level: 2, totalCo2Saved: 44.5, totalXp: 950 },
      ];

      const matched = items.map((u) => ({
        displayName: u.displayName || 'Anonymous Eco Warrior',
        level: u.level || 1,
        totalCo2Saved: u.totalCo2Saved || 0.0,
        totalXp: u.totalXp || 100,
      }));

      const combined = [...matched];
      defaults.forEach((def) => {
        if (
          !combined.some(
            (c) =>
              c.displayName === def.displayName ||
              (def.displayName.startsWith('Alex') && c.displayName.startsWith('Alex'))
          )
        ) {
          combined.push(def);
        }
      });
      return combined.sort((a, b) => b.totalCo2Saved - a.totalCo2Saved).slice(0, 10);
    });
    const leaderboard = snap.docs.map((doc) => {
      const d = doc.data();
      return {
        displayName: d.displayName || 'Anonymous Eco Warrior',
        level: d.level || 1,
        totalCo2Saved: d.totalCo2Saved || 0.0,
        totalXp: d.totalXp || 100,
      };
    });
    res.json(leaderboard);
  } catch (err) {
    const info = handleBackendFirestoreError(err, OperationType.LIST, 'users');
    res.status(500).json({ error: 'Failed to assemble Eco Leaderboard', details: info });
  }
});

// 8. Dynamic ZIP On-the-fly Generator! (Evaluate with High Impact)
app.get('/api/download-zip', (req, res) => {
  try {
    const zip = new AdmZip();
    const sourceDir = process.cwd();

    // Setup exclusions
    const excludePatterns = [
      'node_modules',
      'dist',
      '.git',
      '.env',
      'package-lock.json',
      'tsconfig.tsbuildinfo',
      '.cache',
      'tmp',
    ];

    const files = fs.readdirSync(sourceDir);

    files.forEach((file) => {
      if (excludePatterns.includes(file)) return;

      const fullPath = path.join(sourceDir, file);
      const stat = fs.statSync(fullPath);

      if (stat.isDirectory()) {
        zip.addLocalFolder(fullPath, file, (filepath) => {
          // Inner folder checks (skip nested nodes)
          return !excludePatterns.some((p) => filepath.includes(p));
        });
      } else {
        zip.addLocalFile(fullPath);
      }
    });

    const buffer = zip.toBuffer();
    res.set({
      'Content-Type': 'application/zip',
      'Content-Disposition': 'attachment; filename=ecotracker-carbonbox-project.zip',
      'Content-Length': buffer.length,
    });
    res.send(buffer);
  } catch (err) {
    console.error('ZIP Generator failed:', err);
    res.status(500).json({ error: 'Critical error assembling downloads package.' });
  }
});

import { createProxyMiddleware } from 'http-proxy-middleware';

// --- VITE MIDDLEWARE CONFIGURATION ---
async function startServer() {
  const isTestEnv = process.env.NODE_ENV === 'test' || process.env.VITEST_WORKER_ID !== undefined;
  // Proxy /__/auth to Firebase to prevent cross-origin iframe issues
  app.use(
    '/__/auth',
    createProxyMiddleware({
      target: `https://${firebaseConfig.projectId}.firebaseapp.com`,
      changeOrigin: true,
    })
  );

  if (process.env.NODE_ENV !== 'production' && !isTestEnv) {
    const { createServer: createViteServer } = await import('vite');
    const vite = await createViteServer({
      server: { middlewareMode: true },
      appType: 'spa',
    });
    app.use(vite.middlewares);
  } else {
    const distPath = path.join(process.cwd(), 'dist');
    app.use(express.static(distPath, { maxAge: '1d', index: false }));
    app.get('*', (req, res) => {
      res.sendFile(path.join(distPath, 'index.html'));
    });
  }
  app.listen(PORT, '0.0.0.0', () => {
    console.log(`EcoTracker Server running on http://0.0.0.0:${PORT}`);
  });
}

// Export app for testing and server start control
export { app, startServer };

// Always expose startServer on globalThis so test harnesses can start it.
(globalThis as any).__startServer = startServer;

// Auto-start the server unless running under test environment.
if (process.env.NODE_ENV !== 'test') {
  startServer();
}