PointTracker/server.js

/*
  server.js

  Node/Express + web-push sample.
  - Timer logic: 15 min usage => ring => optional 2 min => ignore or finish up
  - Weekly reset for base arrays (soloUsed, togetherUsed)
  - Push Subscriptions in memory
  - Serves React build from "client/build"

  Setup Steps:
  1) npm install express cors path web-push
  2) Generate VAPID keys: "npx web-push generate-vapid-keys"
  3) Replace placeholders below
  4) "npm run build" in your client folder, so "client/build" exists
  5) node server.js => listens on port 4000
*/

const express = require('express');
const cors = require('cors');
const path = require('path');
const webPush = require('web-push');

// -- REPLACE WITH YOUR ACTUAL VAPID KEYS! --
const VAPID_PUBLIC_KEY = 'BCn73fh1YZV3rFbK9H234he4nNWhhEKnYiQ_UZ1U0nxR6Q6cKvTG6v05Uyq7KXh0FxwjPOV3jHR3DPLqF5Lyfm4';
const VAPID_PRIVATE_KEY = 'ysmxNfkY_V0CVBwL0UJb1BeYl0dgrF4vw09cNWfFW-M';

// Configure web-push
webPush.setVapidDetails(
    'mailto:youremail@example.com',
    VAPID_PUBLIC_KEY,
    VAPID_PRIVATE_KEY
);

const app = express();
app.use(cors());
app.use(express.json());

// In-memory push subscription store
// For a real app, store in DB
let pushSubscriptions = [];

/* ------------------------------------------------------------------
   TIMER / WEEKLY RESET LOGIC
------------------------------------------------------------------ */
const SOLO_BASE_COUNT = 5;
const TOGETHER_BASE_COUNT = 5;

let soloUsed = Array(SOLO_BASE_COUNT).fill(false);
let togetherUsed = Array(TOGETHER_BASE_COUNT).fill(false);

let logs = [];
let lastReset = null;

const FIFTEEN_MINUTES = 15 * 60 * 1000;
const TWO_MINUTES = 2 * 60 * 1000;

let timerRunning = false;
let timeRemaining = 0;
let isPaused = false;
let activeUsage = null; // e.g. { category:'solo'|'together', index:number }
let ringing = false;

// Weekly reset to set all usage to false if new Monday
function getMonday(d = new Date()) {
    const day = d.getDay(); // 0=Sun,1=Mon,...
    const diff = d.getDate() - day + (day === 0 ? -6 : 1);
    d.setDate(diff);
    return d.toISOString().split('T')[0];
}
function resetIfNewWeek() {
    const currentMonday = getMonday();
    if (!lastReset || lastReset !== currentMonday) {
        soloUsed = soloUsed.map(() => false);
        togetherUsed = togetherUsed.map(() => false);
        lastReset = currentMonday;
        console.log('[Server] Weekly reset triggered on Monday =>', currentMonday);
    }
}

// Timer loop => decrement
setInterval(() => {
    if (timerRunning && !isPaused && timeRemaining > 0) {
        timeRemaining -= 1000;
        if (timeRemaining <= 0) {
            // Timer ended
            timerRunning = false;
            timeRemaining = 0;
            // If we ended a 15-min block => ring
            if (!ringing) {
                ringing = true;
                console.log('[Server] 15-minute ended => ringing=true');
                // Send push notification to all
                sendPushToAll('Timer Ended!', 'Time is up! Tap for details.');
            }
        }
    }
}, 1000);

// Send push to all subscribed
function sendPushToAll(title, body) {
    console.log('[Server] Sending push to', pushSubscriptions.length, 'subscribers');
    const payload = JSON.stringify({ title, body });

    pushSubscriptions.forEach((sub) => {
        webPush.sendNotification(sub, payload).catch((err) => {
            console.error('[Push Error]', err);
        });
    });
}

// Middleware => check weekly reset on each request
app.use((req, res, next) => {
    resetIfNewWeek();
    next();
});

/* ------------------------------------------------------------------
   API ROUTES
------------------------------------------------------------------ */

// GET /state => return current usage/timer
app.get('/state', (req, res) => {
    res.json({
        soloUsed,
        togetherUsed,
        logs,
        lastReset,
        timerRunning,
        timeRemaining,
        isPaused,
        activeUsage,
        ringing,
    });
});

// POST /use-bubble => single bubble => 15 min
app.post('/use-bubble', (req, res) => {
    if (timerRunning && !ringing && timeRemaining > 0) {
        return res.status(400).json({ error: 'A timer is already active.' });
    }
    // If currently ringing => ignore
    if (ringing) {
        timerRunning = false;
        timeRemaining = 0;
        isPaused = false;
        activeUsage = null;
        ringing = false;
        console.log('[Server] Timer was ringing => auto-ignored => new usage starts.');
    }
    const { category, index } = req.body;
    let arr = category === 'solo' ? soloUsed : category === 'together' ? togetherUsed : null;
    if (!arr) return res.status(400).json({ error: 'Invalid category' });
    if (index < 0 || index >= arr.length) return res.status(400).json({ error: 'Index out of range' });
    if (arr[index]) return res.status(400).json({ error: 'That bubble is already used.' });

    arr[index] = true;
    logs.push({ type: category, index, usedAt: new Date().toISOString() });

    timerRunning = true;
    timeRemaining = FIFTEEN_MINUTES;
    isPaused = false;
    activeUsage = { category, index };
    res.json({ success: true });
});

// check password
app.post('/check-password', (req, res) => {
    const { password } = req.body;
    if (password !== 'mySecretPassword') {
        return res.status(403).json({ error: 'Incorrect password.' });
    }
    res.json({ success: true });
});

// add-points => append new false items
app.post('/add-points', (req, res) => {
    const { password, category, amount } = req.body;
    if (password !== 'mySecretPassword') {
        return res.status(403).json({ error: 'Wrong password' });
    }
    if (!['solo', 'together'].includes(category)) {
        return res.status(400).json({ error: 'Invalid category' });
    }
    if (typeof amount !== 'number' || amount < 1 || amount > 4) {
        return res.status(400).json({ error: 'Amount must be 1..4' });
    }
    if (category === 'solo') {
        for (let i = 0; i < amount; i++) {
            soloUsed.push(false);
        }
        console.log(`[Server] +${amount} appended to soloUsed => length now`, soloUsed.length);
    } else {
        for (let i = 0; i < amount; i++) {
            togetherUsed.push(false);
        }
        console.log(`[Server] +${amount} appended to togetherUsed => length now`, togetherUsed.length);
    }
    res.json({ success: true });
});

// Pause/Resume
app.post('/pause-resume', (req, res) => {
    if (!timerRunning && timeRemaining <= 0) {
        return res.status(400).json({ error: 'No active timer.' });
    }
    if (ringing) {
        return res.status(400).json({ error: 'Timer is ringing, cannot pause.' });
    }
    isPaused = !isPaused;
    console.log('[Server] Timer pause =>', isPaused);
    res.json({ success: true, isPaused });
});

// finish-up => only if ringing
app.post('/finish-up', (req, res) => {
    if (!ringing) {
        return res.status(400).json({ error: 'Not currently ringing. 2-min only after 15-min ends.' });
    }
    timerRunning = true;
    timeRemaining = TWO_MINUTES;
    isPaused = false;
    ringing = false;
    console.log('[Server] 2-min finish-up started');
    res.json({ success: true });
});

// cancel-finish-up
app.post('/cancel-finish-up', (req, res) => {
    if (!timerRunning || ringing || timeRemaining > TWO_MINUTES) {
        return res.status(400).json({ error: 'Not currently in finish-up timer.' });
    }
    timerRunning = false;
    timeRemaining = 0;
    isPaused = false;
    activeUsage = null;
    console.log('[Server] 2-min finish-up canceled');
    res.json({ success: true });
});

// ignore-ring
app.post('/ignore-ring', (req, res) => {
    if (!ringing) {
        return res.status(400).json({ error: 'Not currently ringing.' });
    }
    timerRunning = false;
    timeRemaining = 0;
    isPaused = false;
    activeUsage = null;
    ringing = false;
    console.log('[Server] Ring ignored => no 2-min started');
    res.json({ success: true });
});

// use-movie
app.post('/use-movie', (req, res) => {
    const { chosenPoints } = req.body;
    if (!Array.isArray(chosenPoints) || chosenPoints.length !== 4) {
        return res.status(400).json({ error: 'Must pick exactly 4 points' });
    }
    for (const p of chosenPoints) {
        let arr = p.category==='solo'?soloUsed: p.category==='together'?togetherUsed:null;
        if (!arr) return res.status(400).json({ error:'Invalid category in chosen points.' });
        if (arr[p.index] === true) return res.status(400).json({ error:'A chosen point is already used.' });
    }
    for (const p of chosenPoints) {
        let arr = p.category==='solo'?soloUsed: togetherUsed;
        arr[p.index] = true;
    }
    logs.push({ type:'movie', index:null, usedAt:new Date().toISOString() });
    res.json({ success: true });
});

// use-episode
app.post('/use-episode', (req, res) => {
    const { chosenPoints } = req.body;
    if (!Array.isArray(chosenPoints) || chosenPoints.length !== 2) {
        return res.status(400).json({ error: 'Must pick exactly 2 points' });
    }
    for (const p of chosenPoints) {
        let arr = p.category==='solo'?soloUsed: p.category==='together'?togetherUsed:null;
        if (!arr) return res.status(400).json({ error:'Invalid category in chosen points.' });
        if (arr[p.index]) return res.status(400).json({ error:'A chosen point is already used.' });
    }
    for (const p of chosenPoints) {
        let arr = p.category==='solo'?soloUsed: togetherUsed;
        arr[p.index]=true;
    }
    logs.push({ type:'episode', index:null, usedAt:new Date().toISOString()});
    res.json({ success:true });
});

/* ------------------------------------------------------------------
   PUSH NOTIFICATION ROUTES
------------------------------------------------------------------ */
// POST /subscribe => client sends { subscription }
app.post('/subscribe', (req, res)=>{
    const sub = req.body.subscription;
    // Check if already in pushSubscriptions?
    pushSubscriptions.push(sub);
    console.log('[Server] New subscription => total', pushSubscriptions.length);
    res.json({ success:true });
});

// POST /unsubscribe => remove from array
app.post('/unsubscribe', (req, res)=>{
    const sub = req.body.subscription;
    pushSubscriptions = pushSubscriptions.filter(s => s.endpoint!==sub.endpoint);
    console.log('[Server] Unsubscribe => total', pushSubscriptions.length);
    res.json({ success:true });
});

/* ------------------------------------------------------------------
   ADMIN
------------------------------------------------------------------ */
app.post('/admin/login',(req,res)=>{
    const { password }=req.body;
    if(password!=='adminSecret'){
        return res.status(403).json({ error:'Wrong admin password' });
    }
    res.json({ success:true });
});

app.post('/admin/clear-logs',(req,res)=>{
    logs=[];
    console.log('[Server] Logs cleared by admin');
    res.json({ success:true });
});

app.post('/admin/reset-usage',(req,res)=>{
    soloUsed=soloUsed.map(()=>false);
    togetherUsed=togetherUsed.map(()=>false);
    console.log('[Server] Usage reset by admin => all set false');
    res.json({ success:true });
});

app.post('/admin/remove-all-earned',(req,res)=>{
    // revert arrays to length 5
    soloUsed.splice(5);
    togetherUsed.splice(5);
    console.log('[Server] All earned points removed => each array length=5');
    res.json({ success:true });
});

// For demonstration, add/remove 1 from soloUsed
app.post('/admin/add-earned',(req,res)=>{
    soloUsed.push(false);
    console.log('[Server] Admin +1 to soloUsed => length', soloUsed.length);
    res.json({ success:true });
});
app.post('/admin/remove-earned',(req,res)=>{
    if(soloUsed.length<=0){
        return res.status(400).json({ error:'No bubble to remove in soloUsed' });
    }
    soloUsed.pop();
    console.log('[Server] Admin removed last => length', soloUsed.length);
    res.json({ success:true });
});

app.post('/admin/clear-timer',(req,res)=>{
    timerRunning=false;
    timeRemaining=0;
    isPaused=false;
    activeUsage=null;
    ringing=false;
    console.log('[Server] Timer cleared by admin');
    res.json({ success:true });
});

app.post('/admin/expire-timer',(req,res)=>{
    if(timeRemaining>1){
        timeRemaining=1;
        console.log('[Server] Timer => set to 1s => about to end');
    }
    res.json({ success:true });
});

/* ------------------------------------------------------------------
   SERVE REACT BUILD
------------------------------------------------------------------ */
app.use(express.static(path.join(__dirname,'build')));

app.get('*',(req,res)=>{
    res.sendFile(path.join(__dirname,'build','index.html'));
});

/* ------------------------------------------------------------------
   START SERVER
------------------------------------------------------------------ */
const PORT = 4000;
app.listen(PORT, ()=>{
    console.log(`[Server] Listening on port ${PORT}`);
});