// How it works:
Page Load
  ├─ [1] Show cached jobs from Redux/localStorage
  ├─ [2] Display loading spinner only for first visit
  ├─ [3] Trigger background refresh (non-blocking)
  ├─ [4] Scraper runs → new jobs added
  └─ [5] Cache updated silently (user doesn't see reload)

// Cleanup Logic:
Every 5 minutes:
  1️⃣ Scrape new jobs from platforms
  2️⃣ Save new jobs (PATCH/upsert - no duplicates)
  3️⃣ 🧹 AUTO-DELETE: Jobs with postedDate > 7 days ago
  4️⃣ Return database statistics

Result: Database stays at ~2500-4200 jobs max (optimized)

// Upsert Strategy:
- Create unique identifier: `${platform}-${title}-${company}`
- Check if job exists (uniqueId match)
- If exists: UPDATE (merge new data)
- If not exists: INSERT (new job)
- Never delete, only add/update

// Header Section
┌──────────────────────────────────────────────┐
│ Job Opportunities                 [🔄 Refresh]│
│ Find and apply to job listings    Updated 2m ago │
└──────────────────────────────────────────────┘

// When refreshing:
[🔄 Refreshing...]    ← Disabled during refresh
"Updating in background..."  ← Shows while refreshing

// After refresh:
[🔄 Refresh]          ← Ready to click again
"Updated Just now"    ← Shows fresh timestamp

// In backend/index.js
import { initializeScheduledScrapers } from "./utils/scraperScheduler.js";

// Run scheduled scraping
await initializeScheduledScrapers();

// This runs cron jobs:
// - Every 5 minutes: Full scrape + cleanup
// - 9 AM: Heavy scraping
// - 2 PM: Medium scraping
// - 7 PM: Light scraping

import { scheduleScraperTask } from "./utils/scraperScheduler.js";

// Run at 9 AM daily
await scheduleScraperTask("daily-9am", "0 9 * * *", {
  linkedin: { enabled: true, pages: 2 },
  internshala: { enabled: true, pages: 3 },
  naukri: { enabled: true, pages: 2 },
});

// In masterScraper.js, change 7 to any number of days
const deletedCount = await cleanupOldJobs(14); // Keep 14 days instead

// Client initiates connection
socket.on("connect", () => {
  console.log("Connected to server");
  // Authenticate user, load previous messages
});

socket.on("connect_error", (error) => {
  console.error("Connection error:", error);
  // Handle retry logic
});

socket.on("disconnect", (reason) => {
  console.log("Disconnected:", reason);
  // Clean up UI, show offline indicator
});

socket.on("reconnect", () => {
  console.log("Reconnected to server");
  // Refresh state, rejoin rooms
});

// User joins a conversation
socket.emit("join_conversation", {
  conversationId: "conv_123",
  userId: "user_456",
});

// Send a new message
socket.emit("send_message", {
  conversationId: "conv_123",
  message: "Hey, can you help with this task?",
  attachments: [
    { type: "file", url: "s3://bucket/file.pdf" },
    { type: "image", url: "s3://bucket/img.jpg" },
  ],
});

// Show typing indicator (send while user typing)
socket.emit("typing_start", { conversationId: "conv_123" });

// Hide typing indicator (send when user stops)
socket.emit("typing_stop", { conversationId: "conv_123" });

// Mark messages as read
socket.emit("mark_as_read", {
  conversationId: "conv_123",
  messageId: "msg_789",
});

// User leaves conversation
socket.emit("leave_conversation", { conversationId: "conv_123" });

// New message received
socket.on("new_message", (data) => {
  const {
    messageId, // Unique message ID
    conversationId, // Which conversation
    senderId, // Who sent it
    message, // Message text
    attachments, // Files/media
    timestamp, // When sent
  } = data;

  // Update Redux, display in UI
  dispatch(addMessage(data));
});

// User is typing
socket.on("user_typing", (data) => {
  const { conversationId, userId, typing } = data;
  // Show "User is typing..." indicator
});

// Message marked as read
socket.on("message_read", (data) => {
  const { messageId, conversationId, readBy, readAt } = data;
  // Update message status to "read"
});

// Conversation updated (name, members changed)
socket.on("conversation_updated", (data) => {
  const { conversationId, updates } = data;
  // Refresh conversation metadata
});

// ========== Initiating a Call ==========

// Step 1: Caller initiates call
socket.emit("call:initiate", {
  calleeId: "user_456", // Who to call
  callerId: "user_123", // Who is calling
  conversationId: "conv_789", // Associated conversation
  type: "video", // or "audio"
});

// Step 2: Server sends to callee
socket.on("incoming_call", (data) => {
  const { callerId, conversationId, type } = data;
  // Show "Incoming call" UI, play notification sound
});

// Step 3: Callee accepts
socket.emit("call:accept", {
  callId: "call_123",
  calleeId: "user_456",
});

// ========== WebRTC Signaling ==========

// Caller sends WebRTC offer
socket.emit("signal", {
  to: "user_456", // Send to
  from: "user_123", // Send from
  signal: sdpObject, // SDP object (JSON serializable)
  type: "offer", // "offer" | "answer" | "ice"
});

// Receive WebRTC signal
socket.on("signal", (data) => {
  const { from, signal, type } = data;
  // Process signal: offer/answer/ice candidate
  // Update peer connection
});

// Decline call
socket.emit("call:reject", {
  callId: "call_123",
  reason: "busy", // optional
});

// End call
socket.emit("call:end", {
  callId: "call_123",
});

// Call ended by other party
socket.on("call:ended", (data) => {
  const { callId, reason } = data;
  // Close peer connection, show call summary
});

// Call failed
socket.on("call:failed", (data) => {
  const { reason, code } = data;
  // Show error message
});

// New job matching user's skills
socket.on("job_matched", (data) => {
  const { jobId, title, client, budget, skills } = data;
  // Show notification, trigger desktop alert
});

// Application status changed
socket.on("application_update", (data) => {
  const { applicationId, status, message } = data;
  // "accepted" | "rejected" | "shortlisted"
});

// Job status update
socket.on("job_update", (data) => {
  const { jobId, status, message } = data;
  // "in_progress" | "completed" | "cancelled"
});

// Payment received
socket.on("payment_received", (data) => {
  const { amount, jobId, date } = data;
  // Show success message, update balance
});

// New message notification
socket.on("message_notification", (data) => {
  const { senderId, senderName, message, conversationId } = data;
  // Browser notification
});

// Online status changed
socket.on("user_online", (data) => {
  const { userId, isOnline, lastSeen } = data;
  // Update user avatar indicator
});

// context/SocketContext.jsx
import { createContext, useEffect, useState } from "react";
import io from "socket.io-client";

const SocketContext = createContext();

export function SocketProvider({ children }) {
  const [socket, setSocket] = useState(null);
  const [isConnected, setIsConnected] = useState(false);
  const { user } = useAuth();

  useEffect(() => {
    if (!user) return;

    // Connect to Socket.IO server
    const newSocket = io(import.meta.env.VITE_SOCKET_URL, {
      auth: { token: localStorage.getItem("token") },
      reconnection: true,
      reconnectionDelay: 1000,
      reconnectionDelayMax: 5000,
      reconnectionAttempts: Infinity,
    });

    // Connection handlers
    newSocket.on("connect", () => setIsConnected(true));
    newSocket.on("disconnect", () => setIsConnected(false));
    newSocket.on("connect_error", (error) => console.error(error));

    setSocket(newSocket);

    return () => newSocket.disconnect();
  }, [user]);

  return (
    <SocketContext.Provider value={{ socket, isConnected }}>
      {children}
    </SocketContext.Provider>
  );
}

export function useSocket() {
  const context = useContext(SocketContext);
  if (!context) throw new Error("useSocket must be used within SocketProvider");
  return context;
}

// components/ChatWindow.jsx
import { useSocket } from "@/context/SocketContext";

export function ChatWindow({ conversationId }) {
  const { socket } = useSocket();
  const [messages, setMessages] = useState([]);
  const [isTyping, setIsTyping] = useState(false);

  useEffect(() => {
    if (!socket) return;

    // Join conversation room
    socket.emit("join_conversation", { conversationId });

    // Listen for new messages
    const handleNewMessage = (data) => {
      setMessages((prev) => [...prev, data]);
    };

    // Listen for typing
    const handleUserTyping = (data) => {
      setIsTyping(data.typing);
    };

    socket.on("new_message", handleNewMessage);
    socket.on("user_typing", handleUserTyping);

    return () => {
      socket.off("new_message", handleNewMessage);
      socket.off("user_typing", handleUserTyping);
      socket.emit("leave_conversation", { conversationId });
    };
  }, [socket, conversationId]);

  const sendMessage = (text) => {
    socket.emit("send_message", {
      conversationId,
      message: text,
      attachments: [],
    });
  };

  return (
    <div>
      {messages.map((msg) => (
        <div key={msg.messageId}>{msg.message}</div>
      ))}
      {isTyping && <p className="text-gray-500">User is typing...</p>}
      <input onKeyPress={(e) => sendMessage(e.target.value)} />
    </div>
  );
}

// Automatic reconnection with exponential backoff
const socket = io(SOCKET_URL, {
  reconnection: true,
  reconnectionDelay: 1000,
  reconnectionDelayMax: 5000,
  reconnectionAttempts: Infinity,
});

// Listen for connection errors
socket.on("connect_error", (error) => {
  console.error("Connection error:", error);
  // Automatically retries after reconnectionDelay
});

// Handle message failures
socket.emit("send_message", data, (ack) => {
  if (ack.success) {
    console.log("Message delivered");
  } else {
    console.error("Message failed:", ack.error);
    // Retry logic
  }
});

// Middleware example
const authMiddleware = async (req, res, next) => {
  try {
    const token = req.cookies.token;
    if (!token) throw new Error("Unauthorized");

    const decoded = jwt.verify(token, process.env.SECRET_KEY);
    req.user = await User.findById(decoded.id);
    next();
  } catch (error) {
    res.status(401).json({ error: "Unauthorized" });
  }
};