app.js

require("dotenv").config();
const express = require("express");
const bodyParser = require("body-parser");
const ejs = require("ejs");
const mongoose = require("mongoose");
const path = require("path");
const admin = require("firebase-admin");

if (!admin.apps.length && process.env.FIREBASE_SERVICE_ACCOUNT) {
  try {
    const serviceAccount = JSON.parse(process.env.FIREBASE_SERVICE_ACCOUNT);
    admin.initializeApp({
      credential: admin.credential.cert(serviceAccount),
    });
    console.log("Firebase Admin initialized successfully.");
  } catch (error) {
    console.error(
      "Firebase Admin init error. Check your JSON format in Vercel:",
      error,
    );
  }
}
const app = express();
app.use(bodyParser.urlencoded({ extended: true }));
app.set("views", path.join(__dirname, "views"));
app.set("view engine", "ejs");
app.use(express.static(path.join(__dirname, "public")));

// Process error handlers
process.on("unhandledRejection", (reason, promise) => {
  console.log("Unhandled Rejection at:", promise, "reason:", reason);
});

process.on("uncaughtException", (error) => {
  console.log("Uncaught Exception:", error);
});

// MongoDB connection
mongoose
  .connect(process.env.MONGODB_URI, {
    useNewUrlParser: true,
    useUnifiedTopology: true,
    serverSelectionTimeoutMS: 5000,
    socketTimeoutMS: 45000,
    connectTimeoutMS: 10000,
  })
  .then(() => {
    console.log("Successfully connected to MongoDB.");
  })
  .catch((err) => {
    console.error("MongoDB connection error:", err);
  });

// Schema with category field
const bdociSchema = new mongoose.Schema({
  title: String,
  document: String,
  code: String,
  category: {
    type: String,
    default: "Uncategorized",
  },
});
const Doc = mongoose.model("Doc", bdociSchema);

// Middleware to get categories dynamically
app.use(async (req, res, next) => {
  console.log(`${new Date().toISOString()} - ${req.method} ${req.url}`);

  try {
    // Get all unique categories from database
    const categories = await Doc.distinct("category");
    res.locals.categories = categories.sort(); // Make categories available in all templates
  } catch (error) {
    console.error("Error fetching categories:", error);
    res.locals.categories = ["Uncategorized"];
  }
  next();
});

// Routes
const linkify = (text) => {
  if (!text) return "";
  // Regex to find URLs not already inside href/src attributes
  return text.replace(
    /(?<!href="|src=")(https?:\/\/[^\s<]+(?<![.,?!]))/g,
    (url) => {
      let displayText = url;
      try {
        // Decode URI components (e.g., %20 to space) for better readability
        displayText = decodeURIComponent(url);
        // Truncate if extremely long
        if (displayText.length > 80) {
          displayText = displayText.substring(0, 77) + "...";
        }
      } catch (e) {
        // Fallback to original URL if decoding fails
      }
      return `<a href="${url}" class="doc-link" target="_blank" rel="noopener noreferrer"><i class="bi bi-link-45deg"></i>${displayText}</a>`;
    },
  );
};

app.get("/", async (req, res) => {
  try {
    const { category } = req.query;
    let filter = {};

    // Filter by category if provided
    if (category && category !== "all") {
      filter.category = category;
    }

    const documents = await Doc.find(filter).sort({ title: 1 });
    res.render("home", {
      documents,
      selectedCategory: category || "all",
    });
  } catch (error) {
    console.error("Error fetching documents:", error);
    res.status(500).send("Error loading documentation list");
  }
});

// Endpoint to return all raw document data
app.get("/api/data", async (req, res) => {
  try {
    const allData = await Doc.find({});
    res.json(allData);
  } catch (error) {
    console.error("Error fetching all data:", error);
    res.status(500).json({ error: "Error fetching data" });
  }
});

app.get("/admin", (req, res) => {
  res.render("admin/admin");
});

app.post("/admin", async (req, res) => {
  try {
    if (
      req.body.adminName === process.env.ADMIN_USERNAME &&
      req.body.password === process.env.ADMIN_PASSWORD
    ) {
      res.render("admin/compose");
    } else {
      return res.status(401).send("Invalid credentials");
    }
  } catch (error) {
    console.error("Login error:", error);
    res.status(500).send("An error occurred during login");
  }
});

app.post("/compose", async (req, res) => {
  try {
    const document = new Doc({
      title: req.body.title,
      document: req.body.doc,
      code: req.body.code,
      category: req.body.newCategory || "Uncategorized",
    });
    await document.save();
    if (admin.apps.length) {
      try {
        const message = {
          notification: {
            title: "New Note Uploaded! 🎉",
            body: `Check out: ${document.title} in ${document.category}`,
          },
          topic: "new_docs",
        };
        // Send the push notification
        await admin.messaging().send(message);
        console.log(`Notification sent for: ${document.title}`);
      } catch (fcmError) {
        console.error("Failed to send Firebase notification:", fcmError);
        // Notice we don't crash the server here. If the notification fails,
        // the document is still saved safely in MongoDB.
      }
    }
    res.render("admin/compose");
  } catch (error) {
    console.error("Error saving document:", error);
    res.status(500).send("Error saving document");
  }
});

app.get("/:title", async (req, res) => {
  try {
    const requestedTitle = req.params.title;
    const document = await Doc.findOne({ title: requestedTitle });

    if (!document) {
      return res.status(404).render("404");
    }

    res.render("index", {
      title: document.title,
      documentation: linkify(document.document),
      code: document.code,
      category: document.category,
    });
  } catch (error) {
    console.error("Error fetching document:", error);
    res.status(500).send("Error loading documentation");
  }
});

// Health check endpoints
app.get("/health", (req, res) => {
  const dbStatus =
    mongoose.connection.readyState === 1 ? "connected" : "disconnected";
  res.json({
    status: "ok",
    timestamp: new Date(),
    database: dbStatus,
  });
});

app.get("/api/health", (req, res) => {
  res.json({
    status: "ok",
    environment: process.env.NODE_ENV,
    mongodb:
      mongoose.connection.readyState === 1 ? "connected" : "disconnected",
    timestamp: new Date().toISOString(),
  });
});

// Error handling middleware
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).send("Something broke!");
});

// Start server
const PORT = process.env.PORT || 3000;
if (!process.env.VERCEL) {
  app.listen(PORT, "0.0.0.0", () => {
    console.log(`Server is Running at ${PORT}`);
  });
}

module.exports = app;