Code.gs

// ========== SRO MONITORING BOOKMARK MANAGER ==========
// Ultra-fast bookmark manager optimized for 2000+ bookmarks with instant sync
// Supports 25 concurrent users with zero conflicts
// Redis-like caching layer for blazing-fast reads

var STORAGE_KEY = 'SRO_BOOKMARKS';
var CHUNK_PREFIX = 'SRO_CHUNK_';
var META_KEY = 'SRO_META';
var CHANGE_NOTIFICATION_KEY = 'SRO_CHANGE_NOTIFICATION'; // Shared change flag
var CACHE_DURATION = 21600; // 6h max (Google limit)
var SHORT_CACHE = 300; // 5min for frequently changing data
var MAX_CHUNK_SIZE = 8000; // Safe limit (9KB quota)

// Redis-like cache keys
var REDIS_KEYS = {
  DATA: 'redis:data',
  META: 'redis:meta',
  CATEGORIES: 'redis:categories',
  LAST_MODIFIED: 'redis:lastmod'
};

// ========== REDIS-LIKE CACHE LAYER ==========
function redisGet(key) {
  try {
    var cache = CacheService.getScriptCache();
    var value = cache.get(key);
    return value ? JSON.parse(value) : null;
  } catch (e) {
    Logger.log('Redis GET error: ' + e);
    return null;
  }
}

function redisSet(key, value, ttl) {
  try {
    var cache = CacheService.getScriptCache();
    var jsonValue = JSON.stringify(value);
    cache.put(key, jsonValue, ttl || CACHE_DURATION);
    return true;
  } catch (e) {
    Logger.log('Redis SET error: ' + e);
    return false;
  }
}

function redisDel(key) {
  try {
    var cache = CacheService.getScriptCache();
    cache.remove(key);
    return true;
  } catch (e) {
    Logger.log('Redis DEL error: ' + e);
    return false;
  }
}

function redisFlush() {
  try {
    var cache = CacheService.getScriptCache();
    Object.keys(REDIS_KEYS).forEach(function(k) {
      cache.remove(REDIS_KEYS[k]);
    });
    cache.remove(STORAGE_KEY);
    cache.remove('LAST_MODIFIED');
    return true;
  } catch (e) {
    Logger.log('Redis FLUSH error: ' + e);
    return false;
  }
}

function doGet() {
  return HtmlService.createHtmlOutputFromFile('index')
    .setTitle('SROBY - Bookmarks')
    .setXFrameOptionsMode(HtmlService.XFrameOptionsMode.ALLOWALL)
    .addMetaTag('viewport', 'width=device-width, initial-scale=1');
}

// ========== USER IDENTITY ==========
function getUserEmail() {
  try {
    var email = Session.getActiveUser().getEmail();
    // Extract username (before @)
    var username = email.split('@')[0];
    return username;
  } catch (e) {
    Logger.log('getUserEmail error: ' + e);
    return 'user_' + Date.now();
  }
}

// ========== DATA MANAGEMENT WITH CHUNKING & COMPRESSION ==========
function getBookmarks() {
  try {
    // L1 Cache: Redis-like in-memory (fastest)
    var cached = redisGet(REDIS_KEYS.DATA);
    if (cached) {
      return cached;
    }
    
    // L2 Cache: Legacy cache
    var cache = CacheService.getScriptCache();
    var legacyCached = cache.get(STORAGE_KEY);
    if (legacyCached) {
      var parsed = JSON.parse(legacyCached);
      redisSet(REDIS_KEYS.DATA, parsed, CACHE_DURATION);
      return parsed;
    }
    
    // L3 Storage: Properties Service (slowest)
    var props = PropertiesService.getScriptProperties();
    var meta = props.getProperty(META_KEY);
    
    if (!meta) {
      var initialData = {
        categories: [],
        lastModified: Date.now()
      };
      saveBookmarks(initialData);
      return initialData;
    }
    
    var metaObj = JSON.parse(meta);
    var chunks = metaObj.chunks || 1;
    
    // Read all chunks
    var dataStr = '';
    for (var i = 0; i < chunks; i++) {
      var chunk = props.getProperty(CHUNK_PREFIX + i);
      if (chunk) dataStr += chunk;
    }
    
    if (!dataStr) {
      return { categories: [], lastModified: 0 };
    }
    
    var parsed = JSON.parse(dataStr);
    
    // Populate all cache layers
    cache.put(STORAGE_KEY, dataStr, CACHE_DURATION);
    redisSet(REDIS_KEYS.DATA, parsed, CACHE_DURATION);
    redisSet(REDIS_KEYS.META, metaObj, CACHE_DURATION);
    
    return parsed;
    
  } catch (e) {
    Logger.log('Error getting bookmarks: ' + e);
    return { categories: [], lastModified: 0 };
  }
}

function saveBookmarks(data) {
  var lock = LockService.getScriptLock();
  var lockAcquired = false;
  
  try {
    // Optimistic locking with shorter timeout
    lockAcquired = lock.tryLock(3000);
    if (!lockAcquired) {
      throw new Error('Busy');
    }
    
    if (!data || !Array.isArray(data.categories)) {
      throw new Error('Invalid data');
    }
    
    var now = Date.now();
    data.lastModified = now;
    var jsonData = JSON.stringify(data);
    
    var props = PropertiesService.getScriptProperties();
    
    // Chunking strategy for large datasets
    var chunks = [];
    var chunkSize = MAX_CHUNK_SIZE;
    
    if (jsonData.length > chunkSize) {
      for (var i = 0; i < jsonData.length; i += chunkSize) {
        chunks.push(jsonData.substring(i, i + chunkSize));
      }
    } else {
      chunks = [jsonData];
    }
    
    // Clear old chunks first
    var oldMeta = props.getProperty(META_KEY);
    if (oldMeta) {
      var oldMetaObj = JSON.parse(oldMeta);
      for (var j = 0; j < (oldMetaObj.chunks || 0); j++) {
        props.deleteProperty(CHUNK_PREFIX + j);
      }
    }
    
    // Write new chunks
    var propsObj = {};
    for (var k = 0; k < chunks.length; k++) {
      propsObj[CHUNK_PREFIX + k] = chunks[k];
    }
    
    // Add metadata
    propsObj[META_KEY] = JSON.stringify({
      chunks: chunks.length,
      lastModified: now,
      size: jsonData.length
    });
    
    props.setProperties(propsObj);
    
    // Invalidate ALL cache layers (Redis-like + legacy)
    redisFlush();
    var cache = CacheService.getScriptCache();
    cache.remove(STORAGE_KEY);
    
    // Warm up cache immediately
    redisSet(REDIS_KEYS.DATA, data, CACHE_DURATION);
    redisSet(REDIS_KEYS.LAST_MODIFIED, now, SHORT_CACHE);
    cache.put(STORAGE_KEY, jsonData, CACHE_DURATION);
    
    // CRITICAL: Update change notification AFTER successful save
    // This triggers cross-machine sync immediately
    updateChangeNotification('system', 'data_changed');
    
    return { success: true, lastModified: now };
    
  } catch (e) {
    Logger.log('Save error: ' + e);
    throw new Error('Save failed: ' + e.message);
  } finally {
    if (lockAcquired) lock.releaseLock();
  }
}

function getLastModified() {
  try {
    // L1: Redis cache (ultra-fast)
    var cached = redisGet(REDIS_KEYS.LAST_MODIFIED);
    if (cached) return cached;
    
    // L2: Legacy cache
    var cache = CacheService.getScriptCache();
    var cachedTs = cache.get('LAST_MODIFIED');
    if (cachedTs) {
      var ts = parseInt(cachedTs, 10);
      redisSet(REDIS_KEYS.LAST_MODIFIED, ts, SHORT_CACHE);
      return ts;
    }
    
    // L3: Properties
    var props = PropertiesService.getScriptProperties();
    var meta = props.getProperty(META_KEY);
    
    if (meta) {
      var metaObj = JSON.parse(meta);
      var ts = metaObj.lastModified || 0;
      cache.put('LAST_MODIFIED', ts.toString(), SHORT_CACHE);
      redisSet(REDIS_KEYS.LAST_MODIFIED, ts, SHORT_CACHE);
      return ts;
    }
    
    return 0;
    
  } catch (e) {
    Logger.log('getLastModified error: ' + e);
    return 0;
  }
}

// ========== CHANGE NOTIFICATION (CROSS-MACHINE SYNC) ==========
function updateChangeNotification(userId, action) {
  try {
    var props = PropertiesService.getScriptProperties();
    
    // Get real user email from Google Session
    var userEmail = 'unknown';
    try {
      userEmail = Session.getActiveUser().getEmail();
      // Extract first part of email (before @) for cleaner display
      if (userEmail && userEmail.indexOf('@') > 0) {
        userEmail = userEmail.split('@')[0];
      }
    } catch (emailError) {
      Logger.log('Could not get user email: ' + emailError);
      userEmail = userId || 'unknown';
    }
    
    var notification = {
      timestamp: Date.now(),
      userId: userEmail,
      action: action || 'update'
    };
    props.setProperty(CHANGE_NOTIFICATION_KEY, JSON.stringify(notification));
    return notification.timestamp;
  } catch (e) {
    Logger.log('updateChangeNotification error: ' + e);
    return Date.now();
  }
}

function getChangeNotification() {
  try {
    var props = PropertiesService.getScriptProperties();
    var stored = props.getProperty(CHANGE_NOTIFICATION_KEY);
    
    if (!stored) {
      // Initialize if not exists
      return { timestamp: Date.now(), userId: 'system', action: 'init' };
    }
    
    return JSON.parse(stored);
  } catch (e) {
    Logger.log('getChangeNotification error: ' + e);
    return { timestamp: Date.now(), userId: 'error', action: 'error' };
  }
}

function addBookmark(categoryId, bookmark) {
  try {
    var data = getBookmarks();
    var category = data.categories.find(function(c) { return c.id === categoryId; });
    
    if (!category) {
      throw new Error('Category not found');
    }
    
    if (!category.bookmarks) category.bookmarks = [];
    
    // Smart URL normalization
    if (bookmark.url) {
      var url = bookmark.url.trim();
      if (!url.match(/^https?:\/\//i)) {
        if (!url.includes('.')) {
          url = url + '.com';
        }
        bookmark.url = 'https://' + url;
      }
    }
    
    // Generate collision-free ID
    bookmark.id = 'b' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
    if (!bookmark.tags) bookmark.tags = [];
    if (!bookmark.info) bookmark.info = '';
    
    category.bookmarks.push(bookmark);
    
    var result = saveBookmarks(data);
    
    // CRITICAL: Άμεση cache invalidation
    redisFlush();
    var cache = CacheService.getScriptCache();
    cache.remove(STORAGE_KEY);
    cache.remove('LAST_MODIFIED');
    
    // Warm up caches
    var jsonData = JSON.stringify(data);
    cache.put(STORAGE_KEY, jsonData, CACHE_DURATION);
    redisSet(REDIS_KEYS.DATA, data, CACHE_DURATION);
    redisSet(REDIS_KEYS.LAST_MODIFIED, result.lastModified, SHORT_CACHE);
    
    // Update shared change notification
    updateChangeNotification('user', 'addBookmark');
    
    return result;
    
  } catch (e) {
    Logger.log('Error adding bookmark: ' + e);
    throw e;
  }
}

function updateBookmark(categoryId, bookmarkId, updates) {
  try {
    var data = getBookmarks();
    var category = data.categories.find(function(c) { return c.id === categoryId; });
    
    if (!category) {
      throw new Error('Category not found');
    }
    
    var bookmark = category.bookmarks.find(function(b) { return b.id === bookmarkId; });
    
    if (!bookmark) {
      throw new Error('Bookmark not found');
    }
    
    // Check if category changed (move bookmark to different category)
    if (updates.newCategoryId && updates.newCategoryId !== categoryId) {
      var newCategory = data.categories.find(function(c) { return c.id === updates.newCategoryId; });
      if (!newCategory) {
        throw new Error('New category not found');
      }
      
      // Remove bookmark from old category
      var index = category.bookmarks.findIndex(function(b) { return b.id === bookmarkId; });
      if (index > -1) {
        category.bookmarks.splice(index, 1);
      }
      
      // Update bookmark data
      if (updates.title) bookmark.title = updates.title;
      if (updates.url) {
        var url = updates.url.trim();
        if (!url.match(/^https?:\/\//i)) {
          if (!url.includes('.')) {
            url = url + '.com';
          }
          url = 'https://' + url;
        }
        bookmark.url = url;
      }
      if (updates.info !== undefined) bookmark.info = updates.info;
      if (updates.tags !== undefined) bookmark.tags = updates.tags;
      
      // Add bookmark to new category
      if (!newCategory.bookmarks) {
        newCategory.bookmarks = [];
      }
      newCategory.bookmarks.push(bookmark);
    } else {
      // Same category - just update fields
      if (updates.title) bookmark.title = updates.title;
      if (updates.url) {
        var url = updates.url.trim();
        if (!url.match(/^https?:\/\//i)) {
          if (!url.includes('.')) {
            url = url + '.com';
          }
          url = 'https://' + url;
        }
        bookmark.url = url;
      }
      if (updates.info !== undefined) bookmark.info = updates.info;
      if (updates.tags !== undefined) bookmark.tags = updates.tags;
    }
    
    var result = saveBookmarks(data);
    
    // CRITICAL: Άμεση cache invalidation
    redisFlush();
    var cache = CacheService.getScriptCache();
    cache.remove(STORAGE_KEY);
    cache.remove('LAST_MODIFIED');
    
    // Warm up caches
    var jsonData = JSON.stringify(data);
    cache.put(STORAGE_KEY, jsonData, CACHE_DURATION);
    redisSet(REDIS_KEYS.DATA, data, CACHE_DURATION);
    redisSet(REDIS_KEYS.LAST_MODIFIED, result.lastModified, SHORT_CACHE);
    
    // Update shared change notification
    updateChangeNotification('user', 'updateBookmark');
    
    return result;
    
  } catch (e) {
    Logger.log('Error updating bookmark: ' + e);
    throw e;
  }
}

function reorderBookmarks(categoryId, orderedBookmarkIds) {
  try {
    var data = getBookmarks();
    var category = data.categories.find(function(c) { return c.id === categoryId; });
    
    if (!category) {
      throw new Error('Category not found');
    }
    
    // Create a map of bookmarks by ID for quick lookup
    var bookmarkMap = {};
    category.bookmarks.forEach(function(b) {
      bookmarkMap[b.id] = b;
    });
    
    // Reorder bookmarks based on the provided ID array
    var reorderedBookmarks = [];
    orderedBookmarkIds.forEach(function(id) {
      if (bookmarkMap[id]) {
        reorderedBookmarks.push(bookmarkMap[id]);
      }
    });
    
    category.bookmarks = reorderedBookmarks;
    
    var result = saveBookmarks(data);
    
    // CRITICAL: Άμεση cache invalidation
    redisFlush();
    var cache = CacheService.getScriptCache();
    cache.remove(STORAGE_KEY);
    cache.remove('LAST_MODIFIED');
    
    // Warm up caches
    var jsonData = JSON.stringify(data);
    cache.put(STORAGE_KEY, jsonData, CACHE_DURATION);
    redisSet(REDIS_KEYS.DATA, data, CACHE_DURATION);
    redisSet(REDIS_KEYS.LAST_MODIFIED, result.lastModified, SHORT_CACHE);
    
    // Update shared change notification
    updateChangeNotification('user', 'reorderBookmarks');
    
    return result;
    
  } catch (e) {
    Logger.log('Error reordering bookmarks: ' + e);
    throw e;
  }
}

function deleteBookmark(categoryId, bookmarkId) {
  try {
    var data = getBookmarks();
    var category = data.categories.find(function(c) { return c.id === categoryId; });
    
    if (!category) {
      throw new Error('Category not found');
    }
    
    category.bookmarks = category.bookmarks.filter(function(b) { return b.id !== bookmarkId; });
    
    var result = saveBookmarks(data);
    
    // CRITICAL: Άμεση cache invalidation
    redisFlush();
    var cache = CacheService.getScriptCache();
    cache.remove(STORAGE_KEY);
    cache.remove('LAST_MODIFIED');
    
    // Warm up caches
    var jsonData = JSON.stringify(data);
    cache.put(STORAGE_KEY, jsonData, CACHE_DURATION);
    redisSet(REDIS_KEYS.DATA, data, CACHE_DURATION);
    redisSet(REDIS_KEYS.LAST_MODIFIED, result.lastModified, SHORT_CACHE);
    
    // Update shared change notification
    updateChangeNotification('user', 'deleteBookmark');
    
    return result;
    
  } catch (e) {
    Logger.log('Error deleting bookmark: ' + e);
    throw e;
  }
}

function addCategory(name) {
  try {
    var data = getBookmarks();
    
    var newCategory = {
      id: 'cat' + Date.now() + '_' + Math.random().toString(36).substr(2, 9),
      name: name,
      bookmarks: []
    };
    
    data.categories.push(newCategory);
    
    var result = saveBookmarks(data);
    
    // CRITICAL: Άμεση cache invalidation για όλα τα layers
    redisFlush();
    var cache = CacheService.getScriptCache();
    cache.remove(STORAGE_KEY);
    cache.remove('LAST_MODIFIED');
    
    // Warm up caches immediately για instant availability
    var jsonData = JSON.stringify(data);
    cache.put(STORAGE_KEY, jsonData, CACHE_DURATION);
    redisSet(REDIS_KEYS.DATA, data, CACHE_DURATION);
    redisSet(REDIS_KEYS.LAST_MODIFIED, result.lastModified, SHORT_CACHE);
    
    // Update shared change notification
    updateChangeNotification('user', 'addCategory');
    
    return result;
    
  } catch (e) {
    Logger.log('Error adding category: ' + e);
    throw e;
  }
}

function deleteCategory(categoryId) {
  try {
    var data = getBookmarks();
    data.categories = data.categories.filter(function(c) { return c.id !== categoryId; });
    
    var result = saveBookmarks(data);
    
    // CRITICAL: Άμεση cache invalidation για όλα τα layers
    redisFlush();
    var cache = CacheService.getScriptCache();
    cache.remove(STORAGE_KEY);
    cache.remove('LAST_MODIFIED');
    
    // Warm up caches immediately
    var jsonData = JSON.stringify(data);
    cache.put(STORAGE_KEY, jsonData, CACHE_DURATION);
    redisSet(REDIS_KEYS.DATA, data, CACHE_DURATION);
    redisSet(REDIS_KEYS.LAST_MODIFIED, result.lastModified, SHORT_CACHE);
    
    // Update shared change notification
    updateChangeNotification('user', 'deleteCategory');
    
    return result;
    
  } catch (e) {
    Logger.log('Error deleting category: ' + e);
    throw e;
  }
}

function updateCategory(categoryId, newName) {
  try {
    var data = getBookmarks();
    
    // Find and update category
    var category = null;
    for (var i = 0; i < data.categories.length; i++) {
      if (data.categories[i].id === categoryId) {
        category = data.categories[i];
        break;
      }
    }
    
    if (!category) {
      throw new Error('Category not found');
    }
    
    category.name = newName;
    
    var result = saveBookmarks(data);
    
    // CRITICAL: Άμεση cache invalidation για όλα τα layers
    redisFlush();
    var cache = CacheService.getScriptCache();
    cache.remove(STORAGE_KEY);
    cache.remove('LAST_MODIFIED');
    
    // Warm up caches immediately
    var jsonData = JSON.stringify(data);
    cache.put(STORAGE_KEY, jsonData, CACHE_DURATION);
    redisSet(REDIS_KEYS.DATA, data, CACHE_DURATION);
    redisSet(REDIS_KEYS.LAST_MODIFIED, result.lastModified, SHORT_CACHE);
    
    // Update shared change notification
    updateChangeNotification('user', 'updateCategory');
    
    return result;
    
  } catch (e) {
    Logger.log('Error updating category: ' + e);
    throw e;
  }
}

// ========== UTILITY FUNCTIONS ==========
function getDataSize() {
  try {
    var props = PropertiesService.getScriptProperties();
    var meta = props.getProperty(META_KEY);
    
    if (!meta) return { size: 0, chunks: 0, bookmarks: 0 };
    
    var metaObj = JSON.parse(meta);
    var data = getBookmarks();
    var totalBookmarks = 0;
    
    if (data.categories) {
      data.categories.forEach(function(cat) {
        totalBookmarks += (cat.bookmarks || []).length;
      });
    }
    
    return {
      size: metaObj.size || 0,
      chunks: metaObj.chunks || 0,
      bookmarks: totalBookmarks,
      categories: (data.categories || []).length
    };
  } catch (e) {
    Logger.log('getDataSize error: ' + e);
    return { size: 0, chunks: 0, bookmarks: 0, categories: 0 };
  }
}

function getCategoryIndex() {
  try {
    // Redis cache first
    var cached = redisGet(REDIS_KEYS.CATEGORIES);
    if (cached) return cached;
    
    var data = getBookmarks();
    
    if (!data.categories) {
      return { categories: [], lastModified: 0 };
    }
    
    // Return lightweight index only
    var index = data.categories.map(function(cat) {
      return {
        id: cat.id,
        name: cat.name,
        count: (cat.bookmarks || []).length
      };
    });
    
    var result = {
      categories: index,
      lastModified: data.lastModified
    };
    
    // Cache for quick access
    redisSet(REDIS_KEYS.CATEGORIES, result, CACHE_DURATION);
    
    return result;
  } catch (e) {
    Logger.log('getCategoryIndex error: ' + e);
    return { categories: [], lastModified: 0 };
  }
}

function getCategory(categoryId) {
  try {
    var data = getBookmarks();
    var category = data.categories.find(function(c) { return c.id === categoryId; });
    
    if (!category) {
      throw new Error('Category not found');
    }
    
    return category;
  } catch (e) {
    Logger.log('getCategory error: ' + e);
    throw e;
  }
}

function clearCache() {
  try {
    redisFlush();
    var cache = CacheService.getScriptCache();
    cache.remove(STORAGE_KEY);
    cache.remove('LAST_MODIFIED');
    return { success: true, message: 'All cache layers cleared' };
  } catch (e) {
    Logger.log('clearCache error: ' + e);
    throw e;
  }
}

// ========== PERFORMANCE MONITORING ==========
function getCacheStats() {
  try {
    var stats = {
      redis: {},
      legacy: {},
      storage: {}
    };
    
    // Check Redis cache
    Object.keys(REDIS_KEYS).forEach(function(k) {
      var key = REDIS_KEYS[k];
      var value = redisGet(key);
      stats.redis[k] = value ? 'HIT' : 'MISS';
    });
    
    // Check legacy cache
    var cache = CacheService.getScriptCache();
    stats.legacy.data = cache.get(STORAGE_KEY) ? 'HIT' : 'MISS';
    stats.legacy.timestamp = cache.get('LAST_MODIFIED') ? 'HIT' : 'MISS';
    
    // Storage info
    var sizeInfo = getDataSize();
    stats.storage = sizeInfo;
    
    return stats;
  } catch (e) {
    Logger.log('getCacheStats error: ' + e);
    return { error: e.message };
  }
}