worker.js

const botToken='xxxxxx';


const CACHE_TTL = 3600000; 
const inMemoryKV = {
  async get(key) {
    const v = _inMemoryKVStore.get(key);
    return typeof v === 'undefined' ? null : v;
  },
  async put(key, value) {
    _inMemoryKVStore.set(key, value);
    return;
  }
};

const RESET_HOUR = 8; // 8 AM

function getCurrentDateKey(now = new Date()) {
  const d = new Date(now);
  if (d.getHours() < RESET_HOUR) {
    d.setDate(d.getDate() - 1);
  }
  return d.toISOString().split('T')[0];
}

// Achievement definitions
const ACHIEVEMENTS = {
  FIRST_BLOOD: { name: "First Blood", desc: "Solve your first problem", emoji: "🩸" },
  STREAK_7: { name: "Week Warrior", desc: "7-day solving streak", emoji: "🔥" },
  RATING_100: { name: "Centurion", desc: "Solve 100 problems", emoji: "💯" },
  ALL_TAGS: { name: "Jack of All Trades", desc: "Solve problems from 10 different tags", emoji: "🎭" },
  RATING_1600: { name: "Expert", desc: "Solve a 1600+ rated problem", emoji: "⭐" },
  DAILY_CHAMP: { name: "Daily Champion", desc: "Complete daily challenge", emoji: "🏆" }
};

// Command descriptions (kept mostly for reference)
const COMMANDS = {
  "/start": "Start the bot",
  "/stats": "View your solving statistics",
  "/contest": "Upcoming contests",
  "/goal": "Set daily goals",
  "/challenge": "Daily challenge",
  "/compare": "Compare with friends",
  "/browse": "Browse problems interactively",
  "/reminder": "Set contest reminders",
  "/achievements": "View your achievements",
  "/help": "Show all commands",
  "/history": "Your problem history"
};


let problemsCache = { data: null, timestamp: 0 };
let contestsCache = { data: null, timestamp: 0 };


function getDifficultyText(rating) {
  if (!rating) return "Unknown";
  if (rating < 1000) return "Very Easy";
  if (rating < 1400) return "Easy";
  if (rating < 1800) return "Medium";
  if (rating < 2200) return "Hard";
  return "Very Hard";
}


function createKeyboard(buttonRows) {
  return { inline_keyboard: buttonRows };
}

// Telegram API sendMessage wrapper
async function sendMessage(chatId, text, botToken, replyMarkup = null, parseMode = null) {
  const payload = { chat_id: chatId, text };
  if (replyMarkup) payload.reply_markup = replyMarkup;
  if (parseMode) payload.parse_mode = parseMode;

  try {
    const res = await fetch(`https://api.telegram.org/bot${botToken}/sendMessage`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(payload)
    });
    const json = await res.json();
    if (!res.ok) {
      console.error('Telegram API error', json);
      return false;
    }
    return true;
  } catch (err) {
    console.error('sendMessage error', err);
    return false;
  }
}


async function fetchCFProblems() {
  const now = Date.now();
  if (problemsCache.data && (now - problemsCache.timestamp) < CACHE_TTL) {
    return problemsCache.data;
  }

  try {
    const res = await fetch('https://codeforces.com/api/problemset.problems');
    const json = await res.json();
    if (json.status !== 'OK') {
      throw new Error('Codeforces API returned non-OK');
    }
    problemsCache.data = json.result.problems;
    problemsCache.timestamp = now;
    return problemsCache.data;
  } catch (err) {
    console.error('fetchCFProblems error', err);
    return problemsCache.data || [];
  }
}


async function getProblemsWithSmartCache() {
  try {
    const problems = await fetchCFProblems();
    return problems || [];
  } catch (err) {
    console.error('getProblemsWithSmartCache error', err);
    return [];
  }
}


async function fetchContests() {
  const now = Date.now();
  if (contestsCache.data && (now - contestsCache.timestamp) < CACHE_TTL) {
    return contestsCache.data;
  }

  try {
    const res = await fetch('https://codeforces.com/api/contest.list');
    const json = await res.json();
    if (json.status === 'OK') {
      contestsCache.data = json.result;
      contestsCache.timestamp = now;
      return contestsCache.data;
    }
    return contestsCache.data || [];
  } catch (err) {
    console.error('fetchContests error', err);
    return contestsCache.data || [];
  }
}

function filterProblems(problems, mode, rating = null, tag = null, indexLetter = null, count = 5, options = {}) {
  let filtered = Array.isArray(problems) ? [...problems] : [];

  if (mode === 'rating') {
    filtered = filtered.filter(p => p.rating === rating);
  } else if (mode === 'tag') {
    filtered = filtered.filter(p => tag && p.tags && p.tags.some(t => t.toLowerCase() === tag.toLowerCase()));
  } else if (mode === 'index') {
    filtered = filtered.filter(p => p.index === indexLetter);
  } else if (mode === 'rating_tag') {
    filtered = filtered.filter(p =>
      p.rating === rating &&
      tag && p.tags && p.tags.some(t => t.toLowerCase() === tag.toLowerCase())
    );
  } else if (mode === 'random') {
    const minRating = options.minRating || 800;
    const maxRating = options.maxRating || 3500;
    filtered = filtered.filter(p => p.rating >= minRating && p.rating <= maxRating);
  } else if (mode === 'recent_contest') {
    // Simple heuristic to pick relatively recent contests/problems
    const sixMonthsAgo = Date.now() - 180 * 24 * 60 * 60 * 1000;
    filtered = filtered.filter(p => p.contestId && p.contestId > 1000);
  }

  filtered = filtered.filter(p => p && p.contestId && p.index);

  // Shuffle
  for (let i = filtered.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [filtered[i], filtered[j]] = [filtered[j], filtered[i]];
  }

  return filtered.slice(0, count);
}

async function dbGetUser(chatId, KV) {
  try {
    const raw = await KV.get(`user:${chatId}`);
    return raw ? JSON.parse(raw) : null;
  } catch (err) {
    console.error('dbGetUser error', err);
    return null;
  }
}

async function dbUpsertUser(chatId, updates, KV) {
  try {
    const existingRaw = await KV.get(`user:${chatId}`);
    const existing = existingRaw ? JSON.parse(existingRaw) : {};
    const merged = { ...existing, ...updates, chat_id: chatId };
    await KV.put(`user:${chatId}`, JSON.stringify(merged));
    return merged;
  } catch (err) {
    console.error('dbUpsertUser error', err);
    return null;
  }
}

async function dbAddHistory(chatId, problem, KV) {
  try {
    const historyItem = {
      chat_id: chatId,
      contestId: problem.contestId,
      problem_index: problem.index,
      name: problem.name,
      rating: problem.rating,
      tags: problem.tags || [],
      ts: new Date().toISOString()
    };
    const userHistoryKey = `user_history:${chatId}`;
    const raw = await KV.get(userHistoryKey);
    let list = raw ? JSON.parse(raw) : [];
    list.unshift(historyItem);
    if (list.length > 50) list = list.slice(0, 50);
    await KV.put(userHistoryKey, JSON.stringify(list));

    await checkAchievements(chatId, KV);
  } catch (err) {
    console.error('dbAddHistory error', err);
  }
}

async function dbGetHistory(chatId, limit = 10, KV) {
  try {
    const raw = await KV.get(`user_history:${chatId}`);
    if (!raw) return [];
    const list = JSON.parse(raw);
    return list.slice(0, limit);
  } catch (err) {
    console.error('dbGetHistory error', err);
    return [];
  }
}

async function dbGetAllHistory(chatId, KV) {
  try {
    const raw = await KV.get(`user_history:${chatId}`);
    return raw ? JSON.parse(raw) : [];
  } catch (err) {
    console.error('dbGetAllHistory error', err);
    return [];
  }
}

async function getUserStats(chatId, KV, botToken) {
  const history = await dbGetAllHistory(chatId, KV);
  if (!history || history.length === 0) {
    return sendMessage(chatId, "No problems solved yet! Start with /start", botToken);
  }

  const solvedByRating = {};
  const solvedByTag = {};
  let totalRating = 0;
  let maxRating = 0;
  let ratedCount = 0;

  history.forEach(p => {
    const ratingKey = p.rating || 'Unknown';
    solvedByRating[ratingKey] = (solvedByRating[ratingKey] || 0) + 1;
    p.tags?.forEach(t => { solvedByTag[t] = (solvedByTag[t] || 0) + 1; });
    if (p.rating) { totalRating += p.rating; maxRating = Math.max(maxRating, p.rating); ratedCount++; }
  });

  const averageRating = ratedCount ? Math.round(totalRating / ratedCount) : 0;

  let statsMsg = "📊 *Your Statistics:*\n\n";
  statsMsg += `✅ Total Solved: *${history.length}* problems\n`;
  statsMsg += `⭐ Average Rating: *${averageRating || 'N/A'}*\n`;
  statsMsg += `🏆 Highest Rated: *${maxRating || 'N/A'}*\n\n`;

  statsMsg += "📈 By Rating:\n";
  Object.keys(solvedByRating)
    .sort((a, b) => {
      if (a === 'Unknown') return 1;
      if (b === 'Unknown') return -1;
      return a - b;
    })
    .forEach(rating => {
      const count = solvedByRating[rating];
      const percentage = ((count / history.length) * 100).toFixed(1);
      const bar = "█".repeat(Math.round(percentage / 10));
      statsMsg += `${rating}: ${bar} ${count} (${percentage}%)\n`;
    });

  const topTags = Object.entries(solvedByTag).sort(([, a], [, b]) => b - a).slice(0, 5);
  if (topTags.length > 0) {
    statsMsg += "\n🏷️ Top Tags:\n";
    topTags.forEach(([tag, count]) => { statsMsg += `• ${tag}: ${count}\n`; });
  }

  return sendMessage(chatId, statsMsg, botToken, null, "Markdown");
}

// Contests
async function getUpcomingContests(chatId, botToken) {
  try {
    const contests = await fetchContests();
    const upcoming = (contests || []).filter(c => c.phase === 'BEFORE').slice(0, 8);
    if (upcoming.length === 0) {
      return sendMessage(chatId, "No upcoming contests found.", botToken);
    }

    let msg = "🗓️ *Upcoming Contests:*\n\n";
    upcoming.forEach(contest => {
      const startTime = new Date(contest.startTimeSeconds * 1000);
      const timeUntilMs = contest.startTimeSeconds * 1000 - Date.now();
      const days = Math.floor(timeUntilMs / (1000 * 60 * 60 * 24));
      const hours = Math.floor((timeUntilMs % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
      msg += `🏆 [${contest.name}](https://codeforces.com/contest/${contest.id})\n`;
      msg += `⏰ ${startTime.toLocaleDateString()} ${startTime.toLocaleTimeString()}\n`;
      msg += `⏳ Starts in ${days}d ${hours}h\n\n`;
    });

    const keyboard = createKeyboard([
      [{ text: "🔔 Set Reminder", callback_data: "set_reminder" }],
      [{ text: "📚 Practice Problems", callback_data: "practice_for_contest" }]
    ]);

    return sendMessage(chatId, msg, botToken, keyboard, "Markdown");
  } catch (err) {
    console.error('getUpcomingContests error', err);
    return sendMessage(chatId, "❌ Failed to fetch contests", botToken);
  }
}

// Goals
async function setDailyGoal(chatId, count, KV, botToken) {
  const parsed = parseInt(count, 10);
  const goalObj = {
    target: parsed,
    startDate: new Date().toISOString(),
    current: 0,
    streak: 0
  };
  await KV.put(`goal:${chatId}`, JSON.stringify(goalObj));
  return sendMessage(chatId, `🎯 Daily goal set: ${parsed} problems per day!`, botToken);
}

async function checkGoalProgress(chatId, KV, botToken) {
  const raw = await KV.get(`goal:${chatId}`);
  if (!raw) return sendMessage(chatId, "No goal set. Use /goal <number> to set a daily goal.", botToken);

  const goal = JSON.parse(raw);
  const today = new Date().toDateString();
  const history = await dbGetAllHistory(chatId, KV);
  const todayProblems = history.filter(p => new Date(p.ts).toDateString() === today);

  goal.current = todayProblems.length;
  const progress = Math.min(100, Math.round((goal.current / goal.target) * 100 || 0));
  const filled = Math.floor(progress / 10);
  const progressBar = "█".repeat(filled) + "░".repeat(10 - filled);

  let msg = `🎯 *Daily Goal Progress*\n\n`;
  msg += `Target: ${goal.target} problems\n`;
  msg += `Solved today: ${goal.current} problems\n\n`;
  msg += `Progress: ${progressBar} ${progress}%\n\n`;
  if (goal.current >= goal.target) {
    msg += "🎉 *Goal completed!* Amazing work!";
    goal.streak = (goal.streak || 0) + 1;
    if (goal.streak > 1) msg += `\n🔥 Streak: ${goal.streak} days!`;
  } else {
    msg += `Keep going! ${Math.max(0, goal.target - goal.current)} more to go.`;
  }

  await KV.put(`goal:${chatId}`, JSON.stringify(goal));
  return sendMessage(chatId, msg, botToken, null, "Markdown");
}

// Daily Challenge
async function startDailyChallenge(chatId, KV, botToken) {
  const today = getCurrentDateKey();
  const challengeKey = `challenge:${today}`;

  try {
    let raw = await KV.get(challengeKey);
    let challenge;
    if (!raw) {
      const problems = await fetchCFProblems();
      if (!problems || problems.length === 0) {
        return sendMessage(chatId, "❌ Cannot generate challenge - Codeforces API is unavailable. Try again later.", botToken);
      }

      const easy = filterProblems(problems, 'rating', 800, null, null, 1);
      const medium = filterProblems(problems, 'rating', 1200, null, null, 1);
      const hard = filterProblems(problems, 'rating', 1600, null, null, 1);
      let challengeProblems = [...easy, ...medium, ...hard].filter(Boolean);

      if (challengeProblems.length === 0) {
        challengeProblems = filterProblems(problems, 'random', null, null, null, 3);
      }

      challenge = { problems: challengeProblems, participants: {}, date: today };
      await KV.put(challengeKey, JSON.stringify(challenge));
      console.log(`Created new daily challenge with ${challengeProblems.length} problems`);
    } else {
      challenge = JSON.parse(raw);
    }

    const participant = challenge.participants[chatId];

    if (participant) {
      let statusMsg = "🎲 *Today's Challenge Problems*\n\n";
      statusMsg += "📋 **Your Current Progress:**\n";
      statusMsg += `Solved: ${participant.solved?.length || 0}/${challenge.problems.length} problems\n\n`;

      challenge.problems.forEach((p, index) => {
        const link = `https://codeforces.com/problemset/problem/${p.contestId}/${p.index}`;
        const isSolved = participant.solved?.includes(`${p.contestId}${p.index}`);
        statusMsg += `${isSolved ? '✅' : '◻️'} ${index + 1}. [${p.name}](${link})\n`;
        statusMsg += `   Rating: ${p.rating || '?'}⭐ | ${getDifficultyText(p.rating)}\n\n`;
      });

      if (participant.completed) {
        statusMsg += "🎉 *CHALLENGE COMPLETED!* 🏆\nYou've earned the Daily Champion achievement!\n\n";
      } else {
        statusMsg += "💡 **Keep going!** Solve all problems to complete the challenge.\n\n";
      }

      const keyboard = createKeyboard([
        [{ text: "🔄 Check Progress", callback_data: "refresh_challenge" }],
        [{ text: "📊 View Stats", callback_data: "challenge_stats" }],
        [{ text: "🎯 New Problems", callback_data: "get_new_problems" }]
      ]);

      return sendMessage(chatId, statusMsg, botToken, keyboard, "Markdown");
    }

    // New user invitation
    let msg = "🎲 *Daily Challenge - Ready to Join!*\n\n";
    msg += `Solve ${challenge.problems.length} problems of varying difficulty:\n\n`;
    challenge.problems.forEach((p, idx) => {
      const link = `https://codeforces.com/problemset/problem/${p.contestId}/${p.index}`;
      msg += `${idx + 1}. [${p.name}](${link})\n`;
      msg += `   Rating: ${p.rating || '?'}⭐ | ${getDifficultyText(p.rating)}\n\n`;
    });
    msg += "**Rewards:**\n";
    msg += "✅ Complete all → 🏆 Daily Champion achievement\n";
    msg += "✅ Track progress and streaks\n";
    msg += "✅ Compare with other participants\n";

    const keyboard = createKeyboard([
      [{ text: "🎯 Join Challenge", callback_data: "join_challenge" }],
      [{ text: "👀 View Problems Only", callback_data: "view_challenge_problems" }]
    ]);

    return sendMessage(chatId, msg, botToken, keyboard, "Markdown");
  } catch (err) {
    console.error('startDailyChallenge error', err);
    return sendMessage(chatId, "❌ Error loading daily challenge. Please try again.", botToken);
  }
}

// Achievement system
async function checkAchievements(chatId, KV) {
  try {
    const user = await dbGetUser(chatId, KV) || {};
    const history = await dbGetAllHistory(chatId, KV);
    if (!history || history.length === 0) return;

    const achievements = user.achievements || {};
    const newAchievements = [];

    if (history.length >= 1 && !achievements.FIRST_BLOOD) newAchievements.push('FIRST_BLOOD');
    if (history.length >= 100 && !achievements.RATING_100) newAchievements.push('RATING_100');
    if (!achievements.RATING_1600 && history.some(p => p.rating >= 1600)) newAchievements.push('RATING_1600');

    const uniqueTags = new Set();
    history.forEach(p => p.tags?.forEach(t => uniqueTags.add(t)));
    if (uniqueTags.size >= 10 && !achievements.ALL_TAGS) newAchievements.push('ALL_TAGS');

    if (newAchievements.length > 0) {
      // Unlock achievements (we don't have botToken here; unlocking will only update DB;
      // notification will be sent by caller that has botToken (we call unlockAchievements with botToken below))
      const unlocked = { ...(achievements || {}) };
      newAchievements.forEach(k => {
        unlocked[k] = { unlocked: new Date().toISOString(), ...ACHIEVEMENTS[k] };
      });
      await dbUpsertUser(chatId, { achievements: unlocked }, KV);
    }
  } catch (err) {
    console.error('checkAchievements error', err);
  }
}

async function unlockAchievements(chatId, achievementKeys, KV, botToken) {
  try {
    const user = await dbGetUser(chatId, KV) || {};
    const achievements = user.achievements || {};
    achievementKeys.forEach(key => {
      achievements[key] = { unlocked: new Date().toISOString(), ...ACHIEVEMENTS[key] };
    });
    await dbUpsertUser(chatId, { achievements }, KV);

    // Send notifications
    for (const key of achievementKeys) {
      const achievement = ACHIEVEMENTS[key];
      const msg = `🎉 *Achievement Unlocked!*\n\n${achievement.emoji} *${achievement.name}*\n${achievement.desc}`;
      await sendMessage(chatId, msg, botToken, null, "Markdown");
    }
  } catch (err) {
    console.error('unlockAchievements error', err);
  }
}
// Daily Notification System
let dailyNotificationSent = {}; // Track if daily problems were sent today

// Function to send daily problems to a user
async function sendDailyProblems(chatId, KV, botToken) {
  const today = getCurrentDateKey();

  // Check if already sent today (based on reset-hour day key)
  if (dailyNotificationSent[chatId] === today) {
    return; // Already sent today
  }
    
  try {
    const todaysProblems = await getOrCreateTodaysProblems(chatId, KV, false);
    if (!todaysProblems || todaysProblems.length === 0) {
      console.log('Cannot send daily problems - CF API unavailable or no problems generated');
      return;
    }

    let message = `📅 *Today's Recommended Problems* 🚀\n\n`;
    message += `Here are your daily practice problems to keep you sharp:\n\n`;

    todaysProblems.forEach((p, index) => {
      const link = `https://codeforces.com/problemset/problem/${p.contestId}/${p.index}`;
      message += `${index + 1}. [${p.name}](${link})\n`;
      message += `   Rating: ${p.rating}⭐ | ${getDifficultyText(p.rating)}\n`;
      message += `   Tags: ${p.tags?.slice(0, 3).join(', ') || 'None'}\n\n`;
    });

    message += `💡 *Tip:* Try to solve at least one problem daily to maintain consistency!\n`;
    message += `✅ Solving these will count towards your daily goals.`;

    const keyboard = createKeyboard([
      [{ text: "🎯 Set Daily Goal", callback_data: "set_goal_menu" }],
      [{ text: "🏆 Join Daily Challenge", callback_data: "daily_challenge" }],
      [{ text: "📊 View Progress", callback_data: "show_stats" }]
    ]);

    await sendMessage(chatId, message, botToken, keyboard, "Markdown");

    // Mark as sent for today (worker-local cache)
    dailyNotificationSent[chatId] = today;

    console.log(`✅ Daily problems sent to ${chatId}`);
  } catch (error) {
    console.error('Error sending daily problems:', error);
  }
}

// Function to check and send daily problems to all active users
async function sendDailyProblemsToAllUsers(KV, botToken) {
    try {
        console.log('🔄 Starting daily problem distribution...');
        const activeUsers = await getAllActiveUsers(KV);
        
        if (activeUsers.length === 0) {
            console.log('No active users found for daily problems');
            return;
        }
        
        console.log(`Sending daily problems to ${activeUsers.length} users`);
        
        for (let i = 0; i < activeUsers.length; i++) {
            const chatId = activeUsers[i];
            await sendDailyProblems(chatId, KV, botToken);
            
            if (i < activeUsers.length - 1) {
                await new Promise(resolve => setTimeout(resolve, 100));
            }
        }
        
        console.log('✅ Daily problem distribution completed');
        
    } catch (error) {
        console.error('Error in daily problem distribution:', error);
    }
}


async function getAllActiveUsers(KV) {
    const users = [];
    
    const userList = await KV.get('active_users');
    if (userList) {
        return JSON.parse(userList);
    }
    
    return users;
}


async function getOrCreateTodaysProblems(chatId, KV, force = false) {
  const today = getCurrentDateKey();
  const key = `todays_problems:${today}:${chatId}`;

  try {
    if (!KV) {
      console.error('getOrCreateTodaysProblems: KV binding is not provided');
      return [];
    }
    if (!force) {
      const raw = await KV.get(key);
      console.log(`getOrCreateTodaysProblems: KV.get(${key}) returned length:`, raw ? raw.length : 0);
      if (raw) {
        try {
          const stored = JSON.parse(raw);
          if (Array.isArray(stored) && stored.length > 0) return stored;
        } catch (e) {

          console.warn('Failed to parse stored todays problems, regenerating', e);
        }
      }
    }

    const problems = await getProblemsWithSmartCache();
    if (!problems || problems.length === 0) return [];

    const p1200 = filterProblems(problems, 'rating', 1200, null, null, 1);
    const p1300 = filterProblems(problems, 'rating', 1300, null, null, 1);
    const p1400 = filterProblems(problems, 'rating', 1400, null, null, 1);

    let todays = [...p1200, ...p1300, ...p1400].filter(Boolean);
    if (todays.length === 0) {
      todays = filterProblems(problems, 'random', null, null, null, 3, { minRating: 1100, maxRating: 1500 });
    }


    const toStore = todays.map(p => ({ contestId: p.contestId, index: p.index, name: p.name, rating: p.rating, tags: p.tags || [] }));
    await KV.put(key, JSON.stringify(toStore));
    console.log(`getOrCreateTodaysProblems: Stored ${toStore.length} problems at key ${key}`);
    return toStore;
  } catch (err) {
    console.error('getOrCreateTodaysProblems error', err);
    return [];
  }
}


async function trackActiveUser(chatId, KV) {
    try {
        const userListKey = 'active_users';
        let activeUsers = await KV.get(userListKey);
        
        if (activeUsers) {
            activeUsers = JSON.parse(activeUsers);
        } else {
            activeUsers = [];
        }
        

        if (!activeUsers.includes(chatId)) {
            activeUsers.push(chatId);
            await KV.put(userListKey, JSON.stringify(activeUsers));
        }
        

        await KV.put(`user_activity:${chatId}`, Date.now().toString());
        
    } catch (error) {
        console.error('Error tracking active user:', error);
    }
}

// Manual command to get today's problems
async function sendTodaysProblems(chatId, KV, botToken, force = false) {
  const today = getCurrentDateKey();

  try {
    const todaysProblems = await getOrCreateTodaysProblems(chatId, KV, force);
    if (!todaysProblems || todaysProblems.length === 0) {
      return sendMessage(chatId,
        "❌ Cannot fetch problems right now. Codeforces API might be temporarily unavailable.\n\nTry again in a few minutes!",
        botToken
      );
    }

    let message = `📅 *Today's Practice Problems* 🎯\n\n`;
    message += `Here are your recommended problems for today:\n\n`;

    todaysProblems.forEach((p, index) => {
      const link = `https://codeforces.com/problemset/problem/${p.contestId}/${p.index}`;
      message += `**${index + 1}. ${p.rating}⭐ Challenge**\n`;
      message += `[${p.name}](${link})\n`;
      message += `Tags: ${p.tags?.slice(0, 3).join(', ') || 'None'}\n\n`;
    });

    message += `🔥 *Progression Path:*\n`;
    message += `• 1200⭐: Foundation building\n`;
    message += `• 1300⭐: Skill development\n`;
    message += `• 1400⭐: Advanced concepts\n\n`;
    message += `💪 Complete all three for maximum growth!`;

    const keyboard = createKeyboard([
      [{ text: "✅ Mark as Started", callback_data: "start_todays_problems" }],
      [{ text: "🔄 Get Different Problems", callback_data: "refresh_todays_problems" }],
      [{ text: "📊 Track Progress", callback_data: "show_stats" }]
    ]);

    dailyNotificationSent[chatId] = today;

    return sendMessage(chatId, message, botToken, keyboard, "Markdown");
  } catch (error) {
    console.error('Error sending today problems:', error);
    return sendMessage(chatId,
      "❌ Error fetching today's problems. Please try again later.",
      botToken
    );
  }
}

async function showAchievements(chatId, KV, botToken) {
  const user = await dbGetUser(chatId, KV) || {};
  const achievements = user.achievements || {};
  const allKeys = Object.keys(ACHIEVEMENTS);

  let msg = "🏆 *Your Achievements*\n\n";
  allKeys.forEach(key => {
    const achievement = ACHIEVEMENTS[key];
    const unlocked = achievements[key];
    if (unlocked) {
      const date = new Date(unlocked.unlocked).toLocaleDateString();
      msg += `✅ ${achievement.emoji} *${achievement.name}*\n   ${achievement.desc}\n   🗓️ ${date}\n\n`;
    } else {
      msg += `🔒 ${achievement.emoji} ${achievement.name}\n   ${achievement.desc}\n\n`;
    }
  });
  msg += `📊 Total: ${Object.keys(achievements || {}).length}/${allKeys.length} unlocked`;

  return sendMessage(chatId, msg, botToken, null, "Markdown");
}

// Problem browsing and sending
async function browseProblems(chatId, page = 0, KV, botToken) {
  const problems = await fetchCFProblems();
  const pageSize = 5;
  const start = page * pageSize;
  const pageProblems = problems.slice(start, start + pageSize);

  if (!pageProblems || pageProblems.length === 0) {
    return sendMessage(chatId, "No more problems to show!", botToken);
  }

  let msg = `🔍 *Browse Problems* (Page ${page + 1})\n\n`;
  pageProblems.forEach((p, index) => {
    msg += `${index + 1}. [${p.name}](https://codeforces.com/problemset/problem/${p.contestId}/${p.index})\n`;
    msg += `   Rating: ${p.rating || '?'} | Index: ${p.index}\n`;
    msg += `   Tags: ${p.tags?.slice(0, 3).join(', ') || 'None'}\n\n`;
  });

  const keyboardRows = pageProblems.map((p) => ([
    { text: `${p.index} - ${p.name.substring(0, 20)}...`, callback_data: `problem_${p.contestId}_${p.index}` }
  ]));

  const navRow = [];
  if (page > 0) navRow.push({ text: "⬅️ Previous", callback_data: `browse_${page - 1}` });
  navRow.push({ text: "Next ➡️", callback_data: `browse_${page + 1}` });

  keyboardRows.push(navRow);
  keyboardRows.push([{ text: "🏠 Main Menu", callback_data: "main_menu" }]);

  const keyboard = createKeyboard(keyboardRows);
  return sendMessage(chatId, msg, botToken, keyboard, "Markdown");
}

async function sendProblems(chatId, problems, KV, botToken) {
  if (!problems || problems.length === 0) {
    return sendMessage(chatId, "❌ No problems found for your filters.", botToken);
  }

  for (const p of problems) {
    const link = `https://codeforces.com/problemset/problem/${p.contestId}/${p.index}`;
    const name = p.name;
    const rating = p.rating || "?";
    const tags = p.tags ? p.tags.slice(0, 3).join(", ") : "";

    await sendMessage(chatId, `[${name}](${link}) — ${rating}⭐ (${tags})`, botToken, null, "Markdown");
    await dbAddHistory(chatId, p, KV);
  }

  const keyboard = createKeyboard([
    [{ text: "🔄 More Problems", callback_data: "main_menu" }],
    [{ text: "📊 View Stats", callback_data: "show_stats" }]
  ]);

  return sendMessage(chatId, "✅ Problems sent! Keep up the great work! 🚀", botToken, keyboard);
}

// Help & main menu
async function showHelp(chatId, botToken) {
  let helpMsg = "🤖 *Codeforces Bot - Complete Guide*\n\n";
  helpMsg += "*🎯 Basic Commands:*\n";
  helpMsg += "/start - Start the bot and choose mode\n";
  helpMsg += "/help - Show this help message\n";
  helpMsg += "/history - Your recent problem history\n\n";
  helpMsg += "*📊 Analytics Commands:*\n";
  helpMsg += "/stats - Detailed solving statistics\n";
  helpMsg += "/achievements - View your achievements\n\n";
  helpMsg += "*🏆 Contest & Goals:*\n";
  helpMsg += "/contest - Upcoming contests\n";
  helpMsg += "/goal <number> - Set daily goal\n";
  helpMsg += "/challenge - Daily challenge\n\n";
  helpMsg += "*🔍 Exploration:*\n";
  helpMsg += "/browse - Browse problems interactively\n";
  helpMsg += "/compare - Compare with friends (coming soon)\n\n";
  helpMsg += "*💡 Pro Tips:*\n";
  helpMsg += "• Use buttons for quick navigation\n";
  helpMsg += "• Set daily goals for consistency\n";
  helpMsg += "• Join daily challenges for motivation\n";
  helpMsg += "• Check /stats to track progress\n";

  const keyboard = createKeyboard([
    [{ text: "🎯 Start Solving", callback_data: "mode_rating" }],
    [{ text: "📊 View Stats", callback_data: "show_stats" }],
    [{ text: "🏆 Daily Challenge", callback_data: "daily_challenge" }],
    [{ text: "🗓️ Upcoming Contests", callback_data: "upcoming_contests" }]
  ]);

  return sendMessage(chatId, helpMsg, botToken, keyboard, "Markdown");
}

async function showMainMenu(chatId, KV, botToken) {
  const user = await dbGetUser(chatId, KV);
  const history = await dbGetAllHistory(chatId, KV);
  const solvedCount = (history || []).length;

  let msg = "🤖 *Codeforces Bot - Main Menu*\n\n";
  msg += `✅ Problems Solved: *${solvedCount}*\n`;

  const goalRaw = await KV.get(`goal:${chatId}`);
  if (goalRaw) {
    const goal = JSON.parse(goalRaw);
    msg += `🎯 Daily Goal: *${goal.current || 0}/${goal.target || 0}*\n`;
  }

  msg += "\nChoose an option below:";

  const keyboard = createKeyboard([
    [
      { text: "🎯 By Rating", callback_data: "mode_rating" },
      { text: "🏷️ By Tag", callback_data: "mode_tag" }
    ],
    [
      { text: "🔤 By Index", callback_data: "mode_index" },
      { text: "⭐ Rating+Tag", callback_data: "mode_rating_tag" }
    ],
    [
      { text: "📊 Statistics", callback_data: "show_stats" },
      { text: "🏆 Achievements", callback_data: "show_achievements" }
    ],
    [
      { text: "🎲 Daily Challenge", callback_data: "daily_challenge" },
      { text: "🗓️ Contests", callback_data: "upcoming_contests" }
    ],
    [
      { text: "🔍 Browse", callback_data: "browse_0" },
      { text: "🎯 Set Goal", callback_data: "set_goal_menu" }
    ],
    [{ text: "ℹ️ Help", callback_data: "show_help" }]
  ]);

  return sendMessage(chatId, msg, botToken, keyboard, "Markdown");
}


async function handleStart(chatId, KV, botToken) {
  await dbUpsertUser(chatId, {
      step: null,
      mode: null,
      rating: null,
      tag: null,
      index_letter: null,
      count: null,
      joined_date: new Date().toISOString()
  }, KV);
  

  await trackActiveUser(chatId, KV);
  
  return showMainMenu(chatId, KV, botToken);
}

// Get fresh problems (used by callbacks)
async function getNewProblems(chatId, KV, botToken) {
  try {
    const problems = await fetchCFProblems();
    if (!problems || problems.length === 0) {
      return sendMessage(chatId, "⚠️ Codeforces API unavailable. Try again later.", botToken);
    }

    const easy = filterProblems(problems, 'rating', 800, null, null, 1);
    const medium = filterProblems(problems, 'rating', 1200, null, null, 1);
    const hard = filterProblems(problems, 'rating', 1600, null, null, 1);
    const selected = [...easy, ...medium, ...hard].filter(Boolean);

    if (selected.length === 0) {
      return sendMessage(chatId, "⚠️ Couldn’t find new problems right now.", botToken);
    }

    let msg = "🎯 *Fresh Problem Set for You*\n\n";
    selected.forEach((p, idx) => {
      const link = `https://codeforces.com/problemset/problem/${p.contestId}/${p.index}`;
      msg += `${idx + 1}. [${p.name}](${link})\n`;
      msg += `   Rating: ${p.rating || '?'}⭐ | ${getDifficultyText(p.rating)}\n\n`;
    });
    msg += "💡 Try solving these to boost your skills!";

    return sendMessage(chatId, msg, botToken, null, "Markdown");
  } catch (err) {
    console.error('getNewProblems error', err);
    return sendMessage(chatId, "❌ Failed to fetch new problems.", botToken);
  }
}

async function showChallengeStats(chatId, KV, botToken) {
  try {
    const today = getCurrentDateKey();
    const data = await KV.get(`challenge:${today}`);
    if (!data) return sendMessage(chatId, "⚠️ No active challenge found for today.", botToken);
    const challenge = JSON.parse(data);
    const participants = Object.keys(challenge.participants || {});
    if (participants.length === 0) return sendMessage(chatId, "📊 No one has joined today’s challenge yet!", botToken);

    let completedCount = 0;
    for (const id in challenge.participants) {
      if (challenge.participants[id].completed) completedCount++;
    }

    const msg =
      `📈 *Today's Challenge Stats*\n\n` +
      `👥 Total Participants: ${participants.length}\n` +
      `🏆 Completed: ${completedCount}\n` +
      `🔥 Completion Rate: ${((completedCount / participants.length) * 100).toFixed(1)}%\n\n` +
      `Keep solving to climb the leaderboard! 💪`;

    return sendMessage(chatId, msg, botToken, null, "Markdown");
  } catch (err) {
    console.error('showChallengeStats error', err);
    return sendMessage(chatId, "❌ Failed to fetch challenge stats.", botToken);
  }
}


async function handleCallback(callbackData, chatId, KV, botToken) {
  console.log(`Handling callback: ${callbackData} for chat ${chatId}`);

  if (callbackData.startsWith('mode_')) {
    const mode = callbackData.split('_')[1];
    await dbUpsertUser(chatId, { mode, step: null }, KV);

    if (mode === 'rating') {
      await dbUpsertUser(chatId, { step: 'await_rating' }, KV);
      return sendMessage(chatId, "Enter rating (e.g., 1200):", botToken);
    } else if (mode === 'tag') {
      await dbUpsertUser(chatId, { step: 'await_tag' }, KV);
      return sendMessage(chatId, "Enter tag (e.g., dp, greedy, math):", botToken);
    } else if (mode === 'index') {
      await dbUpsertUser(chatId, { step: 'await_index' }, KV);
      return sendMessage(chatId, "Enter index letter (e.g., A, B, C):", botToken);
    } else if (mode === 'rating_tag') {
      await dbUpsertUser(chatId, { step: 'await_rating_tag_rating' }, KV);
      return sendMessage(chatId, "Enter rating first (e.g., 1300):", botToken);
    }
  } else if (callbackData === 'show_stats') {
    return getUserStats(chatId, KV, botToken);
  } else if (callbackData === 'show_achievements') {
    return showAchievements(chatId, KV, botToken);
  } else if (callbackData === 'upcoming_contests') {
    return getUpcomingContests(chatId, botToken);
  } else if (callbackData === 'daily_challenge') {
    return startDailyChallenge(chatId, KV, botToken);
  } else if (callbackData === 'challenge_stats' || callbackData === 'show_challenge_stats') {
    return showChallengeStats(chatId, KV, botToken);
  } else if (callbackData === 'get_new_problems' || callbackData === 'get_new_problems') {
    return getNewProblems(chatId, KV, botToken);
  } else if (callbackData === 'show_help') {
    return showHelp(chatId, botToken);
  } else if (callbackData === 'main_menu') {
    return showMainMenu(chatId, KV, botToken);
  } else if (callbackData.startsWith('browse_')) {
    const page = parseInt(callbackData.split('_')[1], 10) || 0;
    return browseProblems(chatId, page, KV, botToken);
  } else if (callbackData === 'set_goal_menu') {
    const keyboard = createKeyboard([
      [{ text: "1 Problem", callback_data: "set_goal_1" }],
      [{ text: "3 Problems", callback_data: "set_goal_3" }],
      [{ text: "5 Problems", callback_data: "set_goal_5" }],
      [{ text: "Custom Goal", callback_data: "set_goal_custom" }]
    ]);
    return sendMessage(chatId, "🎯 Choose your daily goal:", botToken, keyboard);
  } else if (callbackData.startsWith('set_goal_')) {
    const count = callbackData.split('_')[2];
    if (count === 'custom') {
      await dbUpsertUser(chatId, { step: 'await_goal' }, KV);
      return sendMessage(chatId, "Enter your daily goal (number of problems):", botToken);
    } else {
      return setDailyGoal(chatId, count, KV, botToken);
    }
  } else if (callbackData === 'join_challenge') {
    const today = getCurrentDateKey();
    const challengeKey = `challenge:${today}`;
    const raw = await KV.get(challengeKey);
    if (!raw) return sendMessage(chatId, "⚠️ No active challenge today.", botToken);
    const challenge = JSON.parse(raw);
    if (!challenge.participants) challenge.participants = {};
    challenge.participants[chatId] = { joined: new Date().toISOString(), solved: [], completed: false };
    await KV.put(challengeKey, JSON.stringify(challenge));
    return sendMessage(chatId, "🎉 You've joined the daily challenge! Good luck!", botToken);
  } else if (callbackData.startsWith('problem_')) {
    // Format: problem_<contestId>_<index>
    const parts = callbackData.split('_');
    if (parts.length >= 3) {
      const contestId = parts[1];
      const index = parts.slice(2).join('_'); // indexes like "A", "B1" etc
      const link = `https://codeforces.com/problemset/problem/${contestId}/${index}`;
      return sendMessage(chatId, `🔗 Problem link: ${link}`, botToken);
    }
  }
else if (callbackData === 'start_todays_problems') {
  await sendMessage(chatId, "🎯 Great! You've started today's problems. Good luck! 🚀", botToken);
  return sendTodaysProblems(chatId, KV, botToken); // Send problems again
}
else if (callbackData === 'refresh_todays_problems') {
  return sendTodaysProblems(chatId, KV, botToken, true);
}

  return sendMessage(chatId, "Unknown command. Use /help for available commands.", botToken);
}

// Text message handler
async function handleTextMessage(text, chatId, KV, botToken) {
  console.log(`Handling text from ${chatId}:`, text);
  if (text === '/today' || text === '/daily' || text === '/todaysproblems') {
    console.log(`Received /today (or alias) from ${chatId}. KV present: ${!!KV}`);
  }
  const user = await dbGetUser(chatId, KV);

  if (!user) {
    console.log(`User ${chatId} not found in KV, calling handleStart`);
    return handleStart(chatId, KV, botToken);
  }

  const step = user.step;
  const mode = user.mode;

  if (text === '/start') return handleStart(chatId, KV, botToken);
  if (text === '/help') return showHelp(chatId, botToken);
  if (text === '/stats') return getUserStats(chatId, KV, botToken);
  if (text === '/history') {
    const history = await dbGetHistory(chatId, 10, KV);
    if (!history || history.length === 0) return sendMessage(chatId, "No history yet. Start solving problems!", botToken);
    let msg = "🕓 *Recent Problems:*\n\n";
    history.forEach((item, idx) => {
      const link = `https://codeforces.com/problemset/problem/${item.contestId}/${item.problem_index}`;
      const date = new Date(item.ts).toLocaleDateString();
      msg += `${idx + 1}. [${item.name}](${link})\n   Rating: ${item.rating || '?'} | Date: ${date}\n\n`;
    });
    return sendMessage(chatId, msg, botToken, null, "Markdown");
  }
  if (text === '/contest') return getUpcomingContests(chatId, botToken);
  if (text.startsWith('/goal')) {
    const parts = text.split(' ');
    if (parts.length === 2 && /^\d+$/.test(parts[1])) {
      return setDailyGoal(chatId, parts[1], KV, botToken);
    } else {
      return checkGoalProgress(chatId, KV, botToken);
    }
  }


 if (text === '/today' || text === '/daily' || text === '/todaysproblems') {
  return sendTodaysProblems(chatId, KV, botToken);
}
  if (text === '/challenge') return startDailyChallenge(chatId, KV, botToken);
  if (text === '/achievements') return showAchievements(chatId, KV, botToken);
  if (text === '/browse') return browseProblems(chatId, 0, KV, botToken);
  if (text === '/compare') return sendMessage(chatId, "🔜 Friend comparison feature coming soon! Use /stats for now.", botToken);


  if (step === 'await_rating') {
    if (/^\d+$/.test(text)) {
      await dbUpsertUser(chatId, { rating: parseInt(text, 10), step: 'await_count' }, KV);
      return sendMessage(chatId, "Enter number of problems (max 10):", botToken);
    } else {
      return sendMessage(chatId, "Please enter a valid rating.", botToken);
    }
  } else if (step === 'await_tag') {
    await dbUpsertUser(chatId, { tag: text.toLowerCase(), step: 'await_count' }, KV);
    return sendMessage(chatId, "Enter number of problems (max 10):", botToken);
  } else if (step === 'await_index') {
    await dbUpsertUser(chatId, { index_letter: text.toUpperCase(), step: 'await_count' }, KV);
    return sendMessage(chatId, "Enter number of problems (max 10):", botToken);
  } else if (step === 'await_rating_tag_rating') {
    if (/^\d+$/.test(text)) {
      await dbUpsertUser(chatId, { rating: parseInt(text, 10), step: 'await_rating_tag_tag' }, KV);
      return sendMessage(chatId, "Now enter tag (e.g., dp, math, graphs):", botToken);
    } else {
      return sendMessage(chatId, "Please enter a numeric rating.", botToken);
    }
  } else if (step === 'await_rating_tag_tag') {
    await dbUpsertUser(chatId, { tag: text.toLowerCase(), step: 'await_count' }, KV);
    return sendMessage(chatId, "Enter number of problems (max 10):", botToken);
  } else if (step === 'await_count') {
    if (/^\d+$/.test(text)) {
      const count = Math.min(10, Math.max(1, parseInt(text, 10)));

      const userFresh = await dbGetUser(chatId, KV);
      const problems = await fetchCFProblems();
      const filtered = filterProblems(problems, userFresh.mode, userFresh.rating, userFresh.tag, userFresh.index_letter, count);

      await sendProblems(chatId, filtered, KV, botToken);


      await dbUpsertUser(chatId, { step: null, mode: null, rating: null, tag: null, index_letter: null, count: null }, KV);
      return;
    } else {
      return sendMessage(chatId, "Please enter a valid number.", botToken);
    }
  } else if (step === 'await_goal') {
    if (/^\d+$/.test(text)) {
      await dbUpsertUser(chatId, { step: null }, KV);
      return setDailyGoal(chatId, text, KV, botToken);
    } else {
      return sendMessage(chatId, "Please enter a valid number for your goal.", botToken);
    }
  }


  return showMainMenu(chatId, KV, botToken);
}


export default {
  async fetch(request, env, ctx) {
    console.log('Received request:', request.method, request.url);

    if (request.method === 'GET') {
      return new Response(
        '🚀 Codeforces Bot running on Cloudflare Workers!\n\nFeatures:\n✅ Problem Recommendations\n📊 Statistics & Analytics\n🏆 Achievements System\n🎯 Daily Goals & Challenges\n🗓️ Contest Reminders\n🔍 Interactive Browsing',
        { status: 200 }
      );
    }


    try {
      const data = await request.json();

      if (!env.BOT_TOKEN) {
        console.error('BOT_TOKEN is not set in environment');
        return new Response(JSON.stringify({ ok: false, error: 'Bot token not configured' }), { status: 500, headers: { 'Content-Type': 'application/json' } });
      }

      if (!env.KV) {
        console.warn('Warning: KV binding "KV" is not provided in env. DB operations will fail.');
      }


      const KV = env.KV || inMemoryKV;
      if (!env.KV) console.warn('No KV binding provided; using in-memory fallback (non-persistent)');

      // Callback query handling
      if (data.callback_query) {
        const cb = data.callback_query;
        const chatId = cb.message?.chat?.id || cb.from.id;
        const action = cb.data;
        try {
          await handleCallback(action, chatId, KV, env.BOT_TOKEN);
        } catch (err) {
          console.error('handleCallback error', err);
          try { await sendMessage(chatId, '❌ Error processing your action. Please try again later.', env.BOT_TOKEN); } catch(e){/* ignore */}
        }
        return new Response(JSON.stringify({ ok: true }), { headers: { 'Content-Type': 'application/json' } });
      }

      if (data.message) {
        const msg = data.message;
        const chatId = msg.chat.id;
        const text = (msg.text || '').trim();
        try {
          await handleTextMessage(text, chatId, KV, env.BOT_TOKEN);
        } catch (err) {
          console.error('handleTextMessage error', err);
          try { await sendMessage(chatId, '❌ Internal error handling your message. Please try again later.', env.BOT_TOKEN); } catch(e){/* ignore */}
        }
        return new Response(JSON.stringify({ ok: true }), { headers: { 'Content-Type': 'application/json' } });
      }

      return new Response(JSON.stringify({ ok: true }), { headers: { 'Content-Type': 'application/json' } });
    } catch (err) {
      console.error('Error processing request', err);
      return new Response(JSON.stringify({ ok: false, error: 'Internal server error' }), { status: 500, headers: { 'Content-Type': 'application/json' } });
    }
  }
};