User.gs

// User.gs - User management and usage tracking with PostgreSQL backend

// Initialize user in backend (called after authentication)
function initializeUserInBackend(userEmail) {
  try {
    var config = getConfig();
    
    var response = makeApiRequest('/api/users/initialize', {
      method: 'POST',
      payload: {
        email: userEmail,
        addOnId: config.ADDON_ID,
        addOnName: config.ADDON_NAME,
        version: config.VERSION
      }
    });
    
    if (response.success && response.json) {
      Logger.log('User initialized in backend: ' + userEmail);
      return response.json;
    } else {
      Logger.log('Backend user initialization failed: ' + response.body);
      // Don't throw error - let user continue with local functionality
      return { success: false, error: response.body };
    }
    
  } catch (error) {
    Logger.log('Error initializing user in backend: ' + error.toString());
    return { success: false, error: error.toString() };
  }
}

// Get user usage data (syncs, subscription, etc.)
function getUserUsageData() {
  try {
    if (!isAuthenticated()) {
      return {
        success: false,
        error: 'User not authenticated'
      };
    }
    
    var userEmail = getUserEmail();
    var config = getConfig();
    
    // Try to get from backend first
    var response = makeApiRequest('/api/users/usage', {
      method: 'GET'
    });
    
    if (response.success && response.json) {
      return {
        success: true,
        email: userEmail,
        count: response.json.refreshesUsed || 0,
        limit: response.json.refreshLimit || config.FREE_SYNC_LIMIT,
        plan: response.json.plan || 'free',
        resetDate: response.json.resetDate || getNextMonthStart(),
        subscriptionStatus: response.json.subscriptionStatus || 'free'
      };
    } else {
      // Fallback to local storage for offline functionality
      Logger.log('Backend unavailable, using local storage');
      return getLocalUsageData(userEmail, config);
    }
    
  } catch (error) {
    Logger.log('Error getting user usage data: ' + error.toString());
    // Fallback to local storage
    var userEmail = getUserEmail();
    var config = getConfig();
    return getLocalUsageData(userEmail, config);
  }
}

// Local fallback usage tracking (ES5 compatible)
function getLocalUsageData(userEmail, config) {
  try {
    var userProperties = PropertiesService.getUserProperties();
    var currentMonth = getMonthStart();
    var storedMonth = userProperties.getProperty('usage_month');
    var syncCount = parseInt(userProperties.getProperty('sync_count') || '0');
    
    // Reset count if new month
    if (storedMonth !== currentMonth) {
      syncCount = 0;
      userProperties.setProperties({
        'sync_count': '0',
        'usage_month': currentMonth
      });
    }
    
    return {
      success: true,
      email: userEmail,
      count: syncCount,
      limit: config.FREE_SYNC_LIMIT,
      plan: 'free',
      resetDate: getNextMonthStart(),
      subscriptionStatus: 'free',
      isLocal: true
    };
    
  } catch (error) {
    Logger.log('Error with local usage data: ' + error.toString());
    return {
      success: false,
      error: error.toString()
    };
  }
}

// Track sync usage (increment counter)
function trackSyncUsage() {
  try {
    var userEmail = getUserEmail();
    var config = getConfig();
    
    // Try to track in backend first
    var response = makeApiRequest('/api/users/track-usage', {
      method: 'POST',
      payload: {
        addOnId: config.ADDON_ID,
        action: 'sync'
      }
    });
    
    if (response.success) {
      Logger.log('Sync usage tracked in backend for: ' + userEmail);
      return response.json;
    } else {
      // Fallback to local tracking
      Logger.log('Backend tracking failed, using local tracking');
      return trackLocalSyncUsage();
    }
    
  } catch (error) {
    Logger.log('Error tracking sync usage: ' + error.toString());
    return trackLocalSyncUsage();
  }
}

// Local sync tracking fallback
function trackLocalSyncUsage() {
  try {
    var userProperties = PropertiesService.getUserProperties();
    var currentMonth = getMonthStart();
    var storedMonth = userProperties.getProperty('usage_month');
    var syncCount = parseInt(userProperties.getProperty('sync_count') || '0');
    
    // Reset if new month
    if (storedMonth !== currentMonth) {
      syncCount = 0;
      userProperties.setProperty('usage_month', currentMonth);
    }
    
    // Increment counter
    syncCount++;
    userProperties.setProperty('sync_count', syncCount.toString());
    
    return {
      success: true,
      count: syncCount,
      isLocal: true
    };
    
  } catch (error) {
    Logger.log('Error with local sync tracking: ' + error.toString());
    return {
      success: false,
      error: error.toString()
    };
  }
}

// Check if user can perform sync (has remaining quota)
function canUserSync() {
  try {
    var usage = getUserUsageData();
    
    if (!usage.success) {
      // If we can't get usage data, allow sync (fail open)
      return { allowed: true, reason: 'Usage data unavailable' };
    }
    
    if (usage.plan !== 'free') {
      // Paid users have unlimited syncs
      return { allowed: true, reason: 'Premium plan' };
    }
    
    if (usage.count >= usage.limit) {
      return { 
        allowed: false, 
        reason: 'Monthly limit exceeded',
        count: usage.count,
        limit: usage.limit,
        resetDate: usage.resetDate
      };
    }
    
    return { 
      allowed: true, 
      remaining: usage.limit - usage.count,
      count: usage.count,
      limit: usage.limit
    };
    
  } catch (error) {
    Logger.log('Error checking user sync permission: ' + error.toString());
    // Fail open - allow sync if we can't determine usage
    return { allowed: true, reason: 'Error checking limits' };
  }
}

// Get subscription status and upgrade URL
function getSubscriptionInfo() {
  try {
    var userEmail = getUserEmail();
    var config = getConfig();
    
    var response = makeApiRequest('/api/users/subscription', {
      method: 'GET'
    });
    
    if (response.success && response.json) {
      return {
        success: true,
        plan: response.json.plan || 'free',
        status: response.json.status || 'active',
        upgradeUrl: response.json.upgradeUrl || (config.API_BASE_URL.replace('api.', '') + '/upgrade'),
        manageUrl: response.json.manageUrl || null,
        nextBillingDate: response.json.nextBillingDate || null
      };
    } else {
      // Fallback for free users
      return {
        success: true,
        plan: 'free',
        status: 'active',
        upgradeUrl: config.API_BASE_URL.replace('api.', '') + '/upgrade'
      };
    }
    
  } catch (error) {
    Logger.log('Error getting subscription info: ' + error.toString());
    return {
      success: false,
      error: error.toString()
    };
  }
}

// Upgrade flow initiation
function initiateUpgradeFlow() {
  try {
    var subscriptionInfo = getSubscriptionInfo();
    
    if (subscriptionInfo.success && subscriptionInfo.upgradeUrl) {
      var ui = SpreadsheetApp.getUi();
      var response = ui.alert(
        'Upgrade to dflo.io Pro',
        'Upgrade to Pro for unlimited syncs across all dflo.io add-ons!\n\n' +
        '• Unlimited monthly syncs\n' +
        '• Access to all dflo.io connectors\n' +
        '• Priority support\n' +
        '• Advanced scheduling\n\n' +
        'Visit: ' + subscriptionInfo.upgradeUrl + '\n\n' +
        'Would you like to open the upgrade page?',
        ui.ButtonSet.YES_NO
      );
      
      if (response === ui.Button.YES) {
        // Note: Apps Script can't directly open URLs, but we can provide the link
        var linkHtml = HtmlService.createHtmlOutput(
          '<script>window.open("' + subscriptionInfo.upgradeUrl + '", "_blank"); google.script.host.close();</script>'
        );
        ui.showModalDialog(linkHtml, 'Opening upgrade page...');
      }
    }
    
    return {
      success: true,
      message: 'Upgrade information displayed'
    };
    
  } catch (error) {
    Logger.log('Error initiating upgrade flow: ' + error.toString());
    return {
      success: false,
      error: error.toString()
    };
  }
}

// Helper function to get next month start date
function getNextMonthStart() {
  var now = new Date();
  var nextMonth = new Date(now.getFullYear(), now.getMonth() + 1, 1);
  return nextMonth.toISOString().split('T')[0];
}

// Clean up old local data (call periodically)
function cleanupLocalData() {
  try {
    var userProperties = PropertiesService.getUserProperties();
    var currentMonth = getMonthStart();
    var storedMonth = userProperties.getProperty('usage_month');
    
    // If it's a new month, reset counters
    if (storedMonth && storedMonth !== currentMonth) {
      userProperties.setProperty('sync_count', '0');
      userProperties.setProperty('usage_month', currentMonth);
      Logger.log('Local usage data reset for new month');
    }
    
    return { success: true };
  } catch (error) {
    Logger.log('Error cleaning up local data: ' + error.toString());
    return { success: false, error: error.toString() };
  }
}

// Sync user data with backend (call after successful operations)
function syncUserDataWithBackend(operationType, metadata) {
  try {
    var userEmail = getUserEmail();
    var config = getConfig();
    
    var payload = {
      email: userEmail,
      addOnId: config.ADDON_ID,
      operationType: operationType || 'sync',
      timestamp: new Date().toISOString(),
      metadata: metadata || {}
    };
    
    // Make async call to backend (fire and forget)
    makeApiRequest('/api/users/sync-data', {
      method: 'POST',
      payload: payload
    });
    
    // Don't wait for response or handle errors - this is just for analytics
    
  } catch (error) {
    // Silently fail - sync is not critical
    Logger.log('Background sync failed: ' + error.toString());
  }
}