shared.js

// shared.js - ShareSTI PHP + jQuery Version
// All data is stored on server via api.php

// =========================
// Configuration
// =========================
const API_URL = 'api.php';
const SESSION_KEY = 'shareSTI.sessionToken';

// =========================
// Toast Notification System
// =========================

function showToast(title, message, type = 'success', duration = 4000) {
  // Create container if it doesn't exist
  let container = document.querySelector('.toast-container');
  if (!container) {
    container = document.createElement('div');
    container.className = 'toast-container';
    document.body.appendChild(container);
  }
  
  // Icons for different types
  const icons = {
    success: '✅',
    error: '❌',
    warning: '⚠️',
    info: 'ℹ️'
  };
  
  // Create toast element
  const toast = document.createElement('div');
  toast.className = `toast toast-${type}`;
  toast.innerHTML = `
    <span class="toast-icon">${icons[type] || icons.success}</span>
    <div class="toast-content">
      <div class="toast-title">${title}</div>
      <div class="toast-message">${message}</div>
    </div>
    <button class="toast-close" onclick="this.parentElement.classList.add('toast-exit'); setTimeout(() => this.parentElement.remove(), 300);">✕</button>
  `;
  
  container.appendChild(toast);
  
  // Auto remove after duration
  setTimeout(() => {
    toast.classList.add('toast-exit');
    setTimeout(() => toast.remove(), 300);
  }, duration);
  
  return toast;
}

// =========================
// jQuery API Wrapper
// =========================

function apiCall(action, data = {}) {
  return new Promise((resolve, reject) => {
    $.ajax({
      url: API_URL,
      method: 'POST',
      contentType: 'application/json',
      data: JSON.stringify({ action, ...data }),
      success: function(response) {
        resolve(response);
      },
      error: function(xhr, status, error) {
        console.error('API Error:', error);
        try {
          const response = JSON.parse(xhr.responseText);
          resolve(response);
        } catch (e) {
          resolve({ error: 'Server error: ' + error });
        }
      }
    });
  });
}

// =========================
// Helper Functions
// =========================

function escapeHtml(str) {
  if (!str) return '';
  return String(str)
    .replace(/&/g, '&amp;')
    .replace(/</g, '&lt;')
    .replace(/>/g, '&gt;')
    .replace(/"/g, '&quot;')
    .replace(/'/g, '&#39;');
}

function formatDate(timestamp) {
  if (!timestamp) return '';
  const date = new Date(timestamp);
  const now = new Date();
  const diff = now - date;
  
  if (diff < 60000) return 'Just now';
  if (diff < 3600000) return Math.floor(diff / 60000) + 'm ago';
  if (diff < 86400000) return Math.floor(diff / 3600000) + 'h ago';
  if (diff < 604800000) return Math.floor(diff / 86400000) + 'd ago';
  
  return date.toLocaleDateString();
}

function formatTime(timestamp) {
  if (!timestamp) return '';
  const date = new Date(timestamp);
  const now = new Date();
  const isToday = date.toDateString() === now.toDateString();
  const isTomorrow = new Date(now.getTime() + 86400000).toDateString() === date.toDateString();
  
  const timeStr = date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', hour12: true });
  
  if (isToday) return timeStr + ' today';
  if (isTomorrow) return timeStr + ' tomorrow';
  return timeStr + ' on ' + date.toLocaleDateString();
}

function getTimeRemaining(timestamp) {
  if (!timestamp) return '';
  const now = Date.now();
  const diff = timestamp - now;
  
  if (diff <= 0) return 'Expired';
  
  const minutes = Math.floor(diff / 60000);
  const hours = Math.floor(minutes / 60);
  const remainingMinutes = minutes % 60;
  
  if (hours > 0) {
    return `${hours}h ${remainingMinutes}m left`;
  }
  return `${minutes}m left`;
}

function isItemExpired(item) {
  return item.availableUntil && Date.now() > item.availableUntil && item.status === 'available';
}

function isItemExpiringSoon(item, thresholdMinutes = 30) {
  if (!item.availableUntil) return false;
  const now = Date.now();
  const timeUntilExpiry = item.availableUntil - now;
  return timeUntilExpiry > 0 && timeUntilExpiry <= thresholdMinutes * 60 * 1000;
}

function getCategoryIcon(category) {
  const icons = {
    supplies: '✏️',
    electronics: '📱',
    books: '📚',
    tools: '🔧',
    other: '📦'
  };
  return icons[category] || '📦';
}

// =========================
// Validation
// =========================

function validateEmail(email) {
  const regex = /^[a-zA-Z0-9._%+-]+@([a-zA-Z0-9-]+\.)?sti\.edu\.ph$/i;
  return regex.test(email);
}

function validateStudentId(studentId) {
  return /^\d{11}$/.test(studentId);
}

function validateSection(section) {
  return /^[A-Z]{2,5}-\d{3}$/i.test(section);
}

// =========================
// API Object
// =========================

const API = {
  // ============ AUTH ============
  
  async signup(userData) {
    const result = await apiCall('signup', userData);
    if (result.token) {
      localStorage.setItem(SESSION_KEY, result.token);
    }
    return result;
  },

  async login(email, password) {
    const result = await apiCall('login', { email, password });
    if (result.token) {
      localStorage.setItem(SESSION_KEY, result.token);
    }
    return result;
  },

  async logout() {
    const token = localStorage.getItem(SESSION_KEY);
    if (token) {
      await apiCall('logout', { token });
    }
    localStorage.removeItem(SESSION_KEY);
    return { success: true };
  },

  async getCurrentUser() {
    const token = localStorage.getItem(SESSION_KEY);
    if (!token) return null;
    
    const result = await apiCall('getCurrentUser', { token });
    if (result.error || !result.user) {
      localStorage.removeItem(SESSION_KEY);
      return null;
    }
    return result.user;
  },

  // ============ USERS ============
  
  async getAllUsers() {
    const result = await apiCall('getUsers');
    return result.users || [];
  },

  async getUserById(id) {
    const result = await apiCall('getUserById', { id });
    return result.user || null;
  },

  async getUserCount() {
    const result = await apiCall('getUserCount');
    return result.count || 0;
  },

  // ============ ITEMS ============
  
  async getAllItems() {
    const result = await apiCall('getItems');
    return result.items || [];
  },

  async createItem(itemData) {
    const token = localStorage.getItem(SESSION_KEY);
    return await apiCall('createItem', { token, ...itemData });
  },

  async updateItem(id, updates) {
    return await apiCall('updateItem', { id, ...updates });
  },

  async deleteItem(id) {
    return await apiCall('deleteItem', { id });
  },

  // ============ REQUESTS ============
  
  async getAllRequests() {
    const result = await apiCall('getRequests');
    return result.requests || [];
  },

  async createRequest(requestData) {
    const token = localStorage.getItem(SESSION_KEY);
    return await apiCall('createRequest', { token, ...requestData });
  },

  async updateRequest(id, updates) {
    return await apiCall('updateRequest', { id, ...updates });
  },

  // ============ BORROW REQUESTS ============
  
  async getAllBorrowRequests() {
    const result = await apiCall('getBorrowRequests');
    return result.borrowRequests || [];
  },

  async createBorrowRequest(requestData) {
    const token = localStorage.getItem(SESSION_KEY);
    return await apiCall('createBorrowRequest', { token, ...requestData });
  },

  async updateBorrowRequest(id, updates) {
    return await apiCall('updateBorrowRequest', { id, ...updates });
  },

  async deleteBorrowRequest(id) {
    return await apiCall('deleteBorrowRequest', { id });
  },

  // ============ NOTIFICATIONS ============
  
  async getNotifications() {
    const token = localStorage.getItem(SESSION_KEY);
    if (!token) return [];
    const result = await apiCall('getNotifications', { token });
    return result.notifications || [];
  },

  async createNotification(notifData) {
    return await apiCall('createNotification', notifData);
  },

  async markNotificationRead(id) {
    return await apiCall('markNotificationRead', { id });
  },

  async clearNotifications() {
    const token = localStorage.getItem(SESSION_KEY);
    return await apiCall('clearNotifications', { token });
  },

  // ============ HISTORY ============
  
  async getHistory() {
    const token = localStorage.getItem(SESSION_KEY);
    if (!token) return [];
    const result = await apiCall('getHistory', { token });
    return result.history || [];
  },

  async addToHistory(record) {
    const token = localStorage.getItem(SESSION_KEY);
    return await apiCall('addToHistory', { token, ...record });
  }
};

// =========================
// Data Caches & Helpers
// =========================

let usersCache = [];
let usersCacheTime = 0;
let itemsCache = [];
let requestsCache = [];
let borrowRequestsCache = [];

async function getUserById(id) {
  // Check cache first
  if (usersCache.length && Date.now() - usersCacheTime < 30000) {
    const user = usersCache.find(u => u && u.id === id);
    if (user) return user;
  }
  return await API.getUserById(id);
}

async function refreshUsersCache() {
  usersCache = await API.getAllUsers();
  usersCacheTime = Date.now();
  return usersCache;
}

async function refreshItemsCache() {
  itemsCache = await API.getAllItems();
  return itemsCache;
}

function getItemById(id) {
  return itemsCache.find(i => i && i.id === id) || null;
}

function getMyLentItems(userId) {
  return itemsCache.filter(i => i && i.ownerId === userId);
}

function getAllAvailableItems() {
  return itemsCache.filter(i => i && i.status === 'available');
}

function getActiveBorrowsForUser(userId) {
  return itemsCache.filter(i => i && i.currentBorrower === userId && i.status === 'borrowed');
}

async function refreshRequestsCache() {
  requestsCache = await API.getAllRequests();
  return requestsCache;
}

function getRequestById(id) {
  return requestsCache.find(r => r && r.id === id) || null;
}

function getRequestsForLender(lenderId) {
  return requestsCache.filter(r => r && r.lenderId === lenderId);
}

async function refreshBorrowRequestsCache() {
  borrowRequestsCache = await API.getAllBorrowRequests();
  return borrowRequestsCache;
}

function getBorrowRequestById(id) {
  return borrowRequestsCache.find(r => r && r.id === id) || null;
}

function getMyBorrowRequests(userId) {
  return borrowRequestsCache.filter(r => r && r.userId === userId);
}

function getAllBorrowRequests() {
  return borrowRequestsCache;
}

// =========================
// Initialize
// =========================
console.log('📚 ShareSTI - PHP + jQuery Version');
console.log('🌐 Data stored on server via api.php');

// Check if jQuery is loaded
if (typeof $ === 'undefined') {
  console.warn('⚠️ jQuery not loaded. Make sure to include jQuery before shared.js');
}