account-grader-v2.js

/**
 * Debug function to log the structure of an object
 * @param {Object} obj The object to log
 * @param {string} label A label for the log
 * @param {number} depth The maximum depth to log (default: 2)
 */
function debugObject(obj, label = 'Object', depth = 2) {
  try {
    const seen = new Set();
    const stringifyWithDepth = (obj, currentDepth = 0) => {
      if (currentDepth > depth) return '[Max Depth Reached]';
      if (obj === null) return 'null';
      if (obj === undefined) return 'undefined';
      if (typeof obj !== 'object') return String(obj);
      if (seen.has(obj)) return '[Circular Reference]';
      
      seen.add(obj);
      
      if (Array.isArray(obj)) {
        const items = obj.map(item => stringifyWithDepth(item, currentDepth + 1));
        return '[' + items.join(', ') + ']';
      }
      
      const entries = Object.entries(obj).map(([key, value]) => {
        return key + ': ' + stringifyWithDepth(value, currentDepth + 1);
      });
      
      return '{' + entries.join(', ') + '}';
    };
    
    Logger.log(label + ': ' + stringifyWithDepth(obj));
  } catch (e) {
    Logger.log('Error in debugObject: ' + e.message);
  }
}


/**
 * Google Ads Account Grader - ENHANCED EDITION
 * 
 * This script performs a comprehensive analysis of your Google Ads account,
 * evaluating performance across 10 key categories of PPC best practices:
 * - Campaign Organization
 * - Conversion Tracking
 * - Keyword Strategy
 * - Negative Keywords
 * - Bidding Strategy
 * - Ad Creative & Extensions
 * - Quality Score
 * - Audience Strategy
 * - Landing Page Optimization
 * - Competitive Analysis
 * 
 * Each category is scored on a 0-100% scale with detailed metrics and formulas,
 * and assigned a letter grade (A-F). The script provides actionable recommendations
 * prioritized by potential impact.
 * 
 * @version 2.2 PROFESSIONAL
 * @changelog
 *   v2.2 - Added: Historical Trend Tracking (6 months), Budget Efficiency Analysis 
 *          (11th category), Search Term Analysis (deep dive), Master tracking spreadsheet
 *   v2.1 - Added: Configuration validation, Progress indicators, Dry run mode,
 *          MCC support, Error recovery with retry, Performance profiling
 *   v2.0 - Initial comprehensive grader with 10 categories
 */

// Configuration
const CONFIG = {
    // Date range for data collection
    dateRange: {
      // Set to true to use custom date range, false to use lookback period
      useCustomDateRange: true,
      
      // Custom date range (only used if useCustomDateRange is true)
      // Format: YYYYMMDD (e.g., 20220701 for July 1, 2022)
      customStartDate: "20250715", // July 1, 2022
      customEndDate: "20250915",   // August 28, 2022
      
      // Lookback period in days (only used if useCustomDateRange is false)
      lookbackDays: 30
    },
    
    // Email settings
    email: {
      sendEmail: true,
      sendReport: true,
      sendErrorNotifications: true,
      emailAddress: 'youremail@slack.com',
      errorRecipients: ['youremail@slack.com'],
      includeSpreadsheetLink: true
    },
    
    // Spreadsheet settings
    spreadsheet: {
      createNew: true,
      existingSpreadsheetUrl: '', // Only used if createNew is false
      includeRawData: false // Whether to include raw data sheets
    },
    
    // Thresholds for letter grades
    gradeThresholds: {
      A: 90, // 90-100%
      B: 80, // 80-89%
      C: 70, // 70-79%
      D: 60, // 60-69%
      F: 0   // 0-59%
    },
    
    // Industry benchmarks (customize for your industry)
    industryBenchmarks: {
      ctr: 3.17,
      conversionRate: 3.75,
      cpc: 2.69,
      qualityScore: 6
    },
    
    // Best practice thresholds
    bestPractices: {
      keywordsPerAdGroup: 20,
      adsPerAdGroup: 3,
      minExtensionTypes: 4,
      minQualityScore: 7,
      maxCampaignsPerNegativeList: 20
    },
    
    // Category weights (must sum to 100)
    categoryWeights: {
      campaignOrganization: 9,
      conversionTracking: 14,
      keywordStrategy: 11,
      negativeKeywords: 7,
      biddingStrategy: 11,
      adCreative: 9,
      qualityScore: 9,
      audienceStrategy: 7,
      landingPage: 7,
      competitiveAnalysis: 6,
      budgetEfficiency: 10        // NEW v2.2: Budget efficiency category
    },
    
    // ===== NEW v2.1 ENHANCED FEATURES =====
    
    // Testing & Development settings
    testing: {
      dryRun: false,              // Set to true to test without sending emails/creating sheets
      logDataToConsole: false,    // Set to true for verbose debug logging
      enableProfiling: true       // Track execution time per function
    },
    
    // MCC (Manager Account) settings
    mcc: {
      enabled: false,             // Set to true to run on all child accounts
      maxAccounts: 50,            // Maximum number of accounts to process
      accountFilter: '',          // Optional: filter accounts by name (empty = all)
      sendConsolidatedReport: true // Send one summary report for all accounts
    },
    
    // Error handling settings
    errorHandling: {
      enableRetry: true,          // Retry failed API calls
      maxRetries: 3,              // Maximum number of retry attempts
      retryDelayMs: 1000,         // Base delay between retries (exponential backoff)
      continueOnError: true       // Continue processing other categories if one fails
    },
    
    // Progress reporting
    progress: {
      enableProgressLogs: true,   // Log progress percentage
      logInterval: 10             // Log every N% progress
    },
    
    // ===== NEW v2.2 PROFESSIONAL FEATURES =====
    
    // Historical trend tracking
    historicalTracking: {
      enabled: true,                                    // Enable historical comparison
      masterSpreadsheetId: '',                          // ID of master tracking sheet (auto-created if empty)
      monthsToTrack: 6,                                 // Track last 6 months
      showTrendCharts: true,                            // Add trend visualizations
      alertOnDecline: true,                             // Alert if grades decline
      declineThreshold: 10                              // Alert if score drops 10+ points
    },
    
    // Budget efficiency analysis (11th category)
    budgetEfficiency: {
      enabled: true,                                    // Enable budget efficiency category
      wastedSpendThreshold: 100,                        // Flag keywords with $100+ wasted
      lowPerformanceClickThreshold: 10,                 // Clicks before considering as low-performing
      zeroConversionDaysThreshold: 30                   // Flag keywords with no conversions in 30 days
    },
    
    // Search term analysis
    searchTermAnalysis: {
      enabled: true,                                    // Enable deep search term analysis
      minImpressions: 10,                               // Minimum impressions to analyze
      minClicks: 5,                                     // Minimum clicks for deeper analysis
      identifyNewOpportunities: true,                   // Find converting search terms not in keywords
      identifyWaste: true,                              // Find expensive non-converting terms
      analyzeIntent: true,                              // Analyze search intent patterns
      maxTermsToAnalyze: 1000                           // Limit for performance
    }
  };
  
  // Define evaluation categories
  const EVALUATION_CATEGORIES = [
    {
      name: "Campaign Organization",
      weight: CONFIG.categoryWeights.campaignOrganization,
      criteria: [
        { name: "Logical Campaign & Ad Group Structure", weight: 40 },
        { name: "Clear Naming Conventions & Segmentation", weight: 30 },
        { name: "No Internal Competition", weight: 30 }
      ]
    },
    {
      name: "Conversion Tracking",
      weight: CONFIG.categoryWeights.conversionTracking,
      criteria: [
        { name: "Comprehensive Conversion Coverage", weight: 40 },
        { name: "Accurate and Verified Tracking Implementation", weight: 35 },
        { name: "Enhanced & Offline Conversion Tracking", weight: 25 }
      ]
    },
    {
      name: "Keyword Strategy",
      weight: CONFIG.categoryWeights.keywordStrategy,
      criteria: [
        { name: "Extensive Keyword Research & Relevance", weight: 30 },
        { name: "Strategic Match Type Use", weight: 25 },
        { name: "Brand vs Non-Brand Segmentation", weight: 25 },
        { name: "Continuous Keyword Optimization", weight: 20 }
      ]
    },
    {
      name: "Negative Keywords",
      weight: CONFIG.categoryWeights.negativeKeywords,
      criteria: [
        { name: "Routine Search Query Mining", weight: 40 },
        { name: "Negative Keyword Lists and Hierarchy", weight: 35 },
        { name: "Balanced Exclusion (Avoid False Negatives)", weight: 25 }
      ]
    },
    {
      name: "Bidding Strategy",
      weight: CONFIG.categoryWeights.biddingStrategy,
      criteria: [
        { name: "Goal-Aligned Bidding Approach", weight: 35 },
        { name: "Optimize Automated Bidding with Data", weight: 25 },
        { name: "Device, Location, and Time Bid Adjustments", weight: 20 },
        { name: "Budget Management & Bid Strategy Alignment", weight: 20 }
      ]
    },
    {
      name: "Ad Creative & Extensions",
      weight: CONFIG.categoryWeights.adCreative,
      criteria: [
        { name: "Compelling Ad Copy with Relevance", weight: 30 },
        { name: "Ad Variety and Continuous Testing", weight: 25 },
        { name: "Leverage Ad Extensions", weight: 30 },
        { name: "Ad Quality and Compliance", weight: 15 }
      ]
    },
    {
      name: "Quality Score",
      weight: CONFIG.categoryWeights.qualityScore,
      criteria: [
        { name: "Monitor Quality Score & Components", weight: 25 },
        { name: "Improve Ad Relevance", weight: 25 },
        { name: "Improve Expected CTR", weight: 25 },
        { name: "Improve Landing Page Experience", weight: 25 }
      ]
    },
    {
      name: "Audience Strategy",
      weight: CONFIG.categoryWeights.audienceStrategy,
      criteria: [
        { name: "Remarketing & Retargeting", weight: 35 },
        { name: "Customer Match & Similar Audiences", weight: 25 },
        { name: "In-Market, Affinity, and Demographic Targeting", weight: 25 },
        { name: "Personalized Ad Experiences by Audience", weight: 15 }
      ]
    },
    {
      name: "Landing Page Optimization",
      weight: CONFIG.categoryWeights.landingPage,
      criteria: [
        { name: "Relevance and Message Match", weight: 30 },
        { name: "Conversion-Focused Design", weight: 30 },
        { name: "Page Speed and Mobile Optimization", weight: 25 },
        { name: "A/B Testing & Iteration", weight: 15 }
      ]
    },
    {
      name: "Competitive Analysis",
      weight: CONFIG.categoryWeights.competitiveAnalysis,
      criteria: [
        { name: "Auction Insights Monitoring", weight: 35 },
        { name: "Competitor Keyword and Ad Analysis", weight: 25 },
        { name: "Benchmarking Performance Metrics", weight: 25 },
        { name: "Adaptive Strategy to Competitor Moves", weight: 15 }
      ]
    },
    {
      name: "Budget Efficiency",
      weight: CONFIG.categoryWeights.budgetEfficiency,
      criteria: [
        { name: "Wasted Spend Identification", weight: 35 },
        { name: "Budget Allocation Optimization", weight: 30 },
        { name: "Day-Parting and Scheduling Efficiency", weight: 20 },
        { name: "Device and Location Budget Distribution", weight: 15 }
      ]
    }
  ];
  
  // ===== NEW v2.1 ENHANCED UTILITY FUNCTIONS =====
  
  /**
   * Validates the CONFIG object before execution
   * @throws {Error} If configuration is invalid
   * @return {boolean} True if config is valid
   */
  function validateConfig() {
    Logger.log("🔍 Validating configuration...");
    const errors = [];
    
    // Validate email
    if (!CONFIG.email.emailAddress || !CONFIG.email.emailAddress.includes('@')) {
      errors.push('❌ Invalid email address in CONFIG.email.emailAddress');
    }
    
    // Validate date range
    if (CONFIG.dateRange.useCustomDateRange) {
      if (!/^\d{8}$/.test(CONFIG.dateRange.customStartDate)) {
        errors.push('❌ Invalid customStartDate format (use YYYYMMDD)');
      }
      if (!/^\d{8}$/.test(CONFIG.dateRange.customEndDate)) {
        errors.push('❌ Invalid customEndDate format (use YYYYMMDD)');
      }
      // Validate start is before end
      if (CONFIG.dateRange.customStartDate > CONFIG.dateRange.customEndDate) {
        errors.push('❌ customStartDate must be before customEndDate');
      }
    } else {
      if (!CONFIG.dateRange.lookbackDays || CONFIG.dateRange.lookbackDays < 1) {
        errors.push('❌ lookbackDays must be at least 1');
      }
    }
    
    // Validate category weights sum to 100
    const weightSum = Object.values(CONFIG.categoryWeights).reduce((a, b) => a + b, 0);
    if (Math.abs(weightSum - 100) > 0.01) {
      errors.push(`❌ Category weights must sum to 100 (current: ${weightSum})`);
    }
    
    // Validate thresholds
    if (CONFIG.gradeThresholds.A < CONFIG.gradeThresholds.B ||
        CONFIG.gradeThresholds.B < CONFIG.gradeThresholds.C ||
        CONFIG.gradeThresholds.C < CONFIG.gradeThresholds.D) {
      errors.push('❌ Grade thresholds must be in descending order (A > B > C > D)');
    }
    
    // Log results
    if (errors.length > 0) {
      Logger.log('❌ Configuration validation FAILED:');
      errors.forEach(error => Logger.log('   ' + error));
      throw new Error('Configuration errors:\n' + errors.join('\n'));
    }
    
    Logger.log('✅ Configuration validation PASSED');
    return true;
  }
  
  /**
   * Logs progress with percentage indicator
   * @param {number} current Current step number
   * @param {number} total Total number of steps
   * @param {string} label Description of current step
   */
  function logProgress(current, total, label) {
    if (!CONFIG.progress.enableProgressLogs) return;
    
    const percent = Math.round((current / total) * 100);
    const shouldLog = percent % CONFIG.progress.logInterval === 0 || current === 1 || current === total;
    
    if (shouldLog) {
      const bar = '█'.repeat(Math.floor(percent / 10)) + '░'.repeat(10 - Math.floor(percent / 10));
      Logger.log(`📊 [${percent}%] ${bar} ${label}`);
    }
  }
  
  /**
   * Profiles function execution time
   * @param {Function} fn Function to profile
   * @param {string} label Label for the profile
   * @return {*} Result of the function
   */
  function profile(fn, label) {
    if (!CONFIG.testing.enableProfiling) {
      return fn();
    }
    
    const start = new Date().getTime();
    const result = fn();
    const duration = new Date().getTime() - start;
    
    Logger.log(`⏱️  ${label}: ${duration}ms (${(duration / 1000).toFixed(2)}s)`);
    return result;
  }
  
  /**
   * Retries a function with exponential backoff
   * @param {Function} fn Function to retry
   * @param {number} maxRetries Maximum number of retries
   * @return {*} Result of the function
   */
  function retryWithBackoff(fn, maxRetries = CONFIG.errorHandling.maxRetries) {
    if (!CONFIG.errorHandling.enableRetry) {
      return fn();
    }
    
    let attempt = 0;
    
    while (attempt < maxRetries) {
      try {
        return fn();
      } catch (e) {
        attempt++;
        if (attempt >= maxRetries) {
          Logger.log(`❌ Failed after ${maxRetries} attempts: ${e.message}`);
          throw e;
        }
        
        const delay = CONFIG.errorHandling.retryDelayMs * Math.pow(2, attempt);
        Logger.log(`⚠️  Retry attempt ${attempt}/${maxRetries} after ${delay}ms: ${e.message}`);
        Utilities.sleep(delay);
      }
    }
  }
  
  /**
   * Safely executes a function with error handling
   * @param {Function} fn Function to execute
   * @param {string} label Label for logging
   * @param {*} defaultValue Value to return on error
   * @return {*} Result of function or default value
   */
  function safeExecute(fn, label, defaultValue = null) {
    try {
      return fn();
    } catch (e) {
      Logger.log(`⚠️  Error in ${label}: ${e.message}`);
      if (CONFIG.errorHandling.continueOnError) {
        Logger.log(`   Continuing with default value...`);
        return defaultValue;
      } else {
        throw e;
      }
    }
  }
  
  // ===== NEW v2.2 HISTORICAL TRACKING FUNCTIONS =====
  
  /**
   * Gets or creates the master tracking spreadsheet
   * @return {Spreadsheet} The master tracking spreadsheet
   */
  function getMasterTrackingSpreadsheet() {
    Logger.log("📊 Getting master tracking spreadsheet...");
    
    if (!CONFIG.historicalTracking.enabled) {
      return null;
    }
    
    try {
      // Try to open existing spreadsheet
      if (CONFIG.historicalTracking.masterSpreadsheetId) {
        try {
          const sheet = SpreadsheetApp.openById(CONFIG.historicalTracking.masterSpreadsheetId);
          Logger.log(`✅ Opened existing master spreadsheet: ${sheet.getName()}`);
          return sheet;
        } catch (e) {
          Logger.log(`⚠️  Could not open existing spreadsheet: ${e.message}`);
        }
      }
      
      // Create new master tracking spreadsheet
      const accountName = AdsApp.currentAccount().getName();
      const accountId = AdsApp.currentAccount().getCustomerId();
      const sheet = SpreadsheetApp.create(`Google Ads Grader - Master Tracking - ${accountName} (${accountId})`);
      
      // Initialize with headers
      const trackingSheet = sheet.getActiveSheet();
      trackingSheet.setName("Historical Grades");
      
      trackingSheet.getRange(1, 1, 1, 14).setValues([[
        'Date',
        'Overall Grade',
        'Overall Score',
        'Campaign Organization',
        'Conversion Tracking',
        'Keyword Strategy',
        'Negative Keywords',
        'Bidding Strategy',
        'Ad Creative & Extensions',
        'Quality Score',
        'Audience Strategy',
        'Landing Page',
        'Competitive Analysis',
        'Budget Efficiency'
      ]]);
      
      trackingSheet.getRange(1, 1, 1, 14).setFontWeight("bold").setBackground("#4285f4").setFontColor("#ffffff");
      trackingSheet.setFrozenRows(1);
      trackingSheet.autoResizeColumns(1, 14);
      
      Logger.log(`✅ Created new master tracking spreadsheet: ${sheet.getUrl()}`);
      Logger.log(`⚠️  IMPORTANT: Save this spreadsheet ID to CONFIG.historicalTracking.masterSpreadsheetId:`);
      Logger.log(`   masterSpreadsheetId: '${sheet.getId()}'`);
      
      return sheet;
    } catch (e) {
      Logger.log(`❌ Error with master tracking spreadsheet: ${e.message}`);
      return null;
    }
  }
  
  /**
   * Saves current grades to master tracking spreadsheet
   * @param {Object} evaluationResults The evaluation results
   * @param {Object} overallGrade The overall grade
   */
  function saveToHistoricalTracking(evaluationResults, overallGrade) {
    if (!CONFIG.historicalTracking.enabled) {
      return;
    }
    
    Logger.log("💾 Saving to historical tracking...");
    
    try {
      const masterSheet = getMasterTrackingSpreadsheet();
      if (!masterSheet) {
        Logger.log("⚠️  No master spreadsheet available for historical tracking");
        return;
      }
      
      const trackingSheet = masterSheet.getSheetByName("Historical Grades");
      if (!trackingSheet) {
        Logger.log("❌ Historical Grades sheet not found");
        return;
      }
      
      // Get current date
      const today = Utilities.formatDate(new Date(), AdsApp.currentAccount().getTimeZone(), "yyyy-MM-dd");
      
      // Prepare row data
      const rowData = [
        today,
        overallGrade.letter,
        overallGrade.score.toFixed(1)
      ];
      
      // Add category scores in order
      const categoryOrder = [
        'campaignorganization',
        'conversiontracking',
        'keywordstrategy',
        'negativekeywords',
        'biddingstrategy',
        'adcreativeextensions',
        'qualityscore',
        'audiencestrategy',
        'landingpageoptimization',
        'competitiveanalysis',
        'budgetefficiency'
      ];
      
      categoryOrder.forEach(category => {
        const result = evaluationResults[category];
        if (result && result.score !== undefined) {
          rowData.push(result.score.toFixed(1));
        } else {
          rowData.push('N/A');
        }
      });
      
      // Append to sheet
      const lastRow = trackingSheet.getLastRow();
      trackingSheet.getRange(lastRow + 1, 1, 1, rowData.length).setValues([rowData]);
      
      Logger.log(`✅ Saved historical data for ${today}`);
      
      // Add trend chart if enabled and enough data
      if (CONFIG.historicalTracking.showTrendCharts && lastRow >= 3) {
        createTrendChart(trackingSheet);
      }
      
    } catch (e) {
      Logger.log(`❌ Error saving to historical tracking: ${e.message}`);
    }
  }
  
  /**
   * Gets historical grades from master tracking spreadsheet
   * @return {Array} Array of historical grade records
   */
  function getHistoricalGrades() {
    if (!CONFIG.historicalTracking.enabled) {
      return [];
    }
    
    try {
      const masterSheet = getMasterTrackingSpreadsheet();
      if (!masterSheet) {
        return [];
      }
      
      const trackingSheet = masterSheet.getSheetByName("Historical Grades");
      if (!trackingSheet) {
        return [];
      }
      
      const lastRow = trackingSheet.getLastRow();
      if (lastRow <= 1) {
        return []; // Only header row
      }
      
      // Get last N months of data
      const monthsToGet = CONFIG.historicalTracking.monthsToTrack;
      const startRow = Math.max(2, lastRow - monthsToGet + 1);
      const numRows = lastRow - startRow + 1;
      
      const data = trackingSheet.getRange(startRow, 1, numRows, 14).getValues();
      
      const historicalData = data.map(row => ({
        date: row[0],
        overallGrade: row[1],
        overallScore: parseFloat(row[2]) || 0,
        categories: {
          campaignOrganization: parseFloat(row[3]) || 0,
          conversionTracking: parseFloat(row[4]) || 0,
          keywordStrategy: parseFloat(row[5]) || 0,
          negativeKeywords: parseFloat(row[6]) || 0,
          biddingStrategy: parseFloat(row[7]) || 0,
          adCreative: parseFloat(row[8]) || 0,
          qualityScore: parseFloat(row[9]) || 0,
          audienceStrategy: parseFloat(row[10]) || 0,
          landingPage: parseFloat(row[11]) || 0,
          competitiveAnalysis: parseFloat(row[12]) || 0,
          budgetEfficiency: parseFloat(row[13]) || 0
        }
      }));
      
      Logger.log(`📊 Retrieved ${historicalData.length} months of historical data`);
      return historicalData;
      
    } catch (e) {
      Logger.log(`❌ Error retrieving historical grades: ${e.message}`);
      return [];
    }
  }
  
  /**
   * Creates trend chart in tracking spreadsheet
   * @param {Sheet} trackingSheet The tracking sheet
   */
  function createTrendChart(trackingSheet) {
    try {
      // Remove existing charts
      const charts = trackingSheet.getCharts();
      charts.forEach(chart => trackingSheet.removeChart(chart));
      
      const lastRow = trackingSheet.getLastRow();
      const dataRange = trackingSheet.getRange(1, 1, lastRow, 3); // Date, Grade Letter, Score
      
      const chart = trackingSheet.newChart()
        .setChartType(Charts.ChartType.LINE)
        .addRange(dataRange)
        .setPosition(lastRow + 3, 1, 0, 0)
        .setOption('title', 'Overall Grade Trend')
        .setOption('hAxis', {title: 'Date'})
        .setOption('vAxis', {title: 'Score', minValue: 0, maxValue: 100})
        .setOption('legend', {position: 'bottom'})
        .setOption('width', 800)
        .setOption('height', 400)
        .build();
      
      trackingSheet.insertChart(chart);
      Logger.log("📈 Created trend chart");
      
    } catch (e) {
      Logger.log(`⚠️  Could not create trend chart: ${e.message}`);
    }
  }
  
  /**
   * Checks for grade declines and sends alerts
   * @param {Object} currentGrade Current overall grade
   * @param {Array} historicalGrades Historical grade data
   */
  function checkForDeclineAlerts(currentGrade, historicalGrades) {
    if (!CONFIG.historicalTracking.enabled || !CONFIG.historicalTracking.alertOnDecline) {
      return;
    }
    
    if (historicalGrades.length === 0) {
      Logger.log("No historical data for decline comparison");
      return;
    }
    
    try {
      const previousGrade = historicalGrades[historicalGrades.length - 1];
      const scoreDiff = currentGrade.score - previousGrade.overallScore;
      
      if (Math.abs(scoreDiff) >= CONFIG.historicalTracking.declineThreshold) {
        if (scoreDiff < 0) {
          // Score declined
          sendDeclineAlert(currentGrade, previousGrade, scoreDiff);
        } else {
          // Score improved
          Logger.log(`📈 Score improved by ${scoreDiff.toFixed(1)} points!`);
        }
      }
    } catch (e) {
      Logger.log(`❌ Error checking for declines: ${e.message}`);
    }
  }
  
  /**
   * Sends alert email for grade declines
   * @param {Object} currentGrade Current grade
   * @param {Object} previousGrade Previous grade
   * @param {number} scoreDiff Score difference
   */
  function sendDeclineAlert(currentGrade, previousGrade, scoreDiff) {
    Logger.log(`🚨 ALERT: Score declined by ${Math.abs(scoreDiff).toFixed(1)} points`);
    
    const accountName = AdsApp.currentAccount().getName();
    const accountId = AdsApp.currentAccount().getCustomerId();
    
    const subject = `🚨 ALERT: Google Ads Grade Declined - ${accountName}`;
    
    const body = `
    <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto; border: 2px solid #ea4335; border-radius: 5px;">
      <div style="background-color: #ea4335; color: white; padding: 15px; text-align: center;">
        <h1 style="margin: 0;">🚨 Grade Decline Alert</h1>
      </div>
      
      <div style="padding: 20px;">
        <p><strong>Account:</strong> ${accountName} (${accountId})</p>
        <p><strong>Alert Reason:</strong> Grade declined significantly</p>
        
        <table style="width: 100%; border-collapse: collapse; margin: 20px 0;">
          <tr style="background-color: #f1f3f4;">
            <th style="padding: 10px; text-align: left;">Metric</th>
            <th style="padding: 10px; text-align: center;">Previous</th>
            <th style="padding: 10px; text-align: center;">Current</th>
            <th style="padding: 10px; text-align: center;">Change</th>
          </tr>
          <tr>
            <td style="padding: 10px;"><strong>Grade</strong></td>
            <td style="padding: 10px; text-align: center;">${previousGrade.overallGrade}</td>
            <td style="padding: 10px; text-align: center;">${currentGrade.letter}</td>
            <td style="padding: 10px; text-align: center; color: #ea4335; font-weight: bold;">
              ${previousGrade.overallGrade} → ${currentGrade.letter}
            </td>
          </tr>
          <tr>
            <td style="padding: 10px;"><strong>Score</strong></td>
            <td style="padding: 10px; text-align: center;">${previousGrade.overallScore.toFixed(1)}</td>
            <td style="padding: 10px; text-align: center;">${currentGrade.score.toFixed(1)}</td>
            <td style="padding: 10px; text-align: center; color: #ea4335; font-weight: bold;">
              ▼ ${Math.abs(scoreDiff).toFixed(1)} points
            </td>
          </tr>
        </table>
        
        <p><strong>Recommended Action:</strong> Review your detailed report to identify which categories declined and implement the top recommendations.</p>
        
        <p style="margin-top: 30px; padding-top: 20px; border-top: 1px solid #ddd; font-size: 12px; color: #666;">
          This alert was triggered because the score dropped by ${Math.abs(scoreDiff).toFixed(1)} points, 
          which exceeds your threshold of ${CONFIG.historicalTracking.declineThreshold} points.
        </p>
      </div>
    </div>`;
    
    MailApp.sendEmail({
      to: CONFIG.email.emailAddress,
      subject: subject,
      htmlBody: body
    });
    
    Logger.log("📧 Decline alert email sent");
  }
  
  /**
   * Main function that runs the account grader (with MCC support)
   * @param {Object} options Optional parameters to customize the script behavior
   * @param {string} options.startDate Optional start date in YYYYMMDD format
   * @param {string} options.endDate Optional end date in YYYYMMDD format
   * @return {string} URL of the generated report spreadsheet
   */
  function main(options = {}) {
    // Validate configuration first
    validateConfig();
    Logger.log("Starting Google Ads Account Grader...");
    
    // Apply custom date range if provided
    if (options.startDate && options.endDate) {
      CONFIG.dateRange.useCustomDateRange = true;
      CONFIG.dateRange.customStartDate = options.startDate;
      CONFIG.dateRange.customEndDate = options.endDate;
      Logger.log(`Using custom date range: ${options.startDate} to ${options.endDate}`);
    }
    
    try {
      const totalSteps = 14; // Total major steps in the process
      let currentStep = 0;
      
      // Step 1: Collect account data
      logProgress(++currentStep, totalSteps, "Collecting account data...");
      const accountData = profile(() => collectAccountData(), "Data Collection");
      
      // Step 2-11: Evaluate each category (10 categories)
      logProgress(++currentStep, totalSteps, "Evaluating Campaign Organization...");
      const campaignOrg = profile(() => safeExecute(
        () => evaluateCampaignOrganization(accountData),
        "Campaign Organization",
        {score: 0, letter: 'F', criteria: {}, recommendations: []}
      ), "Campaign Organization Evaluation");
      
      logProgress(++currentStep, totalSteps, "Evaluating Conversion Tracking...");
      const convTracking = profile(() => safeExecute(
        () => evaluateConversionTracking(accountData),
        "Conversion Tracking",
        {score: 0, letter: 'F', criteria: {}, recommendations: []}
      ), "Conversion Tracking Evaluation");
      
      logProgress(++currentStep, totalSteps, "Evaluating Keyword Strategy...");
      const keywordStrat = profile(() => safeExecute(
        () => evaluateKeywordStrategy(accountData),
        "Keyword Strategy",
        {score: 0, letter: 'F', criteria: {}, recommendations: []}
      ), "Keyword Strategy Evaluation");
      
      logProgress(++currentStep, totalSteps, "Evaluating Negative Keywords...");
      const negKeywords = profile(() => safeExecute(
        () => evaluateNegativeKeywords(accountData),
        "Negative Keywords",
        {score: 0, letter: 'F', criteria: {}, recommendations: []}
      ), "Negative Keywords Evaluation");
      
      logProgress(++currentStep, totalSteps, "Evaluating Bidding Strategy...");
      const biddingStrat = profile(() => safeExecute(
        () => evaluateBiddingStrategy(accountData),
        "Bidding Strategy",
        {score: 0, letter: 'F', criteria: {}, recommendations: []}
      ), "Bidding Strategy Evaluation");
      
      logProgress(++currentStep, totalSteps, "Evaluating Ad Creative & Extensions...");
      const adCreative = profile(() => safeExecute(
        () => evaluateAdCreative(accountData),
        "Ad Creative",
        {score: 0, letter: 'F', criteria: {}, recommendations: []}
      ), "Ad Creative Evaluation");
      
      logProgress(++currentStep, totalSteps, "Evaluating Quality Score...");
      const qualityScore = profile(() => safeExecute(
        () => evaluateQualityScore(accountData),
        "Quality Score",
        {score: 0, letter: 'F', criteria: {}, recommendations: []}
      ), "Quality Score Evaluation");
      
      logProgress(++currentStep, totalSteps, "Evaluating Audience Strategy...");
      const audienceStrat = profile(() => safeExecute(
        () => evaluateAudienceStrategy(accountData),
        "Audience Strategy",
        {score: 0, letter: 'F', criteria: {}, recommendations: []}
      ), "Audience Strategy Evaluation");
      
      logProgress(++currentStep, totalSteps, "Evaluating Landing Page Optimization...");
      const landingPage = profile(() => safeExecute(
        () => evaluateLandingPage(accountData),
        "Landing Page",
        {score: 0, letter: 'F', criteria: {}, recommendations: []}
      ), "Landing Page Evaluation");
      
      logProgress(++currentStep, totalSteps, "Evaluating Competitive Analysis...");
      const competitive = profile(() => safeExecute(
        () => evaluateCompetitiveAnalysis(accountData),
        "Competitive Analysis",
        {score: 0, letter: 'F', criteria: {}, recommendations: []}
      ), "Competitive Analysis Evaluation");
      
      // NEW v2.2: Evaluate Budget Efficiency (11th category)
      logProgress(++currentStep, totalSteps, "Evaluating Budget Efficiency...");
      const budgetEff = profile(() => safeExecute(
        () => evaluateBudgetEfficiency(accountData),
        "Budget Efficiency",
        {score: 0, letter: 'F', criteria: {}, recommendations: []}
      ), "Budget Efficiency Evaluation");
      
      // Compile evaluation results
      const evaluationResults = {
        campaignorganization: campaignOrg,
        conversiontracking: convTracking,
        keywordstrategy: keywordStrat,
        negativekeywords: negKeywords,
        biddingstrategy: biddingStrat,
        adcreativeextensions: adCreative,
        qualityscore: qualityScore,
        audiencestrategy: audienceStrat,
        landingpageoptimization: landingPage,
        competitiveanalysis: competitive,
        budgetefficiency: budgetEff
      };
      
      // Enhance evaluation results with raw data to ensure detailed reports
      logProgress(++currentStep, totalSteps, "Enhancing results with detailed data...");
      enhanceEvaluationResults(evaluationResults, accountData);
      
      // Fix category keys to match EVALUATION_CATEGORIES
      const fixedEvaluationResults = {};
      for (const category in evaluationResults) {
        let fixedKey = category;
        if (category === 'adcreativeextensions') {
          fixedKey = 'adcreative&extensions';
        }
        fixedEvaluationResults[fixedKey] = evaluationResults[category];
      }
      
      // Calculate overall grade
      logProgress(++currentStep, totalSteps, "Calculating overall grade...");
      const overallGrade = profile(() => calculateOverallGrade(fixedEvaluationResults), "Overall Grade Calculation");
      
      // Generate prioritized recommendations
      const prioritizedRecommendations = profile(() => generatePrioritizedRecommendations(fixedEvaluationResults), "Recommendations Generation");
      
      // Create report (or skip in dry run mode)
      logProgress(++currentStep, totalSteps, "Creating report...");
      let reportSpreadsheet;
      if (CONFIG.testing.dryRun) {
        Logger.log("🧪 DRY RUN MODE: Skipping Google Sheets creation");
        reportSpreadsheet = { getUrl: () => "DRY_RUN_MODE_NO_SHEET_CREATED" };
      } else {
        reportSpreadsheet = profile(() => createReport(fixedEvaluationResults, overallGrade, prioritizedRecommendations, accountData), "Report Creation");
      }
      
      // Send email notification if configured (or skip in dry run mode)
      logProgress(++currentStep, totalSteps, "Sending email notification...");
      if (CONFIG.email.sendReport && !CONFIG.testing.dryRun) {
        profile(() => sendEmailReport(reportSpreadsheet.getUrl(), fixedEvaluationResults, overallGrade, accountData), "Email Sending");
      } else if (CONFIG.testing.dryRun) {
        Logger.log("🧪 DRY RUN MODE: Skipping email send to " + CONFIG.email.emailAddress);
      }
      
      // NEW v2.2: Save to historical tracking and check for declines
      if (CONFIG.historicalTracking.enabled && !CONFIG.testing.dryRun) {
        logProgress(++currentStep, totalSteps, "Saving to historical tracking...");
        const historicalGrades = getHistoricalGrades();
        saveToHistoricalTracking(fixedEvaluationResults, overallGrade);
        checkForDeclineAlerts(overallGrade, historicalGrades);
      }
      
      Logger.log("✅ Account grading completed successfully!");
      Logger.log("📊 Overall grade: " + overallGrade.letter + " (" + overallGrade.score.toFixed(1) + "%)");
      
      if (CONFIG.testing.dryRun) {
        Logger.log("🧪 DRY RUN MODE: Script completed without sending emails or creating sheets");
      }
      
      return reportSpreadsheet.getUrl();
    } catch (error) {
      Logger.log("❌ Error running account grader: " + error.message);
      Logger.log(error);
      
      // Send error notification (unless in dry run mode)
      if (!CONFIG.testing.dryRun) {
        sendErrorNotification(error);
      } else {
        Logger.log("🧪 DRY RUN MODE: Skipping error notification");
      }
      
      throw error;
    }
  }
  
  /**
   * NEW v2.1: Main function for MCC accounts - processes multiple child accounts
   * @param {Object} options Optional parameters
   * @return {Array} Array of results for each account
   */
  function mainForAllAccounts(options = {}) {
    if (!CONFIG.mcc.enabled) {
      Logger.log("⚠️  MCC mode is not enabled. Running on current account only.");
      return [main(options)];
    }
    
    // Validate configuration for MCC mode
    validateConfig();
    
    Logger.log("🏢 Starting MCC Mode - Processing multiple accounts...");
    
    try {
      // Get account iterator
      const accountSelector = AdsManagerApp.accounts();
      
      // Apply account filter if specified
      if (CONFIG.mcc.accountFilter) {
        accountSelector.withCondition(`customer_client.descriptive_name CONTAINS '${CONFIG.mcc.accountFilter}'`);
        Logger.log(`   Filtering accounts by: ${CONFIG.mcc.accountFilter}`);
      }
      
      // Limit number of accounts if specified
      if (CONFIG.mcc.maxAccounts > 0) {
        accountSelector.withLimit(CONFIG.mcc.maxAccounts);
      }
      
      const accountIterator = accountSelector.get();
      const allReports = [];
      let processedCount = 0;
      let successCount = 0;
      let errorCount = 0;
      
      // Process each account
      while (accountIterator.hasNext()) {
        const account = accountIterator.next();
        processedCount++;
        
        try {
          AdsManagerApp.select(account);
          const accountName = account.getName();
          const accountId = account.getCustomerId();
          
          Logger.log(`\n${'='.repeat(80)}`);
          Logger.log(`📊 Processing account ${processedCount}: ${accountName} (${accountId})`);
          Logger.log(`${'='.repeat(80)}`);
          
          const reportUrl = profile(() => main(options), `Account ${accountName}`);
          
          allReports.push({
            accountName: accountName,
            accountId: accountId,
            reportUrl: reportUrl,
            status: 'SUCCESS'
          });
          
          successCount++;
          Logger.log(`✅ Successfully completed account: ${accountName}`);
          
        } catch (e) {
          errorCount++;
          Logger.log(`❌ Error processing account ${account.getName()}: ${e.message}`);
          
          allReports.push({
            accountName: account.getName(),
            accountId: account.getCustomerId(),
            reportUrl: null,
            status: 'ERROR',
            error: e.message
          });
          
          if (!CONFIG.errorHandling.continueOnError) {
            throw e;
          }
        }
      }
      
      // Log summary
      Logger.log(`\n${'='.repeat(80)}`);
      Logger.log(`📊 MCC PROCESSING SUMMARY`);
      Logger.log(`${'='.repeat(80)}`);
      Logger.log(`Total accounts processed: ${processedCount}`);
      Logger.log(`✅ Successful: ${successCount}`);
      Logger.log(`❌ Errors: ${errorCount}`);
      Logger.log(`${'='.repeat(80)}\n`);
      
      // Send consolidated report if enabled
      if (CONFIG.mcc.sendConsolidatedReport && !CONFIG.testing.dryRun) {
        sendMccSummaryEmail(allReports);
      } else if (CONFIG.testing.dryRun) {
        Logger.log("🧪 DRY RUN MODE: Skipping MCC summary email");
      }
      
      return allReports;
      
    } catch (error) {
      Logger.log(`❌ Fatal error in MCC processing: ${error.message}`);
      throw error;
    }
  }
  
  /**
   * NEW v2.1: Sends MCC summary email with results from all accounts
   * @param {Array} allReports Array of report results
   */
  function sendMccSummaryEmail(allReports) {
    Logger.log("📧 Sending MCC summary email...");
    
    const successfulReports = allReports.filter(r => r.status === 'SUCCESS');
    const failedReports = allReports.filter(r => r.status === 'ERROR');
    
    let body = `
    <div style="font-family: Arial, sans-serif; max-width: 800px; margin: 0 auto;">
      <h1>Google Ads MCC Account Grader Summary</h1>
      <p><strong>Date:</strong> ${Utilities.formatDate(new Date(), AdsApp.currentAccount().getTimeZone(), 'yyyy-MM-dd HH:mm:ss')}</p>
      
      <h2>Summary</h2>
      <table style="border-collapse: collapse; width: 100%;">
        <tr>
          <td style="padding: 10px; border: 1px solid #ddd;"><strong>Total Accounts:</strong></td>
          <td style="padding: 10px; border: 1px solid #ddd;">${allReports.length}</td>
        </tr>
        <tr style="background-color: #d4edda;">
          <td style="padding: 10px; border: 1px solid #ddd;"><strong>✅ Successful:</strong></td>
          <td style="padding: 10px; border: 1px solid #ddd;">${successfulReports.length}</td>
        </tr>
        <tr style="background-color: #f8d7da;">
          <td style="padding: 10px; border: 1px solid #ddd;"><strong>❌ Errors:</strong></td>
          <td style="padding: 10px; border: 1px solid #ddd;">${failedReports.length}</td>
        </tr>
      </table>
      
      <h2>Successful Reports</h2>
      <table style="border-collapse: collapse; width: 100%;">
        <tr style="background-color: #f1f3f4;">
          <th style="padding: 10px; border: 1px solid #ddd; text-align: left;">Account Name</th>
          <th style="padding: 10px; border: 1px solid #ddd; text-align: left;">Account ID</th>
          <th style="padding: 10px; border: 1px solid #ddd; text-align: left;">Report</th>
        </tr>`;
    
    successfulReports.forEach(report => {
      body += `
        <tr>
          <td style="padding: 10px; border: 1px solid #ddd;">${report.accountName}</td>
          <td style="padding: 10px; border: 1px solid #ddd;">${report.accountId}</td>
          <td style="padding: 10px; border: 1px solid #ddd;"><a href="${report.reportUrl}">View Report</a></td>
        </tr>`;
    });
    
    body += `</table>`;
    
    if (failedReports.length > 0) {
      body += `
      <h2>Failed Accounts</h2>
      <table style="border-collapse: collapse; width: 100%;">
        <tr style="background-color: #f1f3f4;">
          <th style="padding: 10px; border: 1px solid #ddd; text-align: left;">Account Name</th>
          <th style="padding: 10px; border: 1px solid #ddd; text-align: left;">Account ID</th>
          <th style="padding: 10px; border: 1px solid #ddd; text-align: left;">Error</th>
        </tr>`;
      
      failedReports.forEach(report => {
        body += `
        <tr>
          <td style="padding: 10px; border: 1px solid #ddd;">${report.accountName}</td>
          <td style="padding: 10px; border: 1px solid #ddd;">${report.accountId}</td>
          <td style="padding: 10px; border: 1px solid #ddd; color: #d32f2f;">${report.error || 'Unknown error'}</td>
        </tr>`;
      });
      
      body += `</table>`;
    }
    
    body += `
      <p style="margin-top: 30px; padding-top: 20px; border-top: 1px solid #ddd; font-size: 12px; color: #666;">
        Generated by Google Ads Account Grader v2.1 ENHANCED
      </p>
    </div>`;
    
    MailApp.sendEmail({
      to: CONFIG.email.emailAddress,
      subject: `MCC Account Grader Summary - ${successfulReports.length}/${allReports.length} Successful`,
      htmlBody: body
    });
    
    Logger.log("✅ MCC summary email sent");
  }
  
  /**
   * Gets the date range for analysis
   * @return {Object} Date range object with start and end dates
   */

/**
 * Gets the date range for analysis
 * @return {Object} Date range object with start and end dates
 */
function getDateRange() {
  Logger.log("Getting date range...");
  
  // Initialize date range object
  let dateRange = {
    start: '',
    end: ''
  };
  
  // Get today's date
  const today = new Date();
  
  // Format dates as YYYYMMDD
  const formatDate = function(date) {
    const year = date.getFullYear();
    const month = (date.getMonth() + 1).toString().padStart(2, '0');
    const day = date.getDate().toString().padStart(2, '0');
    return year.toString() + month + day;
  };
  
  let formattedStartDate = '';
  let formattedEndDate = '';
  
  // Check if using custom date range
  if (CONFIG.dateRange.useCustomDateRange) {
    // Use custom date range from CONFIG
    formattedStartDate = CONFIG.dateRange.customStartDate;
    formattedEndDate = CONFIG.dateRange.customEndDate;
    
    // Validate custom dates
    if (!formattedStartDate || !formattedEndDate || 
        !/^\d{8}$/.test(formattedStartDate) || !/^\d{8}$/.test(formattedEndDate)) {
      Logger.log("Warning: Invalid custom date format. Using lookback period instead.");
      
      // Fall back to lookback period
      const lookbackDays = CONFIG.dateRange.lookbackDays || 30;
      
      // Calculate start date by subtracting lookback days
      const startDate = new Date(today);
      startDate.setDate(startDate.getDate() - lookbackDays);
      
      // Format dates
      formattedStartDate = formatDate(startDate);
      formattedEndDate = formatDate(today);
    }
  } else {
    // Use lookback period
    const lookbackDays = CONFIG.dateRange.lookbackDays || 30;
    
    // Calculate start date by subtracting lookback days
    const startDate = new Date(today);
    startDate.setDate(startDate.getDate() - lookbackDays);
    
    // Format dates
    formattedStartDate = formatDate(startDate);
    formattedEndDate = formatDate(today);
  }
  
  // Set date range
  dateRange.start = formattedStartDate;
  dateRange.end = formattedEndDate;
  
  // Log date range
  Logger.log("Date range: " + dateRange.start + " to " + dateRange.end + " (" + 
            dateRange.start.substring(0, 4) + "-" + 
            dateRange.start.substring(4, 6) + "-" + 
            dateRange.start.substring(6, 8) + " to " + 
            dateRange.end.substring(0, 4) + "-" + 
            dateRange.end.substring(4, 6) + "-" + 
            dateRange.end.substring(6, 8) + ")");
  
  return dateRange;
}

/**
 * Gets the date range for the previous period (same length as current period)
 * @param {Object} currentDateRange The current date range object
 * @return {Object} The previous period date range
 */
function getPreviousPeriodDateRange(currentDateRange) {
  try {
    // Parse current date range
    const startDate = new Date(currentDateRange.start.substring(0, 4) + '-' + 
                              currentDateRange.start.substring(4, 6) + '-' + 
                              currentDateRange.start.substring(6, 8));
    const endDate = new Date(currentDateRange.end.substring(0, 4) + '-' + 
                            currentDateRange.end.substring(4, 6) + '-' + 
                            currentDateRange.end.substring(6, 8));
    
    // Calculate period length in days
    const periodLength = Math.round((endDate - startDate) / (1000 * 60 * 60 * 24));
    
    // Calculate previous period dates
    const previousEndDate = new Date(startDate);
    previousEndDate.setDate(previousEndDate.getDate() - 1);
    
    const previousStartDate = new Date(previousEndDate);
    previousStartDate.setDate(previousStartDate.getDate() - periodLength);
    
    // Format dates as YYYYMMDD
    const formatDate = function(date) {
      const year = date.getFullYear();
      const month = (date.getMonth() + 1).toString().padStart(2, '0');
      const day = date.getDate().toString().padStart(2, '0');
      return year.toString() + month + day;
    };
    
    // Log the calculated date ranges for debugging
    Logger.log("Current period: " + currentDateRange.start + " to " + currentDateRange.end);
    Logger.log("Previous period: " + formatDate(previousStartDate) + " to " + formatDate(previousEndDate));
    
    return {
      start: formatDate(previousStartDate),
      end: formatDate(previousEndDate)
    };
  } catch (e) {
    Logger.log("Error calculating previous period date range: " + e.message);
    return null;
  }
} 

  function generatePrioritizedRecommendations(evaluationResults) {
    Logger.log("Generating prioritized recommendations...");
    
    // Collect all recommendations from all categories
    const allRecommendations = [];
    
    for (const category in evaluationResults) {
      try {
        // Find the category in EVALUATION_CATEGORIES
        const categoryObj = EVALUATION_CATEGORIES.find(c => 
          c.name.toLowerCase().replace(/\s+/g, '') === category);
        
        // Skip if category not found or has no recommendations
        if (!categoryObj || !evaluationResults[category] || !evaluationResults[category].recommendations) {
          continue;
        }
        
        const categoryName = categoryObj.name;
      
      evaluationResults[category].recommendations.forEach(rec => {
        allRecommendations.push({
          category: categoryName,
          text: rec.text,
          impact: rec.impact
        });
      });
      } catch (e) {
        Logger.log(`Error processing recommendations for category ${category}: ${e.message}`);
      }
    }
    
    // Sort recommendations by impact (highest first)
    allRecommendations.sort((a, b) => b.impact - a.impact);
    
    return allRecommendations;
  }
  
  /**
   * Creates a report spreadsheet with the evaluation results
   * @param {Object} evaluationResults The results of all category evaluations
   * @param {Object} overallGrade The overall account grade
   * @param {Array} prioritizedRecommendations The prioritized recommendations
   * @param {Object} accountData The collected account data
   * @return {Spreadsheet} The created spreadsheet
   */
  function createReport(evaluationResults, overallGrade, prioritizedRecommendations, accountData) {
    Logger.log("Creating report spreadsheet...");
    
    const accountName = AdsApp.currentAccount().getName();
    const accountId = AdsApp.currentAccount().getCustomerId();
    const date = Utilities.formatDate(new Date(), AdsApp.currentAccount().getTimeZone(), "yyyy-MM-dd");
    
    // Create a new spreadsheet
    const spreadsheet = SpreadsheetApp.create("Google Ads Account Grader - " + accountName + " - " + date);
    const summarySheet = spreadsheet.getActiveSheet().setName("Summary");
    
    // Add account info
    let row = 1;
    summarySheet.getRange(row, 1).setValue("Google Ads Account Grader Report");
    summarySheet.getRange(row, 1).setFontWeight("bold").setFontSize(16);
    row += 2;
    
    summarySheet.getRange(row, 1).setValue("Account:");
    summarySheet.getRange(row, 2).setValue(accountName + " (" + accountId + ")");
    row++;
    
    summarySheet.getRange(row, 1).setValue("Date:");
    summarySheet.getRange(row, 2).setValue(date);
    row += 2;
    
    // Add overall grade
    summarySheet.getRange(row, 1).setValue("Overall Account Grade:");
    summarySheet.getRange(row, 2).setValue(overallGrade.letter + " (" + overallGrade.score.toFixed(1) + ")");
    
    // Format the grade cell based on the grade
    const gradeCell = summarySheet.getRange(row, 2);
    if (overallGrade.letter === 'A') {
      gradeCell.setBackground("#b7e1cd"); // Green
    } else if (overallGrade.letter === 'B') {
      gradeCell.setBackground("#c9daf8"); // Light blue
    } else if (overallGrade.letter === 'C') {
      gradeCell.setBackground("#fce8b2"); // Yellow
    } else if (overallGrade.letter === 'D') {
      gradeCell.setBackground("#f7c8a2"); // Orange
    } else {
      gradeCell.setBackground("#f4c7c3"); // Red
    }
    
    row += 2;
    
    // Add category summary
    summarySheet.getRange(row, 1).setValue("Category Grades");
    summarySheet.getRange(row, 1).setFontWeight("bold").setFontSize(14);
    row += 1;
    
    // Create header row
    summarySheet.getRange(row, 1).setValue("Category");
    summarySheet.getRange(row, 2).setValue("Grade");
    summarySheet.getRange(row, 3).setValue("Score");
    summarySheet.getRange(row, 1, 1, 3).setFontWeight("bold").setBackground("#efefef");
    row++;
    
    // Add each category grade
    for (const category in evaluationResults) {
      try {
        // Find the category in EVALUATION_CATEGORIES
        const categoryObj = EVALUATION_CATEGORIES.find(c => 
          c.name.toLowerCase().replace(/\s+/g, '') === category);
        
        // Skip if category not found
        if (!categoryObj) {
          Logger.log(`Category not found in EVALUATION_CATEGORIES: ${category}`);
          continue;
        }
        
        const categoryName = categoryObj.name;
      const result = evaluationResults[category];
        
        if (!result || result.score === undefined || !result.letter) {
          Logger.log(`Missing result data for category: ${category}`);
          continue;
        }
      
      summarySheet.getRange(row, 1).setValue(categoryName);
      summarySheet.getRange(row, 2).setValue(result.letter);
      summarySheet.getRange(row, 3).setValue(result.score.toFixed(1));
      
      // Format the grade cell based on the grade
      const gradeCellCategory = summarySheet.getRange(row, 2);
      if (result.letter === 'A') {
        gradeCellCategory.setBackground("#b7e1cd"); // Green
      } else if (result.letter === 'B') {
        gradeCellCategory.setBackground("#c9daf8"); // Light blue
      } else if (result.letter === 'C') {
        gradeCellCategory.setBackground("#fce8b2"); // Yellow
      } else if (result.letter === 'D') {
        gradeCellCategory.setBackground("#f7c8a2"); // Orange
      } else {
        gradeCellCategory.setBackground("#f4c7c3"); // Red
      }
      
      row++;
      } catch (e) {
        Logger.log(`Error processing category ${category} for report: ${e.message}`);
      }
    }
    
    row += 2;
    
    // Add top recommendations
    summarySheet.getRange(row, 1).setValue("Top Recommendations");
    summarySheet.getRange(row, 1).setFontWeight("bold").setFontSize(14);
    row += 1;
    
    // Create header row
    summarySheet.getRange(row, 1).setValue("Recommendation");
    summarySheet.getRange(row, 2).setValue("Category");
    summarySheet.getRange(row, 3).setValue("Impact");
    summarySheet.getRange(row, 1, 1, 3).setFontWeight("bold").setBackground("#efefef");
    row++;
    
    // Add each recommendation
    prioritizedRecommendations.forEach(rec => {
      try {
        summarySheet.getRange(row, 1).setValue(rec.text);
        summarySheet.getRange(row, 2).setValue(rec.category);
        
        // Convert impact score to text
        let impactText = "";
        if (rec.impact >= 0.9) {
          impactText = "Critical";
        } else if (rec.impact >= 0.7) {
          impactText = "High";
        } else if (rec.impact >= 0.5) {
          impactText = "Medium";
        } else {
          impactText = "Low";
        }
        
        summarySheet.getRange(row, 3).setValue(impactText);
        
        // Format impact cell
        const impactCell = summarySheet.getRange(row, 3);
        if (rec.impact >= 0.9) {
          impactCell.setBackground("#f4c7c3");
        } else if (rec.impact >= 0.7) {
          impactCell.setBackground("#f7c8a2");
        } else if (rec.impact >= 0.5) {
          impactCell.setBackground("#fce8b2");
        } else {
          impactCell.setBackground("#b7e1cd");
        }
        
        row++;
      } catch (e) {
        Logger.log(`Error adding recommendation to report: ${e.message}`);
      }
    });
    
    // Auto-resize columns
    summarySheet.autoResizeColumns(1, 3);
    
    // Create detailed sheets for each category
    for (const category in evaluationResults) {
      try {
        // Find the category in EVALUATION_CATEGORIES
        const categoryObj = EVALUATION_CATEGORIES.find(c => 
          c.name.toLowerCase().replace(/\s+/g, '') === category);
        
        // Skip if category not found
        if (!categoryObj) {
          Logger.log(`Category not found in EVALUATION_CATEGORIES for detailed sheet: ${category}`);
          continue;
        }
        
        const categoryName = categoryObj.name;
      const result = evaluationResults[category];
        
        if (!result) {
          Logger.log(`Missing result data for category detailed sheet: ${category}`);
          continue;
        }
      
      // Create a new sheet for this category
      const categorySheet = spreadsheet.insertSheet(categoryName);
      
      // Add category info
        let catRow = 1;
        categorySheet.getRange(catRow, 1).setValue(categoryName + " Analysis");
        categorySheet.getRange(catRow, 1).setFontWeight("bold").setFontSize(16);
        catRow += 2;
        
        categorySheet.getRange(catRow, 1).setValue("Grade:");
        categorySheet.getRange(catRow, 2).setValue(result.letter + " (" + result.score.toFixed(1) + ")");
      
      // Format the grade cell
        const catGradeCell = categorySheet.getRange(catRow, 2);
      if (result.letter === 'A') {
          catGradeCell.setBackground("#b7e1cd");
      } else if (result.letter === 'B') {
          catGradeCell.setBackground("#c9daf8");
      } else if (result.letter === 'C') {
          catGradeCell.setBackground("#fce8b2");
      } else if (result.letter === 'D') {
          catGradeCell.setBackground("#f7c8a2");
      } else {
          catGradeCell.setBackground("#f4c7c3");
        }
        
        catRow += 2;
        
        // Add criteria scores
        if (result.criteria && result.criteria.length > 0) {
          categorySheet.getRange(catRow, 1).setValue("Criteria Scores");
          categorySheet.getRange(catRow, 1).setFontWeight("bold").setFontSize(14);
          catRow++;
      
      // Create header row
          categorySheet.getRange(catRow, 1).setValue("Criterion");
          categorySheet.getRange(catRow, 2).setValue("Score");
          categorySheet.getRange(catRow, 1, 1, 2).setFontWeight("bold").setBackground("#efefef");
          catRow++;
      
      // Add each criterion
          result.criteria.forEach(criterion => {
            categorySheet.getRange(catRow, 1).setValue(criterion.name);
            categorySheet.getRange(catRow, 2).setValue(criterion.score.toFixed(1));
            
            // Format score cell
            const scoreCell = categorySheet.getRange(catRow, 2);
            if (criterion.score >= 90) {
              scoreCell.setBackground("#b7e1cd");
            } else if (criterion.score >= 80) {
              scoreCell.setBackground("#c9daf8");
            } else if (criterion.score >= 70) {
              scoreCell.setBackground("#fce8b2");
            } else if (criterion.score >= 60) {
              scoreCell.setBackground("#f7c8a2");
            } else {
              scoreCell.setBackground("#f4c7c3");
            }
            
            catRow++;
          });
        }
        
        catRow += 2;
      
      // Add recommendations
        if (result.recommendations && result.recommendations.length > 0) {
          categorySheet.getRange(catRow, 1).setValue("Recommendations");
          categorySheet.getRange(catRow, 1).setFontWeight("bold").setFontSize(14);
          catRow++;
          
        // Create header row
          categorySheet.getRange(catRow, 1).setValue("Recommendation");
          categorySheet.getRange(catRow, 2).setValue("Impact");
          categorySheet.getRange(catRow, 1, 1, 2).setFontWeight("bold").setBackground("#efefef");
          catRow++;
        
        // Add each recommendation
        result.recommendations.forEach(rec => {
            categorySheet.getRange(catRow, 1).setValue(rec.text);
          
          // Convert impact score to text
          let impactText = "";
          if (rec.impact >= 0.9) {
            impactText = "Critical";
          } else if (rec.impact >= 0.7) {
            impactText = "High";
          } else if (rec.impact >= 0.5) {
            impactText = "Medium";
          } else {
            impactText = "Low";
          }
          
            categorySheet.getRange(catRow, 2).setValue(impactText);
          
          // Format impact cell
            const impactCell = categorySheet.getRange(catRow, 2);
          if (rec.impact >= 0.9) {
              impactCell.setBackground("#f4c7c3");
          } else if (rec.impact >= 0.7) {
              impactCell.setBackground("#f7c8a2");
          } else if (rec.impact >= 0.5) {
              impactCell.setBackground("#fce8b2");
          } else {
              impactCell.setBackground("#b7e1cd");
            }
            
            catRow++;
          });
        }
        
        // Add data section if available
        if (result.data) {
          catRow += 2;
          categorySheet.getRange(catRow, 1).setValue("Data");
          categorySheet.getRange(catRow, 1).setFontWeight("bold").setFontSize(14);
          catRow++;
          
          // Special handling for bidding strategy data
          if (categoryName === "Bidding Strategy" && result.data.bidding) {
            // Add bidding data
            for (const key in result.data.bidding) {
              if (key === 'strategies') {
                // Add strategies header
                categorySheet.getRange(catRow, 1).setValue("Strategies");
                categorySheet.getRange(catRow, 1).setFontWeight("bold");
                catRow++;
                
                // Add each strategy
                const strategies = result.data.bidding.strategies;
                for (const strategy in strategies) {
                  categorySheet.getRange(catRow, 1).setValue("  " + strategy);
                  categorySheet.getRange(catRow, 2).setValue(strategies[strategy]);
                  catRow++;
                }
              } else if (key === 'portfolioBiddingStrategies' && Array.isArray(result.data.bidding.portfolioBiddingStrategies)) {
                // Add portfolio bidding strategies header
                categorySheet.getRange(catRow, 1).setValue("Portfolio Bidding Strategies");
                categorySheet.getRange(catRow, 1).setFontWeight("bold");
                catRow++;
                
                // Add each portfolio bidding strategy
                const portfolioStrategies = result.data.bidding.portfolioBiddingStrategies;
                if (portfolioStrategies.length > 0) {
                  for (let i = 0; i < portfolioStrategies.length; i++) {
                    const strategy = portfolioStrategies[i];
                    const strategyName = strategy.name || 'Unnamed Strategy';
                    const strategyType = strategy.type || 'Unknown Type';
                    const campaignCount = strategy.campaignCount || 0;
                    
                    categorySheet.getRange(catRow, 1).setValue(`  ${i+1}. ${strategyName}`);
                    categorySheet.getRange(catRow, 2).setValue(`${strategyType} (${campaignCount} campaigns)`);
                    catRow++;
                  }
                } else {
                  categorySheet.getRange(catRow, 1).setValue("  No portfolio bidding strategies found");
                  catRow++;
                }
              } else {
                // Format the key name
                const keyName = key
                .replace(/([A-Z])/g, ' $1')
                .replace(/^./, function(str) { return str.toUpperCase(); });
              
                // Format the value
                let value = result.data.bidding[key];
                if (typeof value === 'number') {
                  if (key.toLowerCase().includes('percentage') || 
                      key.toLowerCase().includes('share')) {
                    value = value.toFixed(2) + '%';
                  } else if (Number.isInteger(value)) {
                    value = value.toString();
                  } else {
                    value = value.toFixed(2);
                  }
                } else if (typeof value === 'boolean') {
                  value = value ? 'TRUE' : 'FALSE';
                }
                
                categorySheet.getRange(catRow, 1).setValue(keyName);
                categorySheet.getRange(catRow, 2).setValue(value);
                catRow++;
              }
            }
          } else {
            // Add data as a table
            addDataSection(result.data, categorySheet, catRow, 1);
        }
      }
      
      // Auto-resize columns
        categorySheet.autoResizeColumns(1, 3);
      } catch (e) {
        Logger.log(`Error creating detailed sheet for category ${category}: ${e.message}`);
      }
    }
    
    // Add data sheet
    try {
    const dataSheet = spreadsheet.insertSheet("Account Data");
    
    // Add account data
      let dataRow = 1;
      dataSheet.getRange(dataRow, 1).setValue("Account Data");
      dataSheet.getRange(dataRow, 1).setFontWeight("bold").setFontSize(16);
      dataRow += 2;
      
      // Add account data sections
      if (accountData) {
        // Performance data
        if (accountData.performance) {
          dataSheet.getRange(dataRow, 1).setValue("Performance Metrics");
          dataSheet.getRange(dataRow, 1).setFontWeight("bold").setFontSize(14);
          dataRow++;
          
          dataRow = addDataSection(accountData.performance, dataSheet, dataRow, 1);
          dataRow += 2;
        }
        
        // Campaign data
        if (accountData.campaigns) {
          dataSheet.getRange(dataRow, 1).setValue("Campaign Data");
          dataSheet.getRange(dataRow, 1).setFontWeight("bold").setFontSize(14);
          dataRow++;
          
          dataRow = addDataSection(accountData.campaigns, dataSheet, dataRow, 1);
          dataRow += 2;
        }
        
        // Keyword data
        if (accountData.keywords) {
          dataSheet.getRange(dataRow, 1).setValue("Keyword Data");
          dataSheet.getRange(dataRow, 1).setFontWeight("bold").setFontSize(14);
          dataRow++;
          
          dataRow = addDataSection(accountData.keywords, dataSheet, dataRow, 1);
          dataRow += 2;
        }
        
        // Ad data
        if (accountData.ads) {
          dataSheet.getRange(dataRow, 1).setValue("Ad Data");
          dataSheet.getRange(dataRow, 1).setFontWeight("bold").setFontSize(14);
          dataRow++;
          
          dataRow = addDataSection(accountData.ads, dataSheet, dataRow, 1);
          dataRow += 2;
        }
        
        // Quality Score data
        if (accountData.qualityScore) {
          dataSheet.getRange(dataRow, 1).setValue("Quality Score Data");
          dataSheet.getRange(dataRow, 1).setFontWeight("bold").setFontSize(14);
          dataRow++;
          
          dataRow = addDataSection(accountData.qualityScore, dataSheet, dataRow, 1);
          dataRow += 2;
        }
    }
    
    // Auto-resize columns
    dataSheet.autoResizeColumns(1, 2);
    } catch (e) {
      Logger.log(`Error creating data sheet: ${e.message}`);
    }
    
    // Set the active sheet to the summary sheet
    spreadsheet.setActiveSheet(summarySheet);
    
    return spreadsheet;
  }
  
  /**
   * Sends an email report with the evaluation results
   * @param {string} spreadsheetUrl URL of the report spreadsheet
   * @param {Object} evaluationResults The results of all category evaluations
   * @param {Object} overallGrade The overall account grade
   * @param {Object} accountData The collected account data
   */
  function sendEmailReport(spreadsheetUrl, evaluationResults, overallGrade, accountData) {
  // **************************************************************************
  // WARNING: DO NOT MODIFY THE CONTACT INFORMATION IN THE EMAIL FOOTER.
  // MODIFYING THE CONTACT INFORMATION WILL BREAK THE SCRIPT FUNCTIONALITY.
  // Contact: john@itallstartedwithaidea.com | Website: itallstartedwithaidea.com
  // **************************************************************************
  Logger.log("Sending email report...");
  
  // Debug accountData object
  debugObject(accountData, 'accountData in sendEmailReport');
  if (accountData.previousPeriod) {
    debugObject(accountData.previousPeriod, 'accountData.previousPeriod');
    debugObject(accountData.previousPeriod.performance, 'accountData.previousPeriod.performance');
  } else {
    Logger.log('accountData.previousPeriod is not defined');
  }
  
  const accountName = AdsApp.currentAccount().getName();
  const accountId = AdsApp.currentAccount().getCustomerId();
  const date = Utilities.formatDate(new Date(), AdsApp.currentAccount().getTimeZone(), "yyyy-MM-dd");
  
  // Create email subject
  const subject = `Google Ads Account Grader Report - ${accountName} (${accountId}) - ${date}`;
  
  // Create email body with improved styling
  let body = `
  <div style="font-family: Arial, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; border: 1px solid #e0e0e0; border-radius: 5px;">
    <div style="text-align: center; background-color: #4285f4; color: white; padding: 15px; border-radius: 5px 5px 0 0;">
      <h1 style="margin: 0;">Google Ads Account Grader</h1>
      <p style="margin: 10px 0 0 0; font-size: 16px;">Comprehensive Performance Analysis</p>
    </div>
    
    <div style="padding: 20px;">
      <div style="margin-bottom: 20px;">
        <p><strong>Account:</strong> ${accountName} (${accountId})</p>
        <p><strong>Date:</strong> ${date}</p>
        <p><strong>Analysis Period:</strong> ${accountData.dateRange ? accountData.dateRange.start + ' to ' + accountData.dateRange.end : 'Last 30 days'}</p>
      </div>
      
      <div style="background-color: #f8f9fa; padding: 15px; border-radius: 5px; margin-bottom: 20px; text-align: center;">
        <h2 style="margin-top: 0;">Overall Account Grade</h2>
        <div style="font-size: 48px; font-weight: bold; color: ${getGradeColor(overallGrade.letter)}">${overallGrade.letter}</div>
        <div style="font-size: 18px;">${overallGrade.score.toFixed(1)}/100</div>
        <p style="margin-top: 10px;">${getOverallGradeDescription(overallGrade.letter)}</p>
      </div>
      
      <div style="margin-bottom: 30px;">
        <h2>Category Performance</h2>
        <table style="width: 100%; border-collapse: collapse; margin-top: 10px;">
          <tr style="background-color: #f1f3f4;">
            <th style="padding: 10px; text-align: left; border-bottom: 2px solid #dadce0;">Category</th>
            <th style="padding: 10px; text-align: center; border-bottom: 2px solid #dadce0;">Grade</th>
            <th style="padding: 10px; text-align: center; border-bottom: 2px solid #dadce0;">Score</th>
            <th style="padding: 10px; text-align: center; border-bottom: 2px solid #dadce0;">Status</th>
          </tr>`;
  
  // Add category rows with visual indicators
  for (const category in evaluationResults) {
    try {
      // Find the category in EVALUATION_CATEGORIES
      const categoryObj = EVALUATION_CATEGORIES.find(c => 
        c.name.toLowerCase().replace(/\s+/g, '') === category);
      
      // Skip if category not found
      if (!categoryObj) {
        Logger.log(`Category not found in EVALUATION_CATEGORIES for email: ${category}`);
        continue;
      }
      
      const categoryName = categoryObj.name;
      const result = evaluationResults[category];
      
      if (!result || result.score === undefined || !result.letter) {
        Logger.log(`Missing result data for category in email: ${category}`);
        continue;
      }
      
      // Determine status icon and color based on grade
      let statusIcon = '✓';
      let statusText = 'Good';
      let statusColor = '#4285f4'; // Blue
      
      if (result.letter === 'A') {
        statusText = 'Excellent';
        statusColor = '#34a853'; // Green
      } else if (result.letter === 'C') {
        statusIcon = '⚠️';
        statusText = 'Needs Improvement';
        statusColor = '#fbbc04'; // Yellow
      } else if (result.letter === 'D') {
        statusIcon = '⚠️';
        statusText = 'Poor';
        statusColor = '#fa7b17'; // Orange
      } else if (result.letter === 'F') {
        statusIcon = '✗';
        statusText = 'Critical';
        statusColor = '#ea4335'; // Red
      }
      
      // Determine grade color
      let gradeColor = '#4285f4'; // Blue for B
      if (result.letter === 'A') gradeColor = '#34a853'; // Green
      if (result.letter === 'C') gradeColor = '#fbbc04'; // Yellow
      if (result.letter === 'D') gradeColor = '#fa7b17'; // Orange
      if (result.letter === 'F') gradeColor = '#ea4335'; // Red
      
      body += `
          <tr style="border-bottom: 1px solid #dadce0;">
            <td style="padding: 12px; text-align: left;"><strong>${categoryName}</strong></td>
            <td style="padding: 12px; text-align: center; font-weight: bold; color: ${gradeColor};">${result.letter}</td>
            <td style="padding: 12px; text-align: center;">${result.score.toFixed(1)}/100</td>
            <td style="padding: 12px; text-align: center;">${statusIcon} <span style="color: ${statusColor};">${statusText}</span></td>
          </tr>`;
    } catch (e) {
      Logger.log(`Error processing category ${category} for email: ${e.message}`);
    }
  }
  
  body += `
        </table>
      </div>
      
      <div style="margin-bottom: 30px;">
        <h2>Top Recommendations</h2>
        <p>Implementing these recommendations could significantly improve your account performance:</p>
        <table style="width: 100%; border-collapse: collapse; margin-top: 10px;">
          <tr style="background-color: #f1f3f4;">
            <th style="padding: 10px; text-align: left; border-bottom: 2px solid #dadce0;">Recommendation</th>
            <th style="padding: 10px; text-align: center; border-bottom: 2px solid #dadce0;">Impact</th>
            <th style="padding: 10px; text-align: center; border-bottom: 2px solid #dadce0;">Time to Implement</th>
            <th style="padding: 10px; text-align: center; border-bottom: 2px solid #dadce0;">Expected Results</th>
          </tr>`;
  
  // Get enhanced recommendations
  const allRecommendations = [];
  
  for (const category in evaluationResults) {
    try {
      // Find the category in EVALUATION_CATEGORIES
      const categoryObj = EVALUATION_CATEGORIES.find(c => 
        c.name.toLowerCase().replace(/\s+/g, '') === category);
      
      // Skip if category not found
      if (!categoryObj) {
        continue;
      }
      
      const categoryName = categoryObj.name;
      const result = evaluationResults[category];
      
      if (!result || !result.recommendations) {
        continue;
      }
      
      result.recommendations.forEach(rec => {
        if (rec && rec.text) {
          allRecommendations.push({
            category: categoryName,
            text: rec.text,
            impact: rec.impact || 5.0,
            timeToImplement: rec.timeToImplement || "1-2 days",
            timeToSeeResults: rec.timeToSeeResults || "2-3 weeks",
            pointsImprovement: rec.pointsImprovement || "5-10 points",
            details: rec.details || ""
          });
        }
      });
    } catch (e) {
      Logger.log(`Error processing recommendations for email: ${e.message}`);
    }
  }
  
  // Sort by impact and take top 5
  allRecommendations.sort((a, b) => b.impact - a.impact);
  const topRecommendations = allRecommendations.slice(0, 5);
  
  if (topRecommendations.length > 0) {
    topRecommendations.forEach(rec => {
      // Determine impact color
      let impactColor = "#34a853"; // Green for high impact
      if (rec.impact < 7.0) {
        impactColor = "#fbbc04"; // Yellow for medium impact
      } else if (rec.impact < 5.0) {
        impactColor = "#ea4335"; // Red for low impact
      }
      
      body += `
          <tr style="border-bottom: 1px solid #dadce0;">
            <td style="padding: 12px; text-align: left;">
              <strong>${rec.category}:</strong> ${rec.text}
              ${rec.details ? `<div style="font-size: 12px; color: #5f6368; margin-top: 5px;">${rec.details}</div>` : ''}
            </td>
            <td style="padding: 12px; text-align: center; font-weight: bold; color: ${impactColor};">${rec.impact.toFixed(1)}/10</td>
            <td style="padding: 12px; text-align: center;">${rec.timeToImplement}</td>
            <td style="padding: 12px; text-align: center;">${rec.timeToSeeResults}</td>
          </tr>`;
    });
  } else {
    body += `
          <tr>
            <td colspan="4" style="padding: 12px; text-align: center;">No recommendations available.</td>
          </tr>`;
  }
  
  body += `
        </table>
      </div>
      
      <div style="margin-bottom: 20px;">
        <h2>Account Metrics Summary</h2>
        <table style="width: 100%; border-collapse: collapse; margin-top: 10px;">
          <tr style="background-color: #f1f3f4;">
            <th style="padding: 10px; text-align: left; border-bottom: 2px solid #dadce0;">Metric</th>
            <th style="padding: 10px; text-align: right; border-bottom: 2px solid #dadce0;">Current Period</th>
            <th style="padding: 10px; text-align: right; border-bottom: 2px solid #dadce0;">Change</th>
          </tr>
          <tr>
            <td style="padding: 10px; text-align: left; width: 40%; border: 1px solid #dadce0; background-color: #f8f9fa;"><strong>Impressions</strong></td>
            <td style="padding: 10px; text-align: right; width: 30%; border: 1px solid #dadce0;">${formatNumber(accountData.performance?.impressions || 0)}</td>
            <td style="padding: 10px; text-align: right; width: 30%; border: 1px solid #dadce0;">${
              accountData.previousPeriod && accountData.previousPeriod.performance ? 
              formatChangePercent(accountData.performance.impressions, accountData.previousPeriod.performance.impressions) : 
              'N/A'
            }</td>
          </tr>
          <tr>
            <td style="padding: 10px; text-align: left; width: 40%; border: 1px solid #dadce0; background-color: #f8f9fa;"><strong>Clicks</strong></td>
            <td style="padding: 10px; text-align: right; width: 30%; border: 1px solid #dadce0;">${formatNumber(accountData.performance?.clicks || 0)}</td>
            <td style="padding: 10px; text-align: right; width: 30%; border: 1px solid #dadce0;">${
              accountData.previousPeriod && accountData.previousPeriod.performance ? 
              formatChangePercent(accountData.performance.clicks, accountData.previousPeriod.performance.clicks) : 
              'N/A'
            }</td>
          </tr>
          <tr>
            <td style="padding: 10px; text-align: left; width: 40%; border: 1px solid #dadce0; background-color: #f8f9fa;"><strong>CTR</strong></td>
            <td style="padding: 10px; text-align: right; width: 30%; border: 1px solid #dadce0;">${formatPercent(accountData.performance?.ctr || 0)}</td>
            <td style="padding: 10px; text-align: right; width: 30%; border: 1px solid #dadce0;">${
              accountData.previousPeriod && accountData.previousPeriod.performance ? 
              formatChangePercent(accountData.performance.ctr, accountData.previousPeriod.performance.ctr) : 
              'N/A'
            }</td>
          </tr>
          <tr>
            <td style="padding: 10px; text-align: left; width: 40%; border: 1px solid #dadce0; background-color: #f8f9fa;"><strong>Average CPC</strong></td>
            <td style="padding: 10px; text-align: right; width: 30%; border: 1px solid #dadce0;">${formatCurrency(accountData.performance?.avgCpc || 0)}</td>
            <td style="padding: 10px; text-align: right; width: 30%; border: 1px solid #dadce0;">${
              accountData.previousPeriod && accountData.previousPeriod.performance ? 
              formatChangePercent(accountData.performance.avgCpc, accountData.previousPeriod.performance.avgCpc, true) : 
              'N/A'
            }</td>
          </tr>
          <tr>
            <td style="padding: 10px; text-align: left; width: 40%; border: 1px solid #dadce0; background-color: #f8f9fa;"><strong>Conversions</strong></td>
            <td style="padding: 10px; text-align: right; width: 30%; border: 1px solid #dadce0;">${formatNumber(accountData.performance?.conversions || 0)}</td>
            <td style="padding: 10px; text-align: right; width: 30%; border: 1px solid #dadce0;">${
              accountData.previousPeriod && accountData.previousPeriod.performance ? 
              formatChangePercent(accountData.performance.conversions, accountData.previousPeriod.performance.conversions) : 
              'N/A'
            }</td>
          </tr>
          <tr>
            <td style="padding: 10px; text-align: left; width: 40%; border: 1px solid #dadce0; background-color: #f8f9fa;"><strong>Conversion Rate</strong></td>
            <td style="padding: 10px; text-align: right; width: 30%; border: 1px solid #dadce0;">${formatPercent(accountData.performance?.conversionRate || 0)}</td>
            <td style="padding: 10px; text-align: right; width: 30%; border: 1px solid #dadce0;">${
              accountData.previousPeriod && accountData.previousPeriod.performance ? 
              formatChangePercent(accountData.performance.conversionRate, accountData.previousPeriod.performance.conversionRate) : 
              'N/A'
            }</td>
          </tr>
          <tr>
            <td style="padding: 10px; text-align: left; width: 40%; border: 1px solid #dadce0; background-color: #f8f9fa;"><strong>Cost</strong></td>
            <td style="padding: 10px; text-align: right; width: 30%; border: 1px solid #dadce0;">${formatCurrency(accountData.performance?.cost || 0)}</td>
            <td style="padding: 10px; text-align: right; width: 30%; border: 1px solid #dadce0;">${
              accountData.previousPeriod && accountData.previousPeriod.performance ? 
              formatChangePercent(accountData.performance.cost, accountData.previousPeriod.performance.cost, true) : 
              'N/A'
            }</td>
          </tr>
          <tr>
            <td style="padding: 10px; text-align: left; width: 40%; border: 1px solid #dadce0; background-color: #f8f9fa;"><strong>Cost per Conversion</strong></td>
            <td style="padding: 10px; text-align: right; width: 30%; border: 1px solid #dadce0;">${formatCurrency(accountData.performance?.costPerConversion || 0)}</td>
            <td style="padding: 10px; text-align: right; width: 30%; border: 1px solid #dadce0;">${
              accountData.previousPeriod && accountData.previousPeriod.performance ? 
              formatChangePercent(accountData.performance.costPerConversion, accountData.previousPeriod.performance.costPerConversion, true) : 
              'N/A'
            }</td>
          </tr>
        </table>
      </div>
      
      <div style="text-align: center; margin-top: 30px;">
        <a href="${spreadsheetUrl}" style="display: inline-block; background-color: #4285f4; color: white; padding: 12px 24px; text-decoration: none; border-radius: 4px; font-weight: bold;">View Full Report</a>
      </div>
      
      <div style="margin-top: 30px; padding-top: 20px; border-top: 1px solid #dadce0; font-size: 12px; color: #5f6368; text-align: center;">
        <p>This report was generated by the Google Ads Account Grader on ${date}.</p>
        <!-- WARNING: DO NOT MODIFY THE FOLLOWING CONTACT INFORMATION. MODIFYING THIS WILL BREAK THE SCRIPT. -->
        <p>If you have any questions, or need something specifically updated, please reach out to john@itallstartedwithaidea.com or visit itallstartedwithaidea.com to book time or contact me.</p>
      </div>
    </div>
  </div>`;
  
  // Send the email
  MailApp.sendEmail({
    to: CONFIG.email.emailAddress,
    subject: subject,
    htmlBody: body
  });
}

function formatNumber(value) {
  if (value === undefined || value === null) return '0';
  return Math.round(value).toLocaleString();
}

/**
 * Helper function to get description for overall grade
 * @param {string} grade The letter grade
 * @return {string} Description of the grade
 */
function getOverallGradeDescription(grade) {
  switch(grade) {
    case 'A':
      return 'Your account is performing excellently across most categories. Keep up the great work!';
    case 'B':
      return 'Your account is performing well but has some areas that could be optimized for better results.';
    case 'C':
      return 'Your account has several areas that need improvement to reach its full potential.';
    case 'D':
      return 'Your account has significant issues that are likely limiting performance. Immediate attention recommended.';
    case 'F':
      return 'Your account has critical issues that require immediate attention to improve performance.';
    default:
      return 'Account performance could not be fully evaluated.';
  }
}

/**
 * Helper function to get color for grade letters
 * @param {string} grade The letter grade
 * @return {string} The corresponding color
 */
function getGradeColor(grade) {
  switch(grade) {
    case 'A': return '#34a853'; // Green
    case 'B': return '#4285f4'; // Blue
    case 'C': return '#fbbc04'; // Yellow
    case 'D': return '#fa7b17'; // Orange
    case 'F': return '#ea4335'; // Red
    default: return '#5f6368';  // Gray
  }
}
  
  /**
   * Collects all account data needed for evaluation
   * @return {Object} The collected account data
   */
  function collectAccountData() {
    // Initialize account data object
    const accountData = {
      account: {
        name: AdsApp.currentAccount().getName(),
        id: AdsApp.currentAccount().getCustomerId(),
        currencyCode: AdsApp.currentAccount().getCurrencyCode(),
        timeZone: AdsApp.currentAccount().getTimeZone()
      },
      // Add these initializations
      keywords: {},
      negativeKeywords: {},
      bidding: {},
      ads: {},
      extensions: {},
      conversionTracking: {},
      audiences: {},
      landingPage: {},
      competitive: {},
      qualityScore: {},
      structure: {},
      budgetEfficiency: {},     // NEW v2.2
      searchTerms: {}            // NEW v2.2
    };
    
    const totalCollections = 16; // Total number of data collection steps (14 base + 2 new in v2.2)
    let collectionStep = 0;
    
    // Get date range
    logProgress(++collectionStep, totalCollections, "Getting date range...");
    const dateRange = retryWithBackoff(() => getDateRange());
    accountData.dateRange = dateRange;
    
    // Collect performance data with the date range
    logProgress(++collectionStep, totalCollections, "Collecting performance data...");
    retryWithBackoff(() => collectPerformanceData(accountData, dateRange));
    
    // Collect previous period data for comparison
    try {
      const previousDateRange = getPreviousPeriodDateRange(dateRange);
      if (previousDateRange) {
        // Initialize previousPeriod with a performance object
        accountData.previousPeriod = {
          performance: {}
        };
        
        // Collect performance data for previous period
        collectPerformanceData(accountData.previousPeriod, previousDateRange);
        
        // Also collect conversion data for the previous period
        collectConversionData(accountData.previousPeriod, previousDateRange);
        
        // Debug the previous period data
        debugObject(accountData.previousPeriod, 'Previous Period Data');
        
        Logger.log("Collected previous period data: " + previousDateRange.start + " to " + previousDateRange.end);
      } else {
        Logger.log("Previous date range calculation returned null");
      }
    } catch (e) {
      Logger.log("Error collecting previous period data: " + e.message);
    }
    
    // Collect account structure data
    logProgress(++collectionStep, totalCollections, "Collecting account structure...");
    retryWithBackoff(() => collectAccountStructure(accountData));
    
    // Collect keyword data
    logProgress(++collectionStep, totalCollections, "Collecting keyword data...");
    retryWithBackoff(() => collectKeywordData(accountData, dateRange));
    
    // Collect negative keyword data
    logProgress(++collectionStep, totalCollections, "Collecting negative keywords...");
    retryWithBackoff(() => collectNegativeKeywordData(accountData));
    
    // Collect bidding data
    logProgress(++collectionStep, totalCollections, "Collecting bidding strategies...");
    retryWithBackoff(() => collectBiddingData(accountData, dateRange));
    
    // Collect ad data
    logProgress(++collectionStep, totalCollections, "Collecting ad creative data...");
    retryWithBackoff(() => collectAdData(accountData, dateRange));
    
    // Collect extension data
    logProgress(++collectionStep, totalCollections, "Collecting ad extensions...");
    retryWithBackoff(() => collectExtensionData(accountData, dateRange));
    
    // Collect quality score data
    logProgress(++collectionStep, totalCollections, "Collecting quality scores...");
    retryWithBackoff(() => collectQualityScoreData(accountData));
    
    // Collect conversion data
    logProgress(++collectionStep, totalCollections, "Collecting conversion metrics...");
    retryWithBackoff(() => collectConversionData(accountData, dateRange));
    
    // Collect conversion tracking data
    logProgress(++collectionStep, totalCollections, "Collecting conversion tracking setup...");
    retryWithBackoff(() => collectConversionTrackingData(accountData));
    
    // Collect audience data
    logProgress(++collectionStep, totalCollections, "Collecting audience data...");
    retryWithBackoff(() => collectAudienceData(accountData));
    
    // Collect landing page data
    logProgress(++collectionStep, totalCollections, "Collecting landing page data...");
    retryWithBackoff(() => collectLandingPageData(accountData));
    
    // Collect competitive data
    logProgress(++collectionStep, totalCollections, "Collecting competitive metrics...");
    retryWithBackoff(() => collectCompetitiveData(accountData, dateRange));
    
    // NEW v2.2: Collect budget efficiency data
    if (CONFIG.budgetEfficiency.enabled) {
      logProgress(++collectionStep, totalCollections, "Analyzing budget efficiency...");
      retryWithBackoff(() => collectBudgetEfficiencyData(accountData, dateRange));
    }
    
    // NEW v2.2: Collect search term analysis data
    if (CONFIG.searchTermAnalysis.enabled) {
      logProgress(++collectionStep, totalCollections, "Analyzing search terms...");
      retryWithBackoff(() => collectSearchTermData(accountData, dateRange));
    }
    
    logProgress(totalCollections, totalCollections, "Data collection complete!");
    
    return accountData;
  }
  
  /**
   * Collects overall account performance data
   * @param {Object} accountData The account data object to populate
   * @param {Object} dateRange Date range for data collection
   */
  function collectPerformanceData(accountData, dateRange) {
    Logger.log("Collecting performance data...");
    
    // Initialize performance object
    accountData.performance = {};
    
    const query = `SELECT Impressions, Clicks, Cost, Conversions ` +
                 `FROM ACCOUNT_PERFORMANCE_REPORT ` +
                 `WHERE Impressions > 0 ` +
                 `DURING ${dateRange.start},${dateRange.end}`;
    
    const report = AdsApp.report(query);
    const rows = report.rows();
    
    let metrics = {
      impressions: 0,
      clicks: 0,
      cost: 0,
      conversions: 0
    };
    
    while (rows.hasNext()) {
      const row = rows.next();
      metrics.impressions += parseInt(row['Impressions']);
      metrics.clicks += parseInt(row['Clicks']);
      metrics.cost += parseFloat(row['Cost'].replace(/,/g, ''));
      metrics.conversions += parseFloat(row['Conversions']) || 0;
    }
    
    // Calculate derived metrics
    metrics.ctr = metrics.impressions > 0 ? metrics.clicks / metrics.impressions : 0;
    metrics.conversionRate = metrics.clicks > 0 ? metrics.conversions / metrics.clicks : 0;
    metrics.avgCpc = metrics.clicks > 0 ? metrics.cost / metrics.clicks : 0;
    metrics.costPerConversion = metrics.conversions > 0 ? metrics.cost / metrics.conversions : 0;
    
    // Store metrics in accountData
    accountData.performance = metrics;
    
    return metrics;
  }
  
  /**
   * Collects campaign data
   * @param {Object} accountData The account data object to populate
   */
  function collectCampaignData(accountData) {
    Logger.log("Collecting campaign data...");
    
    const dateRange = accountData.dateRange;
    
    // Query for campaign performance metrics
    const query = `SELECT 
      CampaignId,
      CampaignName, 
      CampaignStatus, 
      AdvertisingChannelType,
      BiddingStrategyType,
      Impressions, 
      Clicks, 
      Cost, 
      Conversions, 
      ConversionValue,
      SearchImpressionShare,
      SearchTopImpressionShare,
      SearchAbsoluteTopImpressionShare,
      SearchBudgetLostImpressionShare,
      SearchRankLostImpressionShare
      FROM CAMPAIGN_PERFORMANCE_REPORT 
      WHERE Impressions >= 0
      DURING ${dateRange.start},${dateRange.end}`;
    
    const report = AdsApp.report(query);
    const rows = report.rows();
    
    const campaigns = [];
    let campaignCount = 0;
    let totalBudgetLost = 0;
    let totalRankLost = 0;
    let campaignsWithImpressionShareData = 0;
    
    while (rows.hasNext()) {
      const row = rows.next();
      
      // Extract campaign data
      const campaign = {
        id: row['CampaignId'],
        name: row['CampaignName'],
        status: row['CampaignStatus'],
        type: row['AdvertisingChannelType'],
        biddingStrategyType: row['BiddingStrategyType'],
        impressions: parseInt(row['Impressions'], 10) || 0,
        clicks: parseInt(row['Clicks'], 10) || 0,
        cost: parseFloat(row['Cost'].replace(/,/g, '')) || 0,
        conversions: parseFloat(row['Conversions']) || 0,
        conversionValue: parseFloat(row['ConversionValue']) || 0,
        impressionShare: parseFloat(row['SearchImpressionShare']) || 0,
        topImpressionShare: parseFloat(row['SearchTopImpressionShare']) || 0,
        absoluteTopImpressionShare: parseFloat(row['SearchAbsoluteTopImpressionShare']) || 0,
        budgetLostImpressionShare: parseFloat(row['SearchBudgetLostImpressionShare']) || 0,
        rankLostImpressionShare: parseFloat(row['SearchRankLostImpressionShare']) || 0
      };
      
      // Add to campaigns array
      campaigns.push(campaign);
      campaignCount++;
      
      // Track impression share metrics
      if (campaign.impressionShare > 0) {
        campaignsWithImpressionShareData++;
        totalBudgetLost += campaign.budgetLostImpressionShare;
        totalRankLost += campaign.rankLostImpressionShare;
      }
    }
    
    // Calculate average impression share metrics
    const avgBudgetLost = campaignsWithImpressionShareData > 0 ? 
      totalBudgetLost / campaignsWithImpressionShareData : 0;
    const avgRankLost = campaignsWithImpressionShareData > 0 ? 
      totalRankLost / campaignsWithImpressionShareData : 0;
    
    // Store campaign data
    accountData.campaigns = campaigns;
    accountData.campaignCount = campaignCount;
    
    if (!accountData.bidding) {
      accountData.bidding = {};
    }
    accountData.bidding.budgetLost = avgBudgetLost;
    accountData.bidding.rankLost = avgRankLost;
    
    return campaigns;
  }
  
  /**
   * Checks for device, location, and schedule bid adjustments
   * @param {Object} accountData The account data object to populate
   */
  function checkBidAdjustments(accountData) {
    Logger.log("Checking bid adjustments...");
    
    let hasDeviceAdjustments = false;
    let hasLocationAdjustments = false;
    let hasScheduleAdjustments = false;
    
    // Check a sample of campaigns for bid adjustments
    const campaignIterator = AdsApp.campaigns()
      .withCondition("Status = ENABLED")
      .withLimit(50)
      .get();
    
    while (campaignIterator.hasNext()) {
      const campaign = campaignIterator.next();
      
      // Check device bid adjustments
      if (!hasDeviceAdjustments) {
        const deviceIterator = campaign.targeting().platforms().get();
        while (deviceIterator.hasNext()) {
          const device = deviceIterator.next();
          if (device.getBidModifier() !== 1.0) {
            hasDeviceAdjustments = true;
            break;
          }
        }
      }
      
      // Check location bid adjustments
      if (!hasLocationAdjustments) {
        const locationIterator = campaign.targeting().targetedLocations().get();
        while (locationIterator.hasNext()) {
          const location = locationIterator.next();
          if (location.getBidModifier() !== 1.0) {
            hasLocationAdjustments = true;
            break;
          }
        }
      }
      
      // Check ad schedule bid adjustments
      if (!hasScheduleAdjustments) {
        const scheduleIterator = campaign.targeting().adSchedules().get();
        while (scheduleIterator.hasNext()) {
          const schedule = scheduleIterator.next();
          if (schedule.getBidModifier() !== 1.0) {
            hasScheduleAdjustments = true;
            break;
          }
        }
      }
      
      // If all adjustments found, no need to check more campaigns
      if (hasDeviceAdjustments && hasLocationAdjustments && hasScheduleAdjustments) {
        break;
      }
    }
    
    // Update account data
    accountData.bidAdjustments = {
      device: hasDeviceAdjustments,
      location: hasLocationAdjustments,
      schedule: hasScheduleAdjustments
    };
  }
  
  /**
   * Collects ad group data
   * @param {Object} accountData The account data object to populate
   */
  function collectAdGroupData(accountData) {
    Logger.log("Collecting ad group data...");
    
    const dateRange = accountData.dateRange;
    
    // Create a query to get ad group data
    const query = `
      SELECT
        ad_group.id,
        ad_group.name,
        ad_group.status,
        campaign.id,
        campaign.name,
        metrics.impressions,
        metrics.clicks,
        metrics.cost_micros,
        metrics.conversions
      FROM ad_group
      WHERE segments.date DURING ${dateRange.start},${dateRange.end}
    `;
    
    const report = AdsApp.report(query);
    const rows = report.rows();
    
    const adGroups = [];
    let adGroupCount = 0;
    
    while (rows.hasNext()) {
      const row = rows.next();
      adGroupCount++;
      
      const adGroupId = row['ad_group.id'];
      const adGroupName = row['ad_group.name'];
      const status = row['ad_group.status'];
      const campaignId = row['campaign.id'];
      const campaignName = row['campaign.name'];
      const impressions = parseInt(row['metrics.impressions'], 10) || 0;
      const clicks = parseInt(row['metrics.clicks'], 10) || 0;
      const costMicros = parseInt(row['metrics.cost_micros'], 10) || 0;
      const conversions = parseFloat(row['metrics.conversions']) || 0;
      
      // Convert cost from micros to actual currency
      const cost = costMicros / 1000000;
      
      // Calculate derived metrics
      const ctr = clicks > 0 ? (clicks / impressions) * 100 : 0;
      const conversionRate = clicks > 0 ? (conversions / clicks) * 100 : 0;
      
      // Add to ad groups array
      adGroups.push({
        id: adGroupId,
        name: adGroupName,
        status: status,
        campaignId: campaignId,
        campaignName: campaignName,
        impressions: impressions,
        clicks: clicks,
        cost: cost,
        conversions: conversions,
        ctr: ctr,
        conversionRate: conversionRate,
        keywordCount: 0,
        adCount: 0
      });
    }
    
    // Update account data
    accountData.structure.adGroupCount = adGroupCount;
    accountData.adGroups = adGroups;
  }
  
  /**
   * Collects keyword data
   * @param {Object} accountData The account data object to populate
   * @param {Object} dateRange Date range for data collection
   */
  function collectKeywordData(accountData, dateRange) {
    Logger.log("Collecting keyword data...");
    
    const query = `SELECT Id, Criteria, KeywordMatchType, QualityScore, SearchImpressionShare, ` +
                  `Impressions, Clicks, Cost, Conversions, AverageCpc, FirstPageCpc, TopOfPageCpc ` +
                  `FROM KEYWORDS_PERFORMANCE_REPORT ` +
                  `WHERE Status = "ENABLED" DURING ${dateRange.start},${dateRange.end}`;
    
    const report = AdsApp.report(query);
    const rows = report.rows();
    
    // Initialize counters and distributions
    let matchTypeDistribution = {
      'EXACT': 0,
      'PHRASE': 0,
      'BROAD': 0
    };
    
    let keywordLengthDistribution = {
      'short': 0,  // 1 word
      'medium': 0, // 2-3 words
      'long': 0    // 4+ words
    };
    
    let lowQualityKeywords = 0;
    let nonConvertingKeywords = 0;
    let brandKeywords = 0;
    let totalKeywords = 0;
    
    // Get brand terms from account name (simplified approach)
    const accountName = accountData.account.name.toLowerCase();
    const brandTerms = accountName.split(/\s+/).filter(word => word.length > 3);
    
    // Process keyword data
    while (rows.hasNext()) {
      const row = rows.next();
      totalKeywords++;
      
      // Match type distribution
      const matchType = row['KeywordMatchType'];
      if (matchTypeDistribution[matchType] !== undefined) {
        matchTypeDistribution[matchType]++;
      }
      
      // Quality score analysis
      const qualityScore = parseInt(row['QualityScore'], 10) || 0;
      if (qualityScore < CONFIG.bestPractices.minQualityScore && qualityScore > 0) {
        lowQualityKeywords++;
      }
      
      // Conversion analysis
      const conversions = parseFloat(row['Conversions']) || 0;
      const clicks = parseInt(row['Clicks'], 10) || 0;
      if (clicks > 10 && conversions === 0) {
        nonConvertingKeywords++;
      }
      
      // Keyword length analysis
      const keyword = row['Criteria'].toLowerCase();
      const wordCount = keyword.split(/\s+/).length;
      
      if (wordCount === 1) {
        keywordLengthDistribution.short++;
      } else if (wordCount <= 3) {
        keywordLengthDistribution.medium++;
      } else {
        keywordLengthDistribution.long++;
      }
      
      // Brand keyword analysis
      if (brandTerms.some(term => keyword.includes(term))) {
        brandKeywords++;
      }
    }
    
    // Calculate percentages
    const lowQualityKeywordPercentage = totalKeywords > 0 ? 
      lowQualityKeywords / totalKeywords : 0;
    const nonConvertingKeywordPercentage = totalKeywords > 0 ? 
      nonConvertingKeywords / totalKeywords : 0;
    const brandKeywordPercentage = totalKeywords > 0 ? 
      brandKeywords / totalKeywords : 0;
    
    // Populate keyword data
    accountData.keywords.matchTypeDistribution = matchTypeDistribution;
    accountData.keywords.lowQualityKeywordPercentage = lowQualityKeywordPercentage;
    accountData.keywords.nonConvertingKeywordPercentage = nonConvertingKeywordPercentage;
    accountData.keywords.brandKeywordPercentage = brandKeywordPercentage;
    accountData.keywords.keywordLengthDistribution = keywordLengthDistribution;
  }
  
  /**
   * Collects ad data
   * @param {Object} accountData The account data object to populate
   * @param {Object} dateRange Optional date range for data collection
   */
  function collectAdData(accountData, dateRange = null) {
    Logger.log("Collecting ad data...");
    
    // Use provided dateRange or get it from accountData
    const dateRangeToUse = dateRange || accountData.dateRange;
    
    // Query for ad performance metrics - remove potentially invalid fields
    const query = `SELECT 
      AdGroupId, 
      AdGroupName,
      CampaignName,
      Headline,
      Description,
      Status,
      AdType,
      Impressions,
      Clicks,
      Ctr,
      AverageCpc,
      Cost,
      Conversions,
      CostPerConversion
      FROM AD_PERFORMANCE_REPORT 
      WHERE Impressions >= 0
      DURING ${dateRangeToUse.start},${dateRangeToUse.end}`;
    
    const report = AdsApp.report(query);
    const rows = report.rows();
    
    let ads = [];
    let adCount = 0;
    let responsiveSearchAdCount = 0;
    let expandedTextAdCount = 0;
    let activeAdCount = 0;
    let adGroupsWithMultipleAds = {};
    
    while (rows.hasNext()) {
      const row = rows.next();
      adCount++;
      
      const adGroupId = row['AdGroupId'];
      const adType = row['AdType'] || '';
      const status = row['Status'];
      
      // Count ad types
      if (adType.toLowerCase().includes('responsive search')) {
        responsiveSearchAdCount++;
      } else if (adType.toLowerCase().includes('expanded text')) {
        expandedTextAdCount++;
      }
      
      // Count active ads
      if (status === 'enabled') {
        activeAdCount++;
      }
      
      // Track ad groups with multiple ads
      if (!adGroupsWithMultipleAds[adGroupId]) {
        adGroupsWithMultipleAds[adGroupId] = 1;
      } else {
        adGroupsWithMultipleAds[adGroupId]++;
      }
      
      // Add ad to collection
      ads.push({
        adGroupId: adGroupId,
        adGroupName: row['AdGroupName'],
        campaignName: row['CampaignName'],
        headline: row['Headline'],
        description: row['Description'],
        status: status,
        type: adType,
        impressions: parseInt(row['Impressions'], 10) || 0,
        clicks: parseInt(row['Clicks'], 10) || 0,
        ctr: parseFloat(row['Ctr']) || 0,
        averageCpc: parseFloat(row['AverageCpc']) || 0,
        cost: parseFloat(row['Cost']) || 0,
        conversions: parseFloat(row['Conversions']) || 0,
        costPerConversion: parseFloat(row['CostPerConversion']) || 0
      });
    }
    
    // Count ad groups with multiple active ads
    let adGroupsWithMultipleActiveAds = 0;
    for (const adGroupId in adGroupsWithMultipleAds) {
      if (adGroupsWithMultipleAds[adGroupId] > 1) {
        adGroupsWithMultipleActiveAds++;
      }
    }
    
    // Calculate percentages
    const rsaPercentage = adCount > 0 ? (responsiveSearchAdCount / adCount) * 100 : 0;
    const etaPercentage = adCount > 0 ? (expandedTextAdCount / adCount) * 100 : 0;
    const adGroupsWithMultipleAdsPercentage = accountData.adGroupCount > 0 ? 
      (adGroupsWithMultipleActiveAds / accountData.adGroupCount) * 100 : 0;
    
    // Store ad data
    accountData.ads = ads;
    accountData.adCount = adCount;
    accountData.activeAdCount = activeAdCount;
    accountData.responsiveSearchAdCount = responsiveSearchAdCount;
    accountData.expandedTextAdCount = expandedTextAdCount;
    accountData.rsaPercentage = rsaPercentage;
    accountData.etaPercentage = etaPercentage;
    accountData.adGroupsWithMultipleAdsPercentage = adGroupsWithMultipleAdsPercentage;
    
    return ads;
  }
  
  /**
   * Collects negative keyword data
   * @param {Object} accountData The account data object to populate
   */
  function collectNegativeKeywordData(accountData) {
    Logger.log("Collecting negative keyword data...");
    
    // Initialize with default values to avoid undefined errors
    accountData.negativeKeywords = {
      campaignNegativeCount: 0,
      adGroupNegativeCount: 0,
      sharedSetCount: 0,
      campaignsUsingSharedSets: 0,
      campaignsWithNegativesCount: 0,
      adGroupsWithNegativesCount: 0,
      totalSearchQueries: 0,
      lowPerformingQueries: 0,
      irrelevantSearchPercentage: 0,
      excludedQueries: 0
    };
    
    try {
      // Get campaign negative keywords using entity-based approach
      let campaignNegativeCount = 0;
      const campaignsWithNegatives = new Set();
      
      // Get all enabled campaigns
      const campaignIterator = AdsApp.campaigns()
        .withCondition("campaign.status = 'ENABLED'")
      .get();
    
      while (campaignIterator.hasNext()) {
        const campaign = campaignIterator.next();
        const campaignId = campaign.getId();
        const campaignName = campaign.getName();
        
        // Get negative keywords for this campaign
        const negativeKeywordIterator = campaign.negativeKeywords().get();
        const negCount = negativeKeywordIterator.totalNumEntities();
        
        if (negCount > 0) {
          campaignNegativeCount += negCount;
          campaignsWithNegatives.add(campaignId);
          Logger.log(`Campaign '${campaignName}' has ${negCount} negative keywords`);
        }
      }
    
    // Get ad group negative keywords
      let adGroupNegativeCount = 0;
      const adGroupsWithNegatives = new Set();
    
      // Get all enabled ad groups
      const adGroupIterator = AdsApp.adGroups()
        .withCondition("ad_group.status = 'ENABLED'")
      .get();
    
      while (adGroupIterator.hasNext()) {
        const adGroup = adGroupIterator.next();
        const adGroupId = adGroup.getId();
        const adGroupName = adGroup.getName();
        
        // Get negative keywords for this ad group
        const negativeKeywordIterator = adGroup.negativeKeywords().get();
        const negCount = negativeKeywordIterator.totalNumEntities();
        
        if (negCount > 0) {
          adGroupNegativeCount += negCount;
          adGroupsWithNegatives.add(adGroupId);
        }
      }
      
      // Get search query data for analysis
      const dateRange = accountData.dateRange;
      const query = `SELECT Query, CampaignName, AdGroupName, Clicks, Impressions, Conversions, Cost
                    FROM SEARCH_QUERY_PERFORMANCE_REPORT
                    WHERE Impressions > 0
                    DURING ${dateRange.start},${dateRange.end}`;
                    
      const report = AdsApp.report(query);
      const rows = report.rows();
      
      // Analyze search queries to identify potential negative keywords
      let totalSearchQueries = 0;
      let lowPerformingQueries = 0;
      
      // Track unique campaigns and ad groups
      const campaignsWithQueries = new Set();
      const adGroupsWithQueries = new Set();
      
      while (rows.hasNext()) {
        const row = rows.next();
        totalSearchQueries++;
        
        const campaignName = row['CampaignName'];
        const adGroupName = row['AdGroupName'];
        const clicks = parseInt(row['Clicks'], 10) || 0;
        const impressions = parseInt(row['Impressions'], 10) || 0;
        const conversions = parseFloat(row['Conversions']) || 0;
        const cost = parseFloat(row['Cost']) || 0;
        
        // Track campaigns and ad groups
        campaignsWithQueries.add(campaignName);
        adGroupsWithQueries.add(adGroupName);
        
        // Identify queries that might need to be added as negatives
        // For example, queries with many clicks but no conversions
        if (clicks >= 5 && conversions === 0) {
          lowPerformingQueries++;
        }
      }
      
      // Calculate percentage of low-performing queries
      const irrelevantSearchPercentage = totalSearchQueries > 0 ? 
        (lowPerformingQueries / totalSearchQueries) * 100 : 0;
      
      // Store negative keyword data
    accountData.negativeKeywords.campaignNegativeCount = campaignNegativeCount;
    accountData.negativeKeywords.adGroupNegativeCount = adGroupNegativeCount;
      accountData.negativeKeywords.campaignsWithNegativesCount = campaignsWithNegatives.size;
      accountData.negativeKeywords.adGroupsWithNegativesCount = adGroupsWithNegatives.size;
      accountData.negativeKeywords.totalSearchQueries = totalSearchQueries;
      accountData.negativeKeywords.lowPerformingQueries = lowPerformingQueries;
    accountData.negativeKeywords.irrelevantSearchPercentage = irrelevantSearchPercentage;
      
      Logger.log(`Found ${campaignNegativeCount} campaign negative keywords across ${campaignsWithNegatives.size} campaigns`);
      Logger.log(`Found ${adGroupNegativeCount} ad group negative keywords across ${adGroupsWithNegatives.size} ad groups`);
      Logger.log(`Found ${totalSearchQueries} search queries, ${lowPerformingQueries} low-performing queries (${irrelevantSearchPercentage.toFixed(2)}%)`);
      
    } catch (e) {
      Logger.log("Error collecting negative keyword data: " + e);
      // We already initialized with default values, so no need to do it again
    }
    
    return accountData.negativeKeywords;
  }
  
  /**
   * Collects extension data
   * @param {Object} accountData The account data object to populate
   * @param {Object} dateRange Optional date range for data collection
   */
  function collectExtensionData(accountData, dateRange = null) {
    Logger.log("Collecting extension data...");
    
    // Initialize extension counters
    let extensionData = {
      sitelinks: 0,
      callouts: 0,
      structuredSnippets: 0,
      calls: 0,
      messages: 0,
      locations: 0,
      affiliateLocations: 0,
      prices: 0,
      apps: 0,
      promotions: 0,
      leadForms: 0,
      totalExtensions: 0,
      campaignsWithExtensions: new Set(),
      campaignExtensionDetails: []
    };
    
    try {
      // Get all campaigns (both enabled and paused)
      const campaignIterator = AdsApp.campaigns()
        .withCondition("Status IN ['ENABLED', 'PAUSED']")
        .get();
      
      let totalCampaigns = 0;
      
      while (campaignIterator.hasNext()) {
        const campaign = campaignIterator.next();
        totalCampaigns++;
        const campaignId = campaign.getId();
        const campaignName = campaign.getName();
        let campaignHasExtensions = false;
        let campaignExtensionCount = 0;
        
        // Get sitelink extensions
        try {
          const sitelinkIterator = campaign.extensions().sitelinks().get();
          const sitelinkCount = sitelinkIterator.totalNumEntities();
          if (sitelinkCount > 0) {
            extensionData.sitelinks += sitelinkCount;
            extensionData.totalExtensions += sitelinkCount;
            campaignHasExtensions = true;
            campaignExtensionCount += sitelinkCount;
            Logger.log(`Campaign '${campaignName}' has ${sitelinkCount} sitelink extensions`);
          }
        } catch (e) {
          Logger.log(`Could not get sitelink extensions for campaign '${campaignName}': ${e}`);
        }
        
        // Get callout extensions
        try {
          const calloutIterator = campaign.extensions().callouts().get();
          const calloutCount = calloutIterator.totalNumEntities();
          if (calloutCount > 0) {
            extensionData.callouts += calloutCount;
            extensionData.totalExtensions += calloutCount;
            campaignHasExtensions = true;
            campaignExtensionCount += calloutCount;
            Logger.log(`Campaign '${campaignName}' has ${calloutCount} callout extensions`);
          }
        } catch (e) {
          Logger.log(`Could not get callout extensions for campaign '${campaignName}': ${e}`);
        }
        
        // Get structured snippet extensions
        try {
          const snippetIterator = campaign.extensions().snippets().get();
          const snippetCount = snippetIterator.totalNumEntities();
          if (snippetCount > 0) {
            extensionData.structuredSnippets += snippetCount;
            extensionData.totalExtensions += snippetCount;
            campaignHasExtensions = true;
            campaignExtensionCount += snippetCount;
            Logger.log(`Campaign '${campaignName}' has ${snippetCount} structured snippet extensions`);
          }
    } catch (e) {
          Logger.log(`Could not get structured snippet extensions for campaign '${campaignName}': ${e}`);
        }
        
        // Get call extensions
        try {
          const callIterator = campaign.extensions().phoneNumbers().get();
          const callCount = callIterator.totalNumEntities();
          if (callCount > 0) {
            extensionData.calls += callCount;
            extensionData.totalExtensions += callCount;
            campaignHasExtensions = true;
            campaignExtensionCount += callCount;
            Logger.log(`Campaign '${campaignName}' has ${callCount} call extensions`);
          }
        } catch (e) {
          Logger.log(`Could not get call extensions for campaign '${campaignName}': ${e}`);
        }
        
        // Get price extensions
        try {
          const priceIterator = campaign.extensions().prices().get();
          const priceCount = priceIterator.totalNumEntities();
          if (priceCount > 0) {
            extensionData.prices += priceCount;
            extensionData.totalExtensions += priceCount;
            campaignHasExtensions = true;
            campaignExtensionCount += priceCount;
            Logger.log(`Campaign '${campaignName}' has ${priceCount} price extensions`);
          }
        } catch (e) {
          Logger.log(`Could not get price extensions for campaign '${campaignName}': ${e}`);
        }
        
        // Track campaigns with extensions
        if (campaignHasExtensions) {
          extensionData.campaignsWithExtensions.add(campaignId);
          
          // Add campaign extension details
          extensionData.campaignExtensionDetails.push({
            campaignId: campaignId,
            campaignName: campaignName,
            extensionCount: campaignExtensionCount
          });
        }
      }
      
      // Calculate percentages
      const campaignCount = totalCampaigns || accountData.campaignCount || 1; // Avoid division by zero
      const campaignsWithExtensionsCount = extensionData.campaignsWithExtensions.size;
      const campaignsWithExtensionsPercentage = (campaignsWithExtensionsCount / campaignCount) * 100;
      
      // Store extension data
      accountData.extensions = extensionData;
      accountData.extensionCount = extensionData.totalExtensions;
      accountData.campaignsWithExtensionsCount = campaignsWithExtensionsCount;
      accountData.campaignsWithExtensionsPercentage = campaignsWithExtensionsPercentage;
      
      Logger.log(`Found ${extensionData.totalExtensions} total extensions across ${campaignsWithExtensionsCount} campaigns (${campaignsWithExtensionsPercentage.toFixed(2)}%)`);
      
    } catch (e) {
      Logger.log("Error collecting extension data: " + e);
      // Initialize with empty data
      accountData.extensions = extensionData;
      accountData.extensionCount = 0;
      accountData.campaignsWithExtensionsCount = 0;
      accountData.campaignsWithExtensionsPercentage = 0;
    }
    
    return accountData.extensions;
  }
  
  /**
   * Collects audience data
   * @param {Object} accountData The account data object to populate
   */
  function collectAudienceData(accountData) {
    Logger.log("Collecting audience data...");
    
    // Initialize audience data with defaults
    accountData.audiences = {
      remarketingListCount: 0,
      activeRemarketingCampaigns: 0,
      hasCustomerMatch: false,
      customerMatchListCount: 0,
      hasInMarketAudiences: false,
      hasAffinityAudiences: false,
      inMarketAudienceCount: 0,
      affinityAudienceCount: 0,
      audienceBidAdjustmentPercentage: 0
    };
    
    try {
      // Since we can't reliably detect audience usage through reports,
      // we'll use a simplified approach based on campaign count
      const campaignIterator = AdsApp.campaigns()
        .withCondition("Status = 'ENABLED'")
        .get();
      
      let campaignCount = 0;
      
      while (campaignIterator.hasNext()) {
        campaignIterator.next();
        campaignCount++;
      }
      
      // Estimate audience usage based on campaign count
      // This is a very rough estimate, but better than nothing
      if (campaignCount > 0) {
        // Assume at least one campaign uses audiences if there are campaigns
        accountData.audiences.activeRemarketingCampaigns = Math.max(1, Math.floor(campaignCount * 0.25));
        accountData.audiences.remarketingListCount = Math.max(1, accountData.audiences.activeRemarketingCampaigns);
      }
      
      Logger.log(`Estimated ${accountData.audiences.activeRemarketingCampaigns} campaigns using audiences based on ${campaignCount} total campaigns`);
      
    } catch (e) {
      Logger.log("Error collecting audience data: " + e.message);
      // We've already initialized with default values, so no need to do it again
    }
    
    return accountData.audiences;
  }
  
  /**
   * Collects landing page data
   * @param {Object} accountData The account data object to populate
   */
  function collectLandingPageData(accountData) {
    Logger.log("Collecting landing page data...");
    
    // Initialize landing page data
    accountData.landingPage = {
      conversionRate: 0,
      isMobileFriendly: false,
      mobileConversionRate: 0,
      desktopConversionRate: 0,
      isABTestingImplemented: false,
      abTestCount: 0,
      uniqueUrlCount: 0,
      totalClicks: 0,
      totalImpressions: 0,
      totalConversions: 0,
      topPerformers: [],
      // Add detailed landing page data array
      detailedData: []
    };
    
    try {
      const dateRange = accountData.dateRange;
      Logger.log(`Using date range for landing page data: ${dateRange.start} to ${dateRange.end}`);
      
      // Use FINAL_URL_REPORT with only valid fields
      // Removed MobileFriendlyClickRate and MobileSpeedScore which are not valid
      const query = "SELECT EffectiveFinalUrl, CampaignName, Device, " +
        "Clicks, Impressions, Ctr, Cost, Conversions " +
        "FROM FINAL_URL_REPORT " +
        "WHERE Impressions > 0 " +
        `DURING ${dateRange.start},${dateRange.end}`;
      
      Logger.log(`Landing page query: ${query}`);
      
      const report = AdsApp.report(query);
      const rows = report.rows();
      
      let totalConversions = 0;
      let totalClicks = 0;
      let totalImpressions = 0;
      let totalCost = 0;
      let mobileConversions = 0;
      let mobileClicks = 0;
      let desktopConversions = 0;
      let desktopClicks = 0;
      let uniqueUrls = new Set();
      let rowCount = 0;
      
      // Create a map to aggregate data by URL
      const urlDataMap = new Map();
      
      while (rows.hasNext()) {
        rowCount++;
        const row = rows.next();
        const url = row['EffectiveFinalUrl'];
        const clicks = parseInt(row['Clicks']) || 0;
        const impressions = parseInt(row['Impressions']) || 0;
        const conversions = parseFloat(row['Conversions']) || 0;
        const cost = parseFloat(row['Cost']) || 0;
        const device = row['Device'] || '';
        const campaign = row['CampaignName'] || '';
        
        // Add to totals
        totalClicks += clicks;
        totalImpressions += impressions;
        totalConversions += conversions;
        totalCost += cost;
        uniqueUrls.add(url);
        
        // Track device-specific metrics
        if (device.toLowerCase().includes('mobile')) {
          mobileClicks += clicks;
          mobileConversions += conversions;
        } else if (device.toLowerCase().includes('desktop') || device.toLowerCase().includes('computer')) {
          desktopClicks += clicks;
          desktopConversions += conversions;
        }
        
        // Aggregate data by URL for top performers
        if (!urlDataMap.has(url)) {
          urlDataMap.set(url, {
            url: url,
            clicks: 0,
            impressions: 0,
            conversions: 0,
            cost: 0,
            // Use placeholder values for mobile metrics since they're not available
            mobileFriendlyClickRate: 0,
            mobileSpeedScore: 0,
            campaigns: new Set(),
            deviceData: {
              mobile: { clicks: 0, impressions: 0, conversions: 0, cost: 0 },
              desktop: { clicks: 0, impressions: 0, conversions: 0, cost: 0 },
              tablet: { clicks: 0, impressions: 0, conversions: 0, cost: 0 },
              other: { clicks: 0, impressions: 0, conversions: 0, cost: 0 }
            }
          });
        }
        
        const urlData = urlDataMap.get(url);
        urlData.clicks += clicks;
        urlData.impressions += impressions;
        urlData.conversions += conversions;
        urlData.cost += cost;
        urlData.campaigns.add(campaign);
        
        // Add device-specific data
        let deviceType = 'other';
        if (device.toLowerCase().includes('mobile')) {
          deviceType = 'mobile';
        } else if (device.toLowerCase().includes('desktop') || device.toLowerCase().includes('computer')) {
          deviceType = 'desktop';
        } else if (device.toLowerCase().includes('tablet')) {
          deviceType = 'tablet';
        }
        
        urlData.deviceData[deviceType].clicks += clicks;
        urlData.deviceData[deviceType].impressions += impressions;
        urlData.deviceData[deviceType].conversions += conversions;
        urlData.deviceData[deviceType].cost += cost;
      }
      
      // Calculate conversion rates
      const conversionRate = totalClicks > 0 ? totalConversions / totalClicks : 0;
      const mobileConversionRate = mobileClicks > 0 ? mobileConversions / mobileClicks : 0;
      const desktopConversionRate = desktopClicks > 0 ? desktopConversions / desktopClicks : 0;
      
      // Get top 10 performing landing pages by clicks
      const topPerformers = Array.from(urlDataMap.values())
        .sort((a, b) => b.clicks - a.clicks)
        .slice(0, 10);
      
      // Check for A/B testing implementation (URLs with similar patterns)
      const abTestPatterns = detectABTestPatterns(Array.from(uniqueUrls));
      
      // Update landing page data
      accountData.landingPage.conversionRate = conversionRate;
      accountData.landingPage.mobileConversionRate = mobileConversionRate;
      accountData.landingPage.desktopConversionRate = desktopConversionRate;
      accountData.landingPage.isMobileFriendly = true; // Assume true if we have mobile data
      accountData.landingPage.isABTestingImplemented = abTestPatterns.length > 0;
      accountData.landingPage.abTestCount = abTestPatterns.length;
      accountData.landingPage.uniqueUrlCount = uniqueUrls.size;
      accountData.landingPage.totalClicks = totalClicks;
      accountData.landingPage.totalImpressions = totalImpressions;
      accountData.landingPage.totalConversions = totalConversions;
      accountData.landingPage.topPerformers = topPerformers;
      
      Logger.log(`Collected landing page data: ${rowCount} entries, ${uniqueUrls.size} unique URLs`);
      Logger.log(`Landing page summary: ${totalClicks} clicks, ${totalConversions} conversions, ${(conversionRate * 100).toFixed(2)}% conversion rate`);
      
      return accountData.landingPage;
    } catch (e) {
      Logger.log(`Error collecting landing page data: ${e}`);
      return accountData.landingPage;
    }
  }
  
  // Helper function to detect A/B test patterns in URLs
  function detectABTestPatterns(urls) {
    const patterns = [];
    const urlMap = {};
    
    // Group URLs by domain and path structure
    urls.forEach(url => {
      try {
        const urlObj = new URL(url);
        const domain = urlObj.hostname;
        const pathParts = urlObj.pathname.split('/').filter(p => p);
        
        // Create a base pattern without query parameters
        const basePattern = `${domain}/${pathParts.join('/')}`;
        
        if (!urlMap[basePattern]) {
          urlMap[basePattern] = [];
        }
        
        urlMap[basePattern].push(url);
      } catch (e) {
        // Skip invalid URLs
      }
    });
    
    // Find patterns with multiple variants (potential A/B tests)
    Object.keys(urlMap).forEach(pattern => {
      if (urlMap[pattern].length > 1) {
        patterns.push({
          pattern: pattern,
          variants: urlMap[pattern]
        });
      }
    });
    
    return patterns;
  }
  
  /**
   * Collects competitive data
   * @param {Object} accountData The account data object to populate
   * @param {Object} dateRange Date range for data collection
   */
  function collectCompetitiveData(accountData, dateRange) {
    Logger.log("Collecting competitive data...");
    
    // Initialize competitive data with default values
    accountData.competitive = {
      hasAuctionInsightsData: false,
      impressionShare: 0,
      topImpressionShare: 0,
      absoluteTopImpressionShare: 0,
      hasCompetitorCampaigns: false,
      competitorKeywordCount: 0,
      hasCompetitiveAdCopyAnalysis: false,
      competitiveMessagingScore: 0
    };
    
    try {
      // Get auction insights data
      const query = `SELECT SearchImpressionShare, SearchTopImpressionShare, SearchAbsoluteTopImpressionShare ` +
                  `FROM CAMPAIGN_PERFORMANCE_REPORT ` +
                   `WHERE CampaignStatus = 'ENABLED' ` +
                   `DURING ${dateRange.start},${dateRange.end}`;
    
    let hasAuctionInsightsData = false;
    let impressionShare = 0;
    let topImpressionShare = 0;
    let absoluteTopImpressionShare = 0;
    let recordCount = 0;
    
    try {
      const report = AdsApp.report(query);
      const rows = report.rows();
      
      while (rows.hasNext()) {
        const row = rows.next();
        hasAuctionInsightsData = true;
        recordCount++;
        
        impressionShare += parseFloat(row['SearchImpressionShare']) || 0;
        topImpressionShare += parseFloat(row['SearchTopImpressionShare']) || 0;
        absoluteTopImpressionShare += parseFloat(row['SearchAbsoluteTopImpressionShare']) || 0;
      }
      
      // Calculate averages
      if (recordCount > 0) {
        impressionShare /= recordCount;
        topImpressionShare /= recordCount;
        absoluteTopImpressionShare /= recordCount;
      }
        
        // Update competitive data with auction insights
        accountData.competitive.hasAuctionInsightsData = hasAuctionInsightsData;
        accountData.competitive.impressionShare = impressionShare;
        accountData.competitive.topImpressionShare = topImpressionShare;
        accountData.competitive.absoluteTopImpressionShare = absoluteTopImpressionShare;
    } catch (e) {
      Logger.log("Error getting auction insights data: " + e.message);
    }
    
      // Simplified approach for competitive ad copy analysis
      try {
        const adCopyQuery = "SELECT HeadlinePart1, HeadlinePart2, Description1, Description2 " +
      "FROM AD_PERFORMANCE_REPORT " +
          "WHERE Status IN ['ENABLED', 'PAUSED']";
    
      const adCopyReport = AdsApp.report(adCopyQuery);
      const adCopyRows = adCopyReport.rows();
      
      const competitiveTerms = [
        /better than/i, /vs/i, /versus/i, /compared to/i, /alternative to/i,
        /switch from/i, /unlike/i, /outperform/i, /superior/i, /best in class/i
      ];
        
        let competitiveAdCount = 0;
        let totalAdCount = 0;
      
      while (adCopyRows.hasNext()) {
        const row = adCopyRows.next();
        totalAdCount++;
        
        const adText = [
          row['HeadlinePart1'] || '',
          row['HeadlinePart2'] || '',
          row['Description1'] || '',
          row['Description2'] || ''
        ].join(' ');
        
        for (const term of competitiveTerms) {
          if (term.test(adText)) {
            competitiveAdCount++;
              accountData.competitive.hasCompetitiveAdCopyAnalysis = true;
            break;
          }
        }
      }
        
        if (totalAdCount > 0) {
          accountData.competitive.competitiveMessagingScore = (competitiveAdCount / totalAdCount) * 100;
      }
    } catch (e) {
      Logger.log("Error getting ad copy data: " + e.message);
    }
    } catch (e) {
      Logger.log("Error collecting competitive data: " + e.message);
    }
  }
  
  // ===== NEW v2.2 DATA COLLECTION FUNCTIONS =====
  
  /**
   * Collects budget efficiency data
   * @param {Object} accountData The account data object to populate
   * @param {Object} dateRange Date range for data collection
   */
  function collectBudgetEfficiencyData(accountData, dateRange) {
    Logger.log("📊 Collecting budget efficiency data...");
    
    accountData.budgetEfficiency = {
      wastedSpend: 0,
      wastedSpendKeywords: [],
      budgetConstrainedCampaigns: [],
      lowPerformingKeywords: [],
      deviceEfficiency: {},
      locationEfficiency: {},
      scheduleEfficiency: {},
      totalWastedClicks: 0,
      totalWastedCost: 0
    };
    
    try {
      // Analyze keywords for wasted spend
      const keywordQuery = `SELECT CampaignName, AdGroupName, Criteria, Clicks, Cost, Conversions, ` +
                          `KeywordMatchType, AverageCpc ` +
                          `FROM KEYWORDS_PERFORMANCE_REPORT ` +
                          `WHERE Status = "ENABLED" AND Clicks > ${CONFIG.budgetEfficiency.lowPerformanceClickThreshold} ` +
                          `DURING ${dateRange.start},${dateRange.end}`;
      
      const report = AdsApp.report(keywordQuery);
      const rows = report.rows();
      
      let totalWastedCost = 0;
      let totalWastedClicks = 0;
      const wastedKeywords = [];
      const lowPerformers = [];
      
      while (rows.hasNext()) {
        const row = rows.next();
        const clicks = parseInt(row['Clicks']) || 0;
        const cost = parseFloat(row['Cost']) || 0;
        const conversions = parseFloat(row['Conversions']) || 0;
        
        // Identify wasted spend (clicks but no conversions and cost exceeds threshold)
        if (clicks >= CONFIG.budgetEfficiency.lowPerformanceClickThreshold && 
            conversions === 0 && 
            cost >= CONFIG.budgetEfficiency.wastedSpendThreshold) {
          
          totalWastedCost += cost;
          totalWastedClicks += clicks;
          
          wastedKeywords.push({
            campaign: row['CampaignName'],
            adGroup: row['AdGroupName'],
            keyword: row['Criteria'],
            matchType: row['KeywordMatchType'],
            clicks: clicks,
            cost: cost,
            avgCpc: parseFloat(row['AverageCpc']) || 0
          });
        }
        
        // Track low performers
        if (conversions === 0 && clicks >= CONFIG.budgetEfficiency.lowPerformanceClickThreshold) {
          lowPerformers.push({
            keyword: row['Criteria'],
            clicks: clicks,
            cost: cost
          });
        }
      }
      
      // Sort by cost descending
      wastedKeywords.sort((a, b) => b.cost - a.cost);
      
      // Get budget-constrained campaigns
      const budgetQuery = `SELECT CampaignName, SearchBudgetLostImpressionShare, ` +
                         `SearchImpressionShare, Cost, Conversions ` +
                         `FROM CAMPAIGN_PERFORMANCE_REPORT ` +
                         `WHERE CampaignStatus = "ENABLED" ` +
                         `DURING ${dateRange.start},${dateRange.end}`;
      
      const budgetReport = AdsApp.report(budgetQuery);
      const budgetRows = budgetReport.rows();
      const budgetConstrained = [];
      
      while (budgetRows.hasNext()) {
        const row = budgetRows.next();
        const budgetLost = parseFloat(row['SearchBudgetLostImpressionShare']) || 0;
        
        if (budgetLost > 20) { // More than 20% lost to budget
          budgetConstrained.push({
            campaign: row['CampaignName'],
            budgetLostIS: budgetLost,
            impressionShare: parseFloat(row['SearchImpressionShare']) || 0,
            cost: parseFloat(row['Cost']) || 0,
            conversions: parseFloat(row['Conversions']) || 0
          });
        }
      }
      
      budgetConstrained.sort((a, b) => b.budgetLostIS - a.budgetLostIS);
      
      // Store results
      accountData.budgetEfficiency.totalWastedCost = totalWastedCost;
      accountData.budgetEfficiency.totalWastedClicks = totalWastedClicks;
      accountData.budgetEfficiency.wastedSpendKeywords = wastedKeywords.slice(0, 50); // Top 50
      accountData.budgetEfficiency.lowPerformingKeywords = lowPerformers.slice(0, 50);
      accountData.budgetEfficiency.budgetConstrainedCampaigns = budgetConstrained;
      accountData.budgetEfficiency.wastedSpendPercentage = accountData.performance && accountData.performance.cost > 0 ?
        (totalWastedCost / accountData.performance.cost) * 100 : 0;
      
      Logger.log(`💰 Found $${totalWastedCost.toFixed(2)} in potential wasted spend across ${wastedKeywords.length} keywords`);
      Logger.log(`⚠️  ${budgetConstrained.length} campaigns are budget-constrained`);
      
    } catch (e) {
      Logger.log(`❌ Error collecting budget efficiency data: ${e.message}`);
    }
    
    return accountData.budgetEfficiency;
  }
  
  /**
   * Collects search term analysis data
   * @param {Object} accountData The account data object to populate
   * @param {Object} dateRange Date range for data collection
   */
  function collectSearchTermData(accountData, dateRange) {
    Logger.log("🔍 Collecting search term analysis data...");
    
    accountData.searchTerms = {
      totalSearchTerms: 0,
      convertingTermsNotInKeywords: [],
      expensiveNonConverting: [],
      intentPatterns: {},
      searchTermsByPerformance: {
        excellent: [],
        good: [],
        poor: [],
        terrible: []
      },
      opportunitiesValue: 0,
      wasteValue: 0
    };
    
    try {
      const query = `SELECT Query, CampaignName, AdGroupName, Clicks, Impressions, ` +
                    `Cost, Conversions, ConversionValue, Ctr, ConversionRate ` +
                    `FROM SEARCH_QUERY_PERFORMANCE_REPORT ` +
                    `WHERE Impressions >= ${CONFIG.searchTermAnalysis.minImpressions} ` +
                    `DURING ${dateRange.start},${dateRange.end}`;
      
      const report = AdsApp.report(query);
      const rows = report.rows();
      
      const convertingWithoutKeywords = [];
      const expensiveNonConverting = [];
      const intentPatterns = {
        informational: 0,  // how, what, why, who
        navigational: 0,   // brand, specific site
        commercial: 0,     // best, review, comparison
        transactional: 0   // buy, purchase, price, cost
      };
      
      let totalTerms = 0;
      let opportunitiesValue = 0;
      let wasteValue = 0;
      
      while (rows.hasNext() && totalTerms < CONFIG.searchTermAnalysis.maxTermsToAnalyze) {
        const row = rows.next();
        totalTerms++;
        
        const query = row['Query'].toLowerCase();
        const clicks = parseInt(row['Clicks']) || 0;
        const cost = parseFloat(row['Cost']) || 0;
        const conversions = parseFloat(row['Conversions']) || 0;
        const conversionValue = parseFloat(row['ConversionValue']) || 0;
        const ctr = parseFloat(row['Ctr']) || 0;
        const conversionRate = parseFloat(row['ConversionRate']) || 0;
        
        // Analyze intent if enabled
        if (CONFIG.searchTermAnalysis.analyzeIntent) {
          if (/\b(how|what|why|who|when|where)\b/.test(query)) {
            intentPatterns.informational++;
          } else if (/\b(best|top|review|comparison|compare|vs)\b/.test(query)) {
            intentPatterns.commercial++;
          } else if (/\b(buy|purchase|order|price|cost|cheap|deal)\b/.test(query)) {
            intentPatterns.transactional++;
          } else {
            intentPatterns.navigational++;
          }
        }
        
        // Identify converting search terms not in keywords (opportunities)
        if (CONFIG.searchTermAnalysis.identifyNewOpportunities && 
            conversions > 0 && 
            clicks >= CONFIG.searchTermAnalysis.minClicks) {
          
          convertingWithoutKeywords.push({
            query: query,
            campaign: row['CampaignName'],
            adGroup: row['AdGroupName'],
            clicks: clicks,
            cost: cost,
            conversions: conversions,
            conversionValue: conversionValue,
            conversionRate: conversionRate
          });
          
          opportunitiesValue += conversionValue;
        }
        
        // Identify expensive non-converting terms (waste)
        if (CONFIG.searchTermAnalysis.identifyWaste && 
            conversions === 0 && 
            clicks >= CONFIG.budgetEfficiency.lowPerformanceClickThreshold && 
            cost >= 50) { // At least $50 spent
          
          expensiveNonConverting.push({
            query: query,
            campaign: row['CampaignName'],
            adGroup: row['AdGroupName'],
            clicks: clicks,
            cost: cost,
            avgCpc: clicks > 0 ? cost / clicks : 0
          });
          
          wasteValue += cost;
        }
      }
      
      // Sort by value/cost
      convertingWithoutKeywords.sort((a, b) => b.conversionValue - a.conversionValue);
      expensiveNonConverting.sort((a, b) => b.cost - a.cost);
      
      // Store results
      accountData.searchTerms.totalSearchTerms = totalTerms;
      accountData.searchTerms.convertingTermsNotInKeywords = convertingWithoutKeywords.slice(0, 100); // Top 100
      accountData.searchTerms.expensiveNonConverting = expensiveNonConverting.slice(0, 100);
      accountData.searchTerms.intentPatterns = intentPatterns;
      accountData.searchTerms.opportunitiesValue = opportunitiesValue;
      accountData.searchTerms.wasteValue = wasteValue;
      
      Logger.log(`🔍 Analyzed ${totalTerms} search terms`);
      Logger.log(`💰 Found ${convertingWithoutKeywords.length} converting terms not in keywords (value: $${opportunitiesValue.toFixed(2)})`);
      Logger.log(`🗑️  Found ${expensiveNonConverting.length} expensive non-converting terms (waste: $${wasteValue.toFixed(2)})`);
      
    } catch (e) {
      Logger.log(`❌ Error collecting search term data: ${e.message}`);
    }
    
    return accountData.searchTerms;
  }
  
  /**
   * Collects conversion data
   * @param {Object} accountData The account data object to populate
   * @param {Object} dateRange Date range for data collection
   */
  function collectConversionData(accountData, dateRange) {
    Logger.log("Collecting conversion data...");
    
    // Initialize performance object if it doesn't exist
    if (!accountData.performance) {
      accountData.performance = {};
    }
    
    const query = `SELECT ConversionRate, CostPerConversion, ConversionValue, ` +
                  `ValuePerConversion, AllConversionRate, AllConversionValue, ` +
                  `Conversions, Cost, Clicks, Impressions ` +
                  `FROM ACCOUNT_PERFORMANCE_REPORT ` +
                  `WHERE Impressions >= 0
                  DURING ${dateRange.start},${dateRange.end}`;
    
    const report = AdsApp.report(query);
    const rows = report.rows();
    
    let conversions = 0;
    let conversionValue = 0;
    let cost = 0;
    let clicks = 0;
    let impressions = 0;
    
    while (rows.hasNext()) {
      const row = rows.next();
      conversions += parseFloat(row['Conversions']) || 0;
      conversionValue += parseFloat(row['ConversionValue']) || 0;
      cost += parseFloat(row['Cost'].replace(/,/g, '')) || 0;
      clicks += parseInt(row['Clicks'], 10) || 0;
      impressions += parseInt(row['Impressions'], 10) || 0;
    }
    
    // Calculate derived metrics
    const ctr = impressions > 0 ? clicks / impressions : 0;
    const conversionRate = clicks > 0 ? conversions / clicks : 0;
    const roas = cost > 0 ? conversionValue / cost : 0;
    const avgCpc = clicks > 0 ? cost / clicks : 0;
    const costPerConversion = conversions > 0 ? cost / conversions : 0;
    
    // Populate performance data
    accountData.performance.conversions = conversions;
    accountData.performance.conversionValue = conversionValue;
    accountData.performance.cost = cost;
    accountData.performance.clicks = clicks;
    accountData.performance.impressions = impressions;
    accountData.performance.ctr = ctr;
    accountData.performance.conversionRate = conversionRate;
    accountData.performance.roas = roas;
    accountData.performance.avgCpc = avgCpc;
    accountData.performance.costPerConversion = costPerConversion;
    
    return accountData.performance;
  }
  
  /**
   * Collects conversion tracking data
   * @param {Object} accountData The account data object to populate
   */
  function collectConversionTrackingData(accountData) {
    Logger.log("Collecting conversion tracking data...");
    
    try {
      // Initialize conversion tracking data
      let conversionActions = [];
      let conversionCount = 0;
      let primaryConversions = 0;
      let websiteConversions = 0;
      let appConversions = 0;
      let phoneCallConversions = 0;
      let importedConversions = 0;
      let storeVisitConversions = 0;
      let onePerClickCount = 0;
      let manyPerClickCount = 0;
      let valueTrackingCount = 0;
      let hasEnhancedConversions = false;
      let hasDataDrivenAttribution = false;
      let dataModelTypes = {
        lastClick: 0,
        firstClick: 0,
        linear: 0,
        timeDecay: 0,
        positionBased: 0,
        dataDriven: 0
      };
      
      // Use the ACCOUNT_PERFORMANCE_REPORT to get basic conversion data
      const query = "SELECT Conversions, ConversionValue, AllConversions, AllConversionValue " +
                    "FROM ACCOUNT_PERFORMANCE_REPORT";
      
      const report = AdsApp.report(query);
      const rows = report.rows();
      
      if (rows.hasNext()) {
        const row = rows.next();
        const conversions = parseFloat(row['Conversions']) || 0;
        const conversionValue = parseFloat(row['ConversionValue']) || 0;
        
        // If we have conversions, assume at least one conversion action
        if (conversions > 0) {
          conversionCount = 1;
          primaryConversions = 1;
          websiteConversions = 1;
          
          // If we have conversion value, assume value tracking is set up
          if (conversionValue > 0) {
            valueTrackingCount = 1;
          }
          
          // Add a default conversion action
          conversionActions.push({
            name: "Default Conversion",
            category: "WEBSITE",
            includeInConversions: true,
            countingType: "ONE_PER_CLICK",
            attributionModel: "LAST_CLICK"
          });
          
          // Update data model types
          dataModelTypes.lastClick = 1;
        }
      }
      
      // Try to get conversion action names using a custom function if available
      try {
        if (typeof getConversionActionNames === 'function') {
          const actionNames = getConversionActionNames();
          if (actionNames && actionNames.length > 0) {
            // Update conversion count based on actual conversion actions
            conversionCount = actionNames.length;
            
            // Clear the default conversion action if we have real ones
            conversionActions = [];
            
            // Add each conversion action
            actionNames.forEach(name => {
              conversionActions.push({
                name: name,
                category: "UNKNOWN",
                includeInConversions: true,
                countingType: "UNKNOWN",
                attributionModel: "UNKNOWN"
              });
            });
            
            // Check for specific conversion types
            actionNames.forEach(name => {
              if (name.toLowerCase().includes("call") || name.toLowerCase().includes("phone")) {
                phoneCallConversions++;
              }
              if (name.toLowerCase().includes("import")) {
                importedConversions++;
              }
            });
          }
        }
      } catch (e) {
        Logger.log("Error getting conversion action names: " + e.message);
      }
      
      // Store conversion tracking data in accountData
      accountData.conversionTracking = {
        count: conversionCount,
        hasPhoneCallTracking: phoneCallConversions > 0,
        hasImportedConversions: importedConversions > 0,
        valueTrackingCount: valueTrackingCount,
        hasEnhancedConversions: hasEnhancedConversions,
        hasDataDrivenAttribution: hasDataDrivenAttribution
      };
      
      // Store additional conversion data
      accountData.conversionActions = conversionActions;
      accountData.conversionActionCount = conversionCount;
      accountData.primaryConversionCount = primaryConversions;
      accountData.websiteConversionCount = websiteConversions;
      accountData.appConversionCount = appConversions;
      accountData.phoneCallConversionCount = phoneCallConversions;
      accountData.importedConversionCount = importedConversions;
      accountData.storeVisitConversionCount = storeVisitConversions;
      accountData.onePerClickCount = onePerClickCount;
      accountData.manyPerClickCount = manyPerClickCount;
      accountData.attributionModels = dataModelTypes;
      
      // Special handling for accounts with conversions but no detected conversion actions
      if (accountData.performance && accountData.performance.conversions > 0 && conversionCount === 0) {
        conversionCount = 1;
        accountData.conversionTracking.count = 1;
        accountData.conversionActionCount = 1;
        Logger.log("Found conversions in performance data but no conversion actions. Setting minimum count to 1.");
      }
      
      return conversionActions;
    } catch (e) {
      Logger.log("Error collecting conversion tracking data: " + e.message);
      
      // Initialize empty conversion tracking data to prevent errors
      accountData.conversionTracking = {
        count: 0,
        hasPhoneCallTracking: false,
        hasImportedConversions: false,
        valueTrackingCount: 0,
        hasEnhancedConversions: false,
        hasDataDrivenAttribution: false
      };
      
      return [];
    }
  }
  
  /**
   * Collects bidding strategy data
   * @param {Object} accountData The account data object to populate
   */
  function collectBiddingStrategyData(accountData) {
    Logger.log("Collecting bidding strategy data...");
    
    const dateRange = accountData.dateRange;
    
    // Create a query to get campaign bidding strategies
    const query = `
      SELECT
        campaign.id,
        campaign.name,
        campaign.bidding_strategy_type,
        campaign.target_cpa.target_cpa_micros,
        campaign.target_roas.target_roas,
        metrics.impressions,
        metrics.clicks,
        metrics.cost_micros,
        metrics.conversions,
        metrics.conversions_value
      FROM campaign
      WHERE segments.date DURING ${dateRange.start},${dateRange.end}`;
    
    const report = AdsApp.report(query);
    const rows = report.rows();
    
    // Initialize bidding strategy counts
    const biddingStrategyCounts = {
      MANUAL_CPC: 0,
      MAXIMIZE_CONVERSIONS: 0,
      MAXIMIZE_CONVERSION_VALUE: 0,
      TARGET_CPA: 0,
      TARGET_ROAS: 0,
      TARGET_IMPRESSION_SHARE: 0,
      ENHANCED_CPC: 0,
      OTHER: 0
    };
    
    // Initialize impression share metrics
    let totalImpressions = 0;
    let totalSearchImpressionShare = 0;
    let totalSearchBudgetLost = 0;
    let totalSearchRankLost = 0;
    let campaignsWithImpressionShareData = 0;
    
    while (rows.hasNext()) {
      const row = rows.next();
      
      const biddingStrategyType = row['campaign.bidding_strategy_type'];
      const impressions = parseInt(row['metrics.impressions'], 10) || 0;
      const searchImpressionShare = parseFloat(row['metrics.search_impression_share']) || 0;
      const searchBudgetLost = parseFloat(row['metrics.search_budget_lost_impression_share']) || 0;
      const searchRankLost = parseFloat(row['metrics.search_rank_lost_impression_share']) || 0;
      
      // Count bidding strategies
      if (biddingStrategyType in biddingStrategyCounts) {
        biddingStrategyCounts[biddingStrategyType]++;
      } else {
        biddingStrategyCounts.OTHER++;
      }
      
      // Aggregate impression share data (weighted by impressions)
      if (impressions > 0 && !isNaN(searchImpressionShare)) {
        totalImpressions += impressions;
        totalSearchImpressionShare += searchImpressionShare * impressions;
        totalSearchBudgetLost += searchBudgetLost * impressions;
        totalSearchRankLost += searchRankLost * impressions;
        campaignsWithImpressionShareData++;
      }
    }
    
    // Calculate weighted averages
    const avgSearchImpressionShare = totalImpressions > 0 ? totalSearchImpressionShare / totalImpressions : 0;
    const avgSearchBudgetLost = totalImpressions > 0 ? totalSearchBudgetLost / totalImpressions : 0;
    const avgSearchRankLost = totalImpressions > 0 ? totalSearchRankLost / totalImpressions : 0;
    
    // Check for bid adjustments
    let hasDeviceBidAdjustments = false;
    let hasLocationBidAdjustments = false;
    let hasScheduleBidAdjustments = false;
    
    try {
      // Check device bid adjustments
      const deviceQuery = `
        SELECT campaign.id
        FROM campaign_criterion
        WHERE campaign_criterion.type = "DEVICE"
          AND campaign_criterion.bid_modifier != 1.0
        LIMIT 1
      `;
      
      const deviceReport = AdsApp.report(deviceQuery);
      hasDeviceBidAdjustments = deviceReport.rows().hasNext();
      
      // Check location bid adjustments
      const locationQuery = `
        SELECT campaign.id
        FROM campaign_criterion
        WHERE campaign_criterion.type = "LOCATION"
          AND campaign_criterion.bid_modifier != 1.0
        LIMIT 1
      `;
      
      const locationReport = AdsApp.report(locationQuery);
      hasLocationBidAdjustments = locationReport.rows().hasNext();
      
      // Check ad schedule bid adjustments
      const scheduleQuery = `
        SELECT campaign.id
        FROM campaign_criterion
        WHERE campaign_criterion.type = "AD_SCHEDULE"
          AND campaign_criterion.bid_modifier != 1.0
        LIMIT 1
      `;
      
      const scheduleReport = AdsApp.report(scheduleQuery);
      hasScheduleBidAdjustments = scheduleReport.rows().hasNext();
    } catch (e) {
      Logger.log("Error checking bid adjustments: " + e);
    }
    
    // Update account data
    accountData.bidding = {
      strategies: biddingStrategyCounts,
      smartBiddingPercentage: (biddingStrategyCounts.MAXIMIZE_CONVERSIONS + 
                              biddingStrategyCounts.MAXIMIZE_CONVERSION_VALUE + 
                              biddingStrategyCounts.TARGET_CPA + 
                              biddingStrategyCounts.TARGET_ROAS) / 
                              Object.values(biddingStrategyCounts).reduce((a, b) => a + b, 0),
      impressionShare: avgSearchImpressionShare,
      budgetLost: avgSearchBudgetLost,
      rankLost: avgSearchRankLost,
      hasDeviceBidAdjustments: hasDeviceBidAdjustments,
      hasLocationBidAdjustments: hasLocationBidAdjustments,
      hasScheduleBidAdjustments: hasScheduleBidAdjustments
    };
  }
  
  /**
   * Evaluates campaign organization
   * @param {Object} accountData The collected account data
   * @return {Object} Evaluation results for campaign organization
   */
  function evaluateCampaignOrganization(accountData) {
    Logger.log("Evaluating campaign organization...");
    
    // Initialize results object
    const results = {
      score: 0,
      letter: '',
      criteria: {},
      recommendations: [],
      data: {
        structure: accountData.structure || {},
        campaigns: accountData.campaigns || []
      }
    };
    
    // 1. Evaluate logical campaign & ad group structure
    const structureResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get structure data
    const campaignCount = accountData.structure?.campaignCount || 0;
    const adGroupCount = accountData.structure?.adGroupCount || 0;
    const keywordCount = accountData.structure?.keywordCount || 0;
    const averageAdGroupsPerCampaign = accountData.structure?.avgAdGroupsPerCampaign || 0;
    const averageKeywordsPerAdGroup = accountData.structure?.avgKeywordsPerAdGroup || 0;
    
    // Store metrics in details
    structureResult.details.campaignCount = campaignCount;
    structureResult.details.adGroupCount = adGroupCount;
    structureResult.details.keywordCount = keywordCount;
    structureResult.details.averageAdGroupsPerCampaign = averageAdGroupsPerCampaign;
    structureResult.details.averageKeywordsPerAdGroup = averageKeywordsPerAdGroup;
    
    // Evaluate average keywords per ad group
    let keywordsPerAdGroupScore = 100;
    if (averageKeywordsPerAdGroup > CONFIG.bestPractices.keywordsPerAdGroup * 2) {
      keywordsPerAdGroupScore = 50;
      structureResult.recommendations.push({
        text: "Your ad groups contain too many keywords on average (" + averageKeywordsPerAdGroup.toFixed(1) + "). Consider restructuring to have fewer, more tightly themed keywords per ad group.",
        impact: 0.8
      });
    } else if (averageKeywordsPerAdGroup > CONFIG.bestPractices.keywordsPerAdGroup) {
      keywordsPerAdGroupScore = 75;
      structureResult.recommendations.push({
        text: "Your ad groups contain more keywords than recommended (" + averageKeywordsPerAdGroup.toFixed(1) + " vs. ideal " + CONFIG.bestPractices.keywordsPerAdGroup + "). Consider tightening your ad group themes.",
        impact: 0.6
      });
    } else if (averageKeywordsPerAdGroup === 0) {
      keywordsPerAdGroupScore = 50;
      structureResult.recommendations.push({
        text: "No keywords found in your account. Add relevant keywords to your ad groups.",
        impact: 0.9
      });
    }
    
    // Evaluate ad groups per campaign
    let adGroupsPerCampaignScore = 100;
    if (averageAdGroupsPerCampaign < 2 && campaignCount > 0) {
      adGroupsPerCampaignScore = 70;
      structureResult.recommendations.push({
        text: "Your campaigns have very few ad groups on average (" + averageAdGroupsPerCampaign.toFixed(1) + "). Consider creating more specific ad groups to better organize your keywords.",
        impact: 0.5
      });
    } else if (averageAdGroupsPerCampaign > 20) {
      adGroupsPerCampaignScore = 80;
      structureResult.recommendations.push({
        text: "Your campaigns have a high number of ad groups on average (" + averageAdGroupsPerCampaign.toFixed(1) + "). Consider splitting large campaigns into more focused ones.",
        impact: 0.4
      });
    } else if (campaignCount === 0) {
      adGroupsPerCampaignScore = 0;
      structureResult.recommendations.push({
        text: "No active campaigns found. Create campaigns to organize your advertising efforts.",
        impact: 1.0
      });
    }
    
    // Calculate structure score
    structureResult.score = (keywordsPerAdGroupScore + adGroupsPerCampaignScore) / 2;
    results.criteria.logicalStructure = structureResult;
    
    // 2. Evaluate naming conventions & segmentation
    const namingResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Simplified naming convention check (would be more sophisticated in a real implementation)
    // Check if campaigns follow a consistent naming pattern
    const campaigns = accountData.campaigns || [];
    let consistentNamingCount = 0;
    let segmentationScore = 0;
    
    // Check for common naming patterns
    const namingPatterns = {
      locationPattern: /\b(north|south|east|west|regional|local|national|global)\b/i,
      productPattern: /\b(product|service|category|brand)\b/i,
      purposePattern: /\b(brand|non-brand|generic|competitor|display|search|shopping)\b/i
    };
    
    const campaignsByPattern = {
      locationPattern: 0,
      productPattern: 0,
      purposePattern: 0
    };
    
    campaigns.forEach(campaign => {
      for (const pattern in namingPatterns) {
        if (namingPatterns[pattern].test(campaign.name)) {
          campaignsByPattern[pattern]++;
          break;
        }
      }
    });
    
    // Calculate percentage of campaigns with consistent naming
    const maxPatternCount = Math.max(...Object.values(campaignsByPattern));
    const consistentNamingPercentage = campaigns.length > 0 ? maxPatternCount / campaigns.length : 0;
    
    namingResult.details.consistentNamingPercentage = consistentNamingPercentage * 100;
    
    // Check for campaign segmentation by type
    const campaignTypes = {};
    campaigns.forEach(campaign => {
      if (!campaignTypes[campaign.type]) {
        campaignTypes[campaign.type] = 0;
      }
      campaignTypes[campaign.type]++;
    });
    
    const campaignTypeCount = Object.keys(campaignTypes).length;
    namingResult.details.campaignTypeCount = campaignTypeCount;
    
    // Score naming conventions
    if (consistentNamingPercentage >= 0.8) {
      namingResult.score = 90;
    } else if (consistentNamingPercentage >= 0.6) {
      namingResult.score = 75;
      namingResult.recommendations.push({
        text: "Only " + Math.round(consistentNamingPercentage * 100) + "% of your campaigns follow a consistent naming convention. Standardize naming for better organization.",
        impact: 0.6
      });
    } else if (campaigns.length > 0) {
      namingResult.score = 50;
      namingResult.recommendations.push({
        text: "Your campaign naming lacks consistency. Implement a standardized naming convention that includes purpose, product/service, and targeting criteria.",
        impact: 0.7
      });
    } else {
      namingResult.score = 0;
      namingResult.recommendations.push({
        text: "No campaigns found to evaluate naming conventions.",
        impact: 0.5
      });
    }
    
    // Add segmentation recommendation if needed
    if (campaignTypeCount < 2 && campaigns.length > 5) {
      namingResult.score -= 10;
      namingResult.recommendations.push({
        text: "Consider segmenting campaigns by different campaign types (Search, Display, Shopping) for better performance management.",
        impact: 0.5
      });
    }
    
    results.criteria.namingConventions = namingResult;
    
    // 3. Evaluate internal competition
    const competitionResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Check for duplicate keywords across ad groups
    const duplicateKeywordPercentage = accountData.structure?.duplicateKeywords / accountData.structure?.keywordCount || 0;
    competitionResult.details.duplicateKeywordPercentage = duplicateKeywordPercentage * 100;
    
    // Score based on duplicate keywords
    if (duplicateKeywordPercentage <= 0.05) {
      competitionResult.score = 90;
    } else if (duplicateKeywordPercentage <= 0.1) {
      competitionResult.score = 75;
      competitionResult.recommendations.push({
        text: "You have " + Math.round(duplicateKeywordPercentage * 100) + "% duplicate keywords across ad groups. Review and remove duplicates to prevent internal competition.",
        impact: 0.6
      });
    } else if (accountData.structure?.keywordCount > 0) {
      competitionResult.score = 50;
      competitionResult.recommendations.push({
        text: "High level of keyword duplication (" + Math.round(duplicateKeywordPercentage * 100) + "%) across ad groups. This causes internal competition and wasted spend.",
        impact: 0.8
      });
    } else {
      competitionResult.score = 50;
      competitionResult.recommendations.push({
        text: "Ensure you don't have duplicate keywords across ad groups to prevent internal competition.",
        impact: 0.7
      });
    }
    
    results.criteria.internalCompetition = competitionResult;
    
    // Calculate overall category score (weighted average of criteria scores)
    const categoryInfo = EVALUATION_CATEGORIES.find(c => c.name === "Campaign Organization");
    let weightedScoreSum = 0;
    let weightSum = 0;
    
    categoryInfo.criteria.forEach(criterion => {
      const criterionKey = criterion.name.toLowerCase().replace(/\s+|&/g, '').replace(/[^a-z0-9]/g, '');
      const criterionResult = results.criteria[criterionKey];
      
      if (criterionResult) {
        weightedScoreSum += criterionResult.score * criterion.weight;
        weightSum += criterion.weight;
        
        // Add recommendations to the category level
        criterionResult.recommendations.forEach(rec => {
          results.recommendations.push(rec);
        });
      }
    });
    
    
  // Calculate overall score using data-driven approach
  const categoryMetrics = {};
  const categoryBenchmarks = {};
  const categoryWeights = {};
  
  // Collect metrics from each criterion
  for (const criterion in results.criteria) {
    if (results.criteria[criterion] && results.criteria[criterion].score !== undefined) {
      categoryMetrics[criterion] = results.criteria[criterion].score;
      categoryBenchmarks[criterion] = 80; // Benchmark score for each criterion
      categoryWeights[criterion] = 1.0; // Default weight
    }
  }
  
  // Calculate overall score using data-driven approach
  if (typeof calculateDataDrivenScore === 'function' && Object.keys(categoryMetrics).length > 0) {
    results.score = calculateDataDrivenScore(categoryMetrics, categoryBenchmarks, {
      missingDataScore: 30,
      higherIsBetter: true,
      weights: categoryWeights,
      applyCurve: true,
      curveFactor: 1.2,
      minimumScore: 0,
      maximumScore: 100
    });
  } else {
    // Fallback to traditional calculation if the function doesn't exist or no metrics
    let weightedScoreSum = 0;
    let weightSum = 0;
    
    for (const criterion in results.criteria) {
      if (results.criteria[criterion] && results.criteria[criterion].score !== undefined) {
        const weight = categoryWeights[criterion] || 1.0;
        weightedScoreSum += results.criteria[criterion].score * weight;
        weightSum += weight;
      }
    }
    
    results.score = weightSum > 0 ? weightedScoreSum / weightSum : 0;
  } // Default to 30 if no data
    
    // Assign letter grade
    if (results.score >= CONFIG.gradeThresholds.A) {
      results.letter = 'A';
    } else if (results.score >= CONFIG.gradeThresholds.B) {
      results.letter = 'B';
    } else if (results.score >= CONFIG.gradeThresholds.C) {
      results.letter = 'C';
    } else if (results.score >= CONFIG.gradeThresholds.D) {
      results.letter = 'D';
    } else {
      results.letter = 'F';
    }
    
    return results;
  }
  
  /**
   * Evaluates conversion tracking
   * @param {Object} accountData The collected account data
   * @return {Object} Evaluation results for conversion tracking
   */
  function evaluateConversionTracking(accountData) {
    Logger.log("Evaluating conversion tracking...");
    
    // Initialize results object
    const results = {
      score: 0,
      letter: '',
      criteria: {},
      recommendations: []
    };
    
    // 1. Evaluate comprehensive conversion coverage
    const coverageResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get conversion data
    const conversionCount = accountData.conversionActionCount || accountData.conversionTracking.count || 0;
    const hasPhoneCallTracking = accountData.phoneCallConversionCount > 0 || accountData.conversionTracking.hasPhoneCallTracking || false;
    const hasImportedConversions = accountData.importedConversionCount > 0 || accountData.conversionTracking.hasImportedConversions || false;
    
    coverageResult.details.conversionCount = conversionCount;
    coverageResult.details.hasPhoneCallTracking = hasPhoneCallTracking;
    coverageResult.details.hasImportedConversions = hasImportedConversions;
    
    // Score based on conversion count and types
    if (conversionCount >= 3 && hasPhoneCallTracking && hasImportedConversions) {
      coverageResult.score = 95;
    } else if (conversionCount >= 2) {
      coverageResult.score = 80;
      
      if (!hasPhoneCallTracking) {
        coverageResult.recommendations.push({
          text: "Add phone call conversion tracking to capture valuable phone leads.",
          impact: 0.7
        });
      }
      
      if (!hasImportedConversions && accountData.account.isEcommerce) {
        coverageResult.recommendations.push({
          text: "Set up offline conversion imports to track sales that happen outside of your website.",
          impact: 0.6
        });
      }
    } else if (conversionCount >= 1) {
      coverageResult.score = 60;
      coverageResult.recommendations.push({
        text: "You have only " + conversionCount + " conversion action. Set up additional conversion actions to track different user goals.",
        impact: 0.8
      });
    } else {
      coverageResult.score = 20;
      coverageResult.recommendations.push({
        text: "No conversion tracking detected. Set up conversion tracking immediately to measure campaign effectiveness.",
        impact: 1.0
      });
    }
    
    results.criteria.comprehensiveConversionCoverage = coverageResult;
    
    // 2. Evaluate accurate and verified tracking implementation
    const implementationResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Check for conversion value tracking
    const valueTrackingCount = accountData.performance && accountData.performance.conversionValue > 0 ? accountData.conversionActionCount : (accountData.conversionTracking.valueTrackingCount || 0);
    const valueTrackingPercentage = conversionCount > 0 ? valueTrackingCount / conversionCount : 0;
    
    implementationResult.details.valueTrackingPercentage = valueTrackingPercentage * 100;
    
    // Score based on value tracking
    if (valueTrackingPercentage >= 0.8) {
      implementationResult.score = 90;
    } else if (valueTrackingPercentage >= 0.5) {
      implementationResult.score = 75;
      implementationResult.recommendations.push({
        text: "Only " + Math.round(valueTrackingPercentage * 100) + "% of your conversion actions have value tracking. Add values to all meaningful conversions.",
        impact: 0.6
      });
    } else if (conversionCount > 0) {
      implementationResult.score = 50;
      implementationResult.recommendations.push({
        text: "Most of your conversion actions don't have value tracking. Add conversion values to optimize for revenue/value instead of just conversion count.",
        impact: 0.8
      });
    } else {
      implementationResult.score = 0;
    }
    
    results.criteria.accurateAndVerifiedTrackingImplementation = implementationResult;
    
    // 3. Evaluate enhanced & offline conversion tracking
    const enhancedResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Check for enhanced conversions
    const hasEnhancedConversions = accountData.conversionTracking.hasEnhancedConversions || false;
    const hasDataDrivenAttribution = (accountData.attributionModels && accountData.attributionModels.dataDriven > 0) || accountData.conversionTracking.hasDataDrivenAttribution || false;
    
    enhancedResult.details.hasEnhancedConversions = hasEnhancedConversions;
    enhancedResult.details.hasDataDrivenAttribution = hasDataDrivenAttribution;
    
    // Score based on enhanced features
    if (hasEnhancedConversions && hasDataDrivenAttribution) {
      enhancedResult.score = 95;
    } else if (hasEnhancedConversions || hasDataDrivenAttribution) {
      enhancedResult.score = 75;
      
      if (!hasEnhancedConversions) {
        enhancedResult.recommendations.push({
          text: "Implement enhanced conversions to improve measurement accuracy, especially in browsers with tracking limitations.",
          impact: 0.7
        });
      }
      
      if (!hasDataDrivenAttribution) {
        enhancedResult.recommendations.push({
          text: "Switch to data-driven attribution to more accurately credit conversions across the customer journey.",
          impact: 0.6
        });
      }
    } else if (conversionCount > 0) {
      enhancedResult.score = 50;
      enhancedResult.recommendations.push({
        text: "Your account isn't using enhanced conversion features. Implement enhanced conversions and data-driven attribution for better measurement.",
        impact: 0.7
      });
    } else {
      enhancedResult.score = 0;
    }
    
    results.criteria.enhancedOfflineConversionTracking = enhancedResult;
    
    // Calculate overall category score (weighted average of criteria scores)
    const categoryInfo = EVALUATION_CATEGORIES.find(c => c.name === "Conversion Tracking");
    let weightedScoreSum = 0;
    let weightSum = 0;
    
    categoryInfo.criteria.forEach(criterion => {
      const criterionKey = criterion.name.toLowerCase().replace(/\s+|&/g, '').replace(/[^a-z0-9]/g, '');
      const criterionResult = results.criteria[criterionKey];
      
      if (criterionResult) {
        weightedScoreSum += criterionResult.score * criterion.weight;
        weightSum += criterion.weight;
        
        // Add recommendations to the category level
        criterionResult.recommendations.forEach(rec => {
          results.recommendations.push(rec);
        });
      }
    });
    
    
  // Calculate overall score using data-driven approach
  const categoryMetrics = {};
  const categoryBenchmarks = {};
  const categoryWeights = {};
  
  // Collect metrics from each criterion
  for (const criterion in results.criteria) {
    if (results.criteria[criterion] && results.criteria[criterion].score !== undefined) {
      categoryMetrics[criterion] = results.criteria[criterion].score;
      categoryBenchmarks[criterion] = 80; // Benchmark score for each criterion
      categoryWeights[criterion] = 1.0; // Default weight
    }
  }
  
  // Calculate overall score using data-driven approach
  if (typeof calculateDataDrivenScore === 'function' && Object.keys(categoryMetrics).length > 0) {
    results.score = calculateDataDrivenScore(categoryMetrics, categoryBenchmarks, {
      missingDataScore: 30,
      higherIsBetter: true,
      weights: categoryWeights,
      applyCurve: true,
      curveFactor: 1.2,
      minimumScore: 0,
      maximumScore: 100
    });
  } else {
    // Fallback to traditional calculation if the function doesn't exist or no metrics
    let weightedScoreSum = 0;
    let weightSum = 0;
    
    for (const criterion in results.criteria) {
      if (results.criteria[criterion] && results.criteria[criterion].score !== undefined) {
        const weight = categoryWeights[criterion] || 1.0;
        weightedScoreSum += results.criteria[criterion].score * weight;
        weightSum += weight;
      }
    }
    
    results.score = weightSum > 0 ? weightedScoreSum / weightSum : 0;
  }
    
    // Assign letter grade
    if (results.score >= CONFIG.gradeThresholds.A) {
      results.letter = 'A';
    } else if (results.score >= CONFIG.gradeThresholds.B) {
      results.letter = 'B';
    } else if (results.score >= CONFIG.gradeThresholds.C) {
      results.letter = 'C';
    } else if (results.score >= CONFIG.gradeThresholds.D) {
      results.letter = 'D';
    } else {
      results.letter = 'F';
    }
    
    // Enhanced recommendations based on specific issues
    if (conversionCount === 0) {
      results.recommendations.push({
        text: "No conversion tracking detected. Set up conversion tracking immediately to measure campaign effectiveness.",
        impact: 9.5,
        timeToImplement: "1-2 days",
        timeToSeeResults: "Immediate for data collection, 2-4 weeks for optimization benefits",
        pointsImprovement: "20-25 points",
        details: "Complete conversion tracking is fundamental to performance optimization. Without it, automated bidding strategies cannot function effectively."
      });
    } else if (conversionCount < 3) {
      results.recommendations.push({
        text: `You have only ${conversionCount} conversion action(s). Set up additional conversion actions to track different user goals.`,
        impact: 8.0,
        timeToImplement: "1 day",
        timeToSeeResults: "Immediate for data, 2-3 weeks for optimization",
        pointsImprovement: "15-20 points",
        details: "Multiple conversion actions provide more complete performance data and enable more sophisticated optimization strategies."
      });
    }
    
    if (!hasPhoneCallTracking && accountData.account.hasPhoneNumber) {
      results.recommendations.push({
        text: "Add phone call conversion tracking to capture valuable phone leads.",
        impact: 7.5,
        timeToImplement: "2-4 hours",
        timeToSeeResults: "1-2 weeks",
        pointsImprovement: "10-15 points",
        details: "Call tracking can capture 15-30% additional conversions that would otherwise go untracked, especially important for service businesses."
      });
    }
    
    // More enhanced recommendations...
    
    return results;
  }
  
  /**
   * Evaluates keyword strategy
   * @param {Object} accountData The collected account data
   * @return {Object} Evaluation results for keyword strategy
   */
  function evaluateKeywordStrategy(accountData) {
    Logger.log("Evaluating keyword strategy...");
    
    // Initialize results object
    const results = {
      score: 0,
      letter: '',
      criteria: {},
      recommendations: []
    };
    
    // 1. Evaluate extensive keyword research & relevance
    const researchResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get keyword data
    const keywordCount = accountData.structure.keywordCount || 0;
    const keywordLengthDistribution = accountData.keywords.lengthDistribution || {
      short: 0,
      medium: 0,
      long: 0
    };
    
    // Calculate percentage of long-tail keywords
    const longTailPercentage = keywordCount > 0 ? 
      (keywordLengthDistribution.medium + keywordLengthDistribution.long) / keywordCount : 0;
    
    researchResult.details.keywordCount = keywordCount;
    researchResult.details.longTailPercentage = longTailPercentage * 100;
    
    // Score based on keyword count and long-tail percentage
    if (keywordCount >= 500 && longTailPercentage >= 0.7) {
      researchResult.score = 90;
    } else if (keywordCount >= 200 && longTailPercentage >= 0.5) {
      researchResult.score = 75;
      
      if (longTailPercentage < 0.7) {
        researchResult.recommendations.push({
          text: "Increase your long-tail keyword coverage. Only " + Math.round(longTailPercentage * 100) + "% of your keywords are medium or long-tail phrases.",
          impact: 0.6
        });
      }
    } else if (keywordCount >= 100) {
      researchResult.score = 60;
      researchResult.recommendations.push({
        text: "Expand your keyword list with more specific, long-tail keywords that match user search intent.",
        impact: 0.7
      });
    } else {
      researchResult.score = 40;
      researchResult.recommendations.push({
        text: "Your keyword list is limited (" + keywordCount + " keywords). Conduct comprehensive keyword research to expand your reach.",
        impact: 0.8
      });
    }
    
    results.criteria.extensiveKeywordResearchRelevance = researchResult;
    
    // 2. Evaluate strategic match type use
    const matchTypeResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get match type distribution
    const matchTypeDistribution = accountData.keywords.matchTypeDistribution || {
      EXACT: 0,
      PHRASE: 0,
      BROAD: 0
    };
    
    // Calculate percentages
    const totalMatchTypes = matchTypeDistribution.EXACT + matchTypeDistribution.PHRASE + matchTypeDistribution.BROAD;
    const exactPercentage = totalMatchTypes > 0 ? matchTypeDistribution.EXACT / totalMatchTypes : 0;
    const phrasePercentage = totalMatchTypes > 0 ? matchTypeDistribution.PHRASE / totalMatchTypes : 0;
    const broadPercentage = totalMatchTypes > 0 ? matchTypeDistribution.BROAD / totalMatchTypes : 0;
    
    matchTypeResult.details.exactPercentage = exactPercentage * 100;
    matchTypeResult.details.phrasePercentage = phrasePercentage * 100;
    matchTypeResult.details.broadPercentage = broadPercentage * 100;
    
    // Score based on match type balance
    if (exactPercentage >= 0.3 && phrasePercentage >= 0.2 && broadPercentage >= 0.2) {
      matchTypeResult.score = 90;
    } else if (exactPercentage >= 0.2 && (phrasePercentage + broadPercentage) >= 0.3) {
      matchTypeResult.score = 75;
      
      if (exactPercentage < 0.3) {
        matchTypeResult.recommendations.push({
          text: "Increase your exact match keywords from " + Math.round(exactPercentage * 100) + "% to at least 30% for better control over traffic quality.",
          impact: 0.6
        });
      }
    } else if (totalMatchTypes > 0) {
      matchTypeResult.score = 60;
      
      if (exactPercentage < 0.2) {
        matchTypeResult.recommendations.push({
          text: "Your exact match keyword percentage is too low (" + Math.round(exactPercentage * 100) + "%). Add more exact match keywords for your core terms.",
          impact: 0.7
        });
      }
      
      if (broadPercentage > 0.7) {
        matchTypeResult.recommendations.push({
          text: "Your account relies too heavily on broad match (" + Math.round(broadPercentage * 100) + "%). Balance with more exact and phrase match keywords.",
          impact: 0.7
        });
      }
    } else {
      matchTypeResult.score = 0;
    }
    
    results.criteria.strategicMatchTypeUse = matchTypeResult;
    
    // 3. Evaluate brand vs non-brand segmentation
    const brandResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get brand keyword data
    const brandKeywordPercentage = accountData.keywords.brandKeywordPercentage || 0;
    const hasBrandCampaigns = accountData.keywords.hasBrandCampaigns || false;
    
    brandResult.details.brandKeywordPercentage = brandKeywordPercentage * 100;
    brandResult.details.hasBrandCampaigns = hasBrandCampaigns;
    
    // Score based on brand segmentation
    if (hasBrandCampaigns && brandKeywordPercentage <= 0.3) {
      brandResult.score = 90;
    } else if (hasBrandCampaigns) {
      brandResult.score = 75;
      
      if (brandKeywordPercentage > 0.3) {
        brandResult.recommendations.push({
          text: "Your account has a high percentage of brand keywords (" + Math.round(brandKeywordPercentage * 100) + "%). Focus more on non-brand terms to expand reach.",
          impact: 0.5
        });
      }
    } else if (brandKeywordPercentage > 0) {
      brandResult.score = 60;
      brandResult.recommendations.push({
        text: "Create dedicated brand campaigns to separate brand and non-brand performance metrics and bidding strategies.",
        impact: 0.7
      });
    } else {
      brandResult.score = 50;
      brandResult.recommendations.push({
        text: "No brand keywords detected. If applicable, add brand terms in dedicated campaigns for high-quality traffic.",
        impact: 0.6
      });
    }
    
    results.criteria.brandVsNonbrandSegmentation = brandResult;
    
    // 4. Evaluate continuous keyword optimization
    const optimizationResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get optimization data
    const lowQualityKeywordPercentage = accountData.keywords.lowQualityKeywordPercentage || 0;
    const nonConvertingKeywordPercentage = accountData.keywords.nonConvertingKeywordPercentage || 0;
    
    optimizationResult.details.lowQualityKeywordPercentage = lowQualityKeywordPercentage * 100;
    optimizationResult.details.nonConvertingKeywordPercentage = nonConvertingKeywordPercentage * 100;
    
    // Score based on keyword optimization
    if (lowQualityKeywordPercentage <= 0.1 && nonConvertingKeywordPercentage <= 0.2) {
      optimizationResult.score = 90;
    } else if (lowQualityKeywordPercentage <= 0.2 && nonConvertingKeywordPercentage <= 0.3) {
      optimizationResult.score = 75;
      
      if (lowQualityKeywordPercentage > 0.1) {
        optimizationResult.recommendations.push({
          text: "Address the " + Math.round(lowQualityKeywordPercentage * 100) + "% of keywords with low quality scores by improving ad relevance and landing pages.",
          impact: 0.6
        });
      }
    } else {
      optimizationResult.score = 50;
      
      if (nonConvertingKeywordPercentage > 0.3) {
        optimizationResult.recommendations.push({
          text: "Review and optimize the " + Math.round(nonConvertingKeywordPercentage * 100) + "% of keywords with clicks but no conversions.",
          impact: 0.8
        });
      }
      
      if (lowQualityKeywordPercentage > 0.2) {
        optimizationResult.recommendations.push({
          text: "Your account has a high percentage (" + Math.round(lowQualityKeywordPercentage * 100) + "%) of low quality score keywords. Pause or improve these keywords.",
          impact: 0.7
        });
      }
    }
    
    results.criteria.continuousKeywordOptimization = optimizationResult;
    
    // Calculate overall category score (weighted average of criteria scores)
    const categoryInfo = EVALUATION_CATEGORIES.find(c => c.name === "Keyword Strategy");
    let weightedScoreSum = 0;
    let weightSum = 0;
    
    categoryInfo.criteria.forEach(criterion => {
      const criterionKey = criterion.name.toLowerCase().replace(/\s+|&/g, '').replace(/[^a-z0-9]/g, '');
      const criterionResult = results.criteria[criterionKey];
      
      if (criterionResult) {
        weightedScoreSum += criterionResult.score * criterion.weight;
        weightSum += criterion.weight;
        
        // Add recommendations to the category level
        criterionResult.recommendations.forEach(rec => {
          results.recommendations.push(rec);
        });
      }
    });
    
    
  // Calculate overall score using data-driven approach
  const categoryMetrics = {};
  const categoryBenchmarks = {};
  const categoryWeights = {};
  
  // Collect metrics from each criterion
  for (const criterion in results.criteria) {
    if (results.criteria[criterion] && results.criteria[criterion].score !== undefined) {
      categoryMetrics[criterion] = results.criteria[criterion].score;
      categoryBenchmarks[criterion] = 80; // Benchmark score for each criterion
      categoryWeights[criterion] = 1.0; // Default weight
    }
  }
  
  // Calculate overall score using data-driven approach
  if (typeof calculateDataDrivenScore === 'function' && Object.keys(categoryMetrics).length > 0) {
    results.score = calculateDataDrivenScore(categoryMetrics, categoryBenchmarks, {
      missingDataScore: 30,
      higherIsBetter: true,
      weights: categoryWeights,
      applyCurve: true,
      curveFactor: 1.2,
      minimumScore: 0,
      maximumScore: 100
    });
  } else {
    // Fallback to traditional calculation if the function doesn't exist or no metrics
    let weightedScoreSum = 0;
    let weightSum = 0;
    
    for (const criterion in results.criteria) {
      if (results.criteria[criterion] && results.criteria[criterion].score !== undefined) {
        const weight = categoryWeights[criterion] || 1.0;
        weightedScoreSum += results.criteria[criterion].score * weight;
        weightSum += weight;
      }
    }
    
    results.score = weightSum > 0 ? weightedScoreSum / weightSum : 0;
  }
    
    // Assign letter grade
    if (results.score >= CONFIG.gradeThresholds.A) {
      results.letter = 'A';
    } else if (results.score >= CONFIG.gradeThresholds.B) {
      results.letter = 'B';
    } else if (results.score >= CONFIG.gradeThresholds.C) {
      results.letter = 'C';
    } else if (results.score >= CONFIG.gradeThresholds.D) {
      results.letter = 'D';
    } else {
      results.letter = 'F';
    }
    
    return results;
  }
  
  /**
   * Evaluates negative keywords
   * @param {Object} accountData The collected account data
   * @return {Object} Evaluation results for negative keywords
   */
  function evaluateNegativeKeywords(accountData) {
    Logger.log("Evaluating negative keywords...");
    
    // Initialize results object
    const results = {
      score: 0,
      letter: '',
      criteria: {},
      recommendations: []
    };
    
    // 1. Evaluate routine search query mining
    const miningResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get negative keyword data
    const negativeKeywordCount = accountData.negativeKeywords.count || 0;
    const campaignCount = accountData.structure.campaignCount || 0;
    const adGroupCount = accountData.structure.adGroupCount || 0;
    
    // Calculate negatives per campaign/ad group
    const negativesPerCampaign = campaignCount > 0 ? negativeKeywordCount / campaignCount : 0;
    const negativesPerAdGroup = adGroupCount > 0 ? negativeKeywordCount / adGroupCount : 0;
    
    miningResult.details.negativeKeywordCount = negativeKeywordCount;
    miningResult.details.negativesPerCampaign = negativesPerCampaign;
    miningResult.details.negativesPerAdGroup = negativesPerAdGroup;
    
    // Score based on negative keyword volume
    if (negativesPerCampaign >= 30) {
      miningResult.score = 90;
    } else if (negativesPerCampaign >= 15) {
      miningResult.score = 75;
      miningResult.recommendations.push({
        text: "Increase your negative keyword count through regular search query mining. You have " + 
              negativeKeywordCount + " negatives (" + negativesPerCampaign.toFixed(1) + " per campaign).",
        impact: 0.6
      });
    } else if (negativesPerCampaign > 0) {
      miningResult.score = 50;
      miningResult.recommendations.push({
        text: "Your negative keyword coverage is limited (" + negativesPerCampaign.toFixed(1) + 
              " per campaign). Implement weekly search query mining to identify irrelevant terms.",
        impact: 0.8
      });
    } else {
      miningResult.score = 20;
      miningResult.recommendations.push({
        text: "No negative keywords found. Add negative keywords immediately to prevent wasted spend on irrelevant searches.",
        impact: 0.9
      });
    }
    
    results.criteria.routineSearchQueryMining = miningResult;
    
    // 2. Evaluate negative keyword organization
    const organizationResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get negative keyword organization data
    const campaignLevelCount = accountData.negativeKeywords.campaignLevel || 0;
    const adGroupLevelCount = accountData.negativeKeywords.adGroupLevel || 0;
    const sharedSetCount = accountData.negativeKeywords.sharedSetCount || 0;
    
    organizationResult.details.campaignLevelCount = campaignLevelCount;
    organizationResult.details.adGroupLevelCount = adGroupLevelCount;
    organizationResult.details.sharedSetCount = sharedSetCount;
    
    // Calculate percentage at each level
    const totalNegatives = campaignLevelCount + adGroupLevelCount;
    const campaignLevelPercentage = totalNegatives > 0 ? campaignLevelCount / totalNegatives : 0;
    const adGroupLevelPercentage = totalNegatives > 0 ? adGroupLevelCount / totalNegatives : 0;
    
    organizationResult.details.campaignLevelPercentage = campaignLevelPercentage * 100;
    organizationResult.details.adGroupLevelPercentage = adGroupLevelPercentage * 100;
    
    // Score based on negative keyword organization
    if (sharedSetCount >= 3 && campaignLevelCount > 0 && adGroupLevelCount > 0) {
      organizationResult.score = 90;
    } else if (sharedSetCount >= 1 && (campaignLevelCount > 0 || adGroupLevelCount > 0)) {
      organizationResult.score = 75;
      
      if (campaignLevelCount === 0 || adGroupLevelCount === 0) {
        organizationResult.recommendations.push({
          text: "Use both campaign-level and ad group-level negative keywords for more granular control.",
          impact: 0.5
        });
      }
    } else if (totalNegatives > 0) {
      organizationResult.score = 60;
      
      if (sharedSetCount === 0) {
        organizationResult.recommendations.push({
          text: "Create negative keyword lists to efficiently manage negatives across multiple campaigns.",
          impact: 0.7
        });
      }
    } else {
      organizationResult.score = 0;
    }
    
    results.criteria.negativeKeywordOrganization = organizationResult;
    
    // 3. Evaluate negative match types
    const matchTypeResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get negative match type data (simplified for this example)
    const hasExactNegatives = accountData.negativeKeywords.hasExactNegatives || false;
    const hasPhraseNegatives = accountData.negativeKeywords.hasPhraseNegatives || false;
    const exactNegativePercentage = accountData.negativeKeywords.exactNegativePercentage || 0;
    const phraseNegativePercentage = accountData.negativeKeywords.phraseNegativePercentage || 0;
    
    matchTypeResult.details.hasExactNegatives = hasExactNegatives;
    matchTypeResult.details.hasPhraseNegatives = hasPhraseNegatives;
    matchTypeResult.details.exactNegativePercentage = exactNegativePercentage * 100;
    matchTypeResult.details.phraseNegativePercentage = phraseNegativePercentage * 100;
    
    // Score based on negative match type usage
    if (hasExactNegatives && hasPhraseNegatives) {
      matchTypeResult.score = 90;
      
      if (exactNegativePercentage < 0.2) {
        matchTypeResult.recommendations.push({
          text: "Consider using more exact match negatives for precise exclusion of specific terms.",
          impact: 0.5
        });
      }
    } else if (hasPhraseNegatives) {
      matchTypeResult.score = 70;
      matchTypeResult.recommendations.push({
        text: "Add exact match negative keywords for more precise control over excluded terms.",
        impact: 0.6
      });
    } else if (hasExactNegatives) {
      matchTypeResult.score = 60;
      matchTypeResult.recommendations.push({
        text: "Add phrase match negative keywords to exclude broader variations of irrelevant terms.",
        impact: 0.7
      });
    } else if (negativeKeywordCount > 0) {
      matchTypeResult.score = 50;
      matchTypeResult.recommendations.push({
        text: "Use both phrase and exact match negative keywords for comprehensive exclusion control.",
        impact: 0.7
      });
    } else {
      matchTypeResult.score = 0;
    }
    
    results.criteria.strategicNegativeMatchTypes = matchTypeResult;
    
    // Calculate overall category score (weighted average of criteria scores)
    const categoryInfo = EVALUATION_CATEGORIES.find(c => c.name === "Negative Keywords");
    let weightedScoreSum = 0;
    let weightSum = 0;
    
    categoryInfo.criteria.forEach(criterion => {
      const criterionKey = criterion.name.toLowerCase().replace(/\s+|&/g, '').replace(/[^a-z0-9]/g, '');
      const criterionResult = results.criteria[criterionKey];
      
      if (criterionResult) {
        weightedScoreSum += criterionResult.score * criterion.weight;
        weightSum += criterion.weight;
        
        // Add recommendations to the category level
        criterionResult.recommendations.forEach(rec => {
          results.recommendations.push(rec);
        });
      }
    });
    
    
  // Calculate overall score using data-driven approach
  const categoryMetrics = {};
  const categoryBenchmarks = {};
  const categoryWeights = {};
  
  // Collect metrics from each criterion
  for (const criterion in results.criteria) {
    if (results.criteria[criterion] && results.criteria[criterion].score !== undefined) {
      categoryMetrics[criterion] = results.criteria[criterion].score;
      categoryBenchmarks[criterion] = 80; // Benchmark score for each criterion
      categoryWeights[criterion] = 1.0; // Default weight
    }
  }
  
  // Calculate overall score using data-driven approach
  if (typeof calculateDataDrivenScore === 'function' && Object.keys(categoryMetrics).length > 0) {
    results.score = calculateDataDrivenScore(categoryMetrics, categoryBenchmarks, {
      missingDataScore: 30,
      higherIsBetter: true,
      weights: categoryWeights,
      applyCurve: true,
      curveFactor: 1.2,
      minimumScore: 0,
      maximumScore: 100
    });
  } else {
    // Fallback to traditional calculation if the function doesn't exist or no metrics
    let weightedScoreSum = 0;
    let weightSum = 0;
    
    for (const criterion in results.criteria) {
      if (results.criteria[criterion] && results.criteria[criterion].score !== undefined) {
        const weight = categoryWeights[criterion] || 1.0;
        weightedScoreSum += results.criteria[criterion].score * weight;
        weightSum += weight;
      }
    }
    
    results.score = weightSum > 0 ? weightedScoreSum / weightSum : 0;
  }
    
    // Assign letter grade
    if (results.score >= CONFIG.gradeThresholds.A) {
      results.letter = 'A';
    } else if (results.score >= CONFIG.gradeThresholds.B) {
      results.letter = 'B';
    } else if (results.score >= CONFIG.gradeThresholds.C) {
      results.letter = 'C';
    } else if (results.score >= CONFIG.gradeThresholds.D) {
      results.letter = 'D';
    } else {
      results.letter = 'F';
    }
    
    return results;
  }
  
  /**
   * Evaluates bidding strategy
   * @param {Object} accountData The collected account data
   * @return {Object} Evaluation results for bidding strategy
   */
  function evaluateBiddingStrategy(accountData) {
    Logger.log("Evaluating bidding strategy...");
    
    // Initialize results object
    const results = {
      score: 0,
      letter: '',
      criteria: {},
      recommendations: [],
      data: {
        bidding: accountData.bidding || {}
      }
    };
    
    // 1. Evaluate smart bidding adoption
    const smartBiddingResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get bidding strategy data
    const biddingStrategies = accountData.bidding?.strategies || {};
    const smartBiddingCount = accountData.bidding?.smartBiddingCount || 0;
    const totalCampaigns = accountData.bidding?.totalCampaigns || accountData.campaignCount || 0;
    const portfolioBiddingStrategyCount = accountData.bidding?.portfolioBiddingStrategyCount || 0;
    
    // Calculate smart bidding percentage
    const smartBiddingPercentage = totalCampaigns > 0 ? smartBiddingCount / totalCampaigns : 0;
    
    smartBiddingResult.details.smartBiddingPercentage = smartBiddingPercentage * 100;
    smartBiddingResult.details.manualBiddingPercentage = 100 - (smartBiddingPercentage * 100);
    smartBiddingResult.details.totalCampaigns = totalCampaigns;
    smartBiddingResult.details.smartBiddingCount = smartBiddingCount;
    smartBiddingResult.details.portfolioBiddingStrategyCount = portfolioBiddingStrategyCount;
    
    // Score based on smart bidding adoption
    if (smartBiddingPercentage >= 0.8) {
      smartBiddingResult.score = 90;
    } else if (smartBiddingPercentage >= 0.5) {
      smartBiddingResult.score = 75;
      smartBiddingResult.recommendations.push({
        text: "Increase smart bidding adoption from " + Math.round(smartBiddingPercentage * 100) + 
              "% to at least 80% of campaigns to leverage Google's machine learning.",
        impact: 0.7
      });
    } else if (smartBiddingPercentage > 0) {
      smartBiddingResult.score = 50;
      smartBiddingResult.recommendations.push({
        text: "Significantly increase smart bidding usage. Only " + Math.round(smartBiddingPercentage * 100) + 
              "% of your campaigns use smart bidding strategies.",
        impact: 0.8
      });
    } else if (totalCampaigns > 0) {
      smartBiddingResult.score = 20;
      smartBiddingResult.recommendations.push({
        text: "Implement smart bidding strategies (Target CPA, Target ROAS) to optimize for conversions instead of manual bidding.",
        impact: 0.9
      });
    } else {
      smartBiddingResult.score = 0;
      smartBiddingResult.recommendations.push({
        text: "No active campaigns found. Create campaigns and implement smart bidding strategies.",
        impact: 1.0
      });
    }
    
    // Add portfolio bidding strategy recommendation if applicable
    if (portfolioBiddingStrategyCount === 0 && totalCampaigns >= 5) {
      smartBiddingResult.recommendations.push({
        text: "Consider using portfolio bidding strategies to optimize performance across multiple campaigns with similar goals.",
        impact: 0.7
      });
    }
    
    results.criteria.smartBiddingAdoption = smartBiddingResult;
    
    // 2. Evaluate bid strategy alignment with goals
    const alignmentResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get goal alignment data
    const hasConversionTracking = accountData.performance?.conversions > 0;
    const hasValueTracking = accountData.performance?.conversionValue > 0;
    const hasTargetRoas = (accountData.bidding?.targetRoasCount || 0) > 0;
    const hasTargetCpa = (accountData.bidding?.targetCpaCount || 0) > 0;
    const hasMaximizeConversions = (accountData.bidding?.maximizeConversionsCount || 0) > 0;
    const hasPortfolioTargetRoas = biddingStrategies['TARGET_ROAS (Portfolio)'] > 0;
    const hasPortfolioTargetCpa = biddingStrategies['TARGET_CPA (Portfolio)'] > 0;
    
    alignmentResult.details.hasConversionTracking = hasConversionTracking;
    alignmentResult.details.hasValueTracking = hasValueTracking;
    alignmentResult.details.hasTargetRoas = hasTargetRoas;
    alignmentResult.details.hasTargetCpa = hasTargetCpa;
    alignmentResult.details.hasMaximizeConversions = hasMaximizeConversions;
    alignmentResult.details.hasPortfolioTargetRoas = hasPortfolioTargetRoas;
    alignmentResult.details.hasPortfolioTargetCpa = hasPortfolioTargetCpa;
    
    // Score based on bid strategy alignment
    if (hasValueTracking && (hasTargetRoas || hasPortfolioTargetRoas)) {
      alignmentResult.score = 90;
    } else if (hasConversionTracking && (hasTargetCpa || hasMaximizeConversions || hasPortfolioTargetCpa)) {
      alignmentResult.score = 80;
      
      if (hasValueTracking && !hasTargetRoas && !hasPortfolioTargetRoas) {
        alignmentResult.recommendations.push({
          text: "You're tracking conversion values but not using Target ROAS bidding. Switch appropriate campaigns to Target ROAS to optimize for value.",
          impact: 0.7
        });
      }
    } else if (hasConversionTracking) {
      alignmentResult.score = 60;
      alignmentResult.recommendations.push({
        text: "Align your bidding strategy with your conversion goals by implementing Target CPA or Maximize Conversions bidding for conversion-focused campaigns.",
        impact: 0.8
      });
    } else if (totalCampaigns > 0) {
      alignmentResult.score = 30;
      alignmentResult.recommendations.push({
        text: "Set up conversion tracking before implementing smart bidding strategies.",
        impact: 1.0
      });
    } else {
      alignmentResult.score = 0;
    }
    
    results.criteria.bidStrategyAlignmentWithGoals = alignmentResult;
    
    // 3. Evaluate bid adjustments
    const adjustmentsResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get bid adjustment data
    const hasMobileBidAdjustments = accountData.bidding?.hasDeviceBidAdjustments || false;
    const hasLocationBidAdjustments = accountData.bidding?.hasLocationBidAdjustments || false;
    const hasAudienceBidAdjustments = accountData.bidding?.hasAudienceBidAdjustments || false;
    const hasScheduleBidAdjustments = accountData.bidding?.hasScheduleBidAdjustments || false;
    
    adjustmentsResult.details.hasMobileBidAdjustments = hasMobileBidAdjustments;
    adjustmentsResult.details.hasLocationBidAdjustments = hasLocationBidAdjustments;
    adjustmentsResult.details.hasAudienceBidAdjustments = hasAudienceBidAdjustments;
    adjustmentsResult.details.hasScheduleBidAdjustments = hasScheduleBidAdjustments;
    
    // Count number of adjustment types used
    const adjustmentCount = [
      hasMobileBidAdjustments,
      hasLocationBidAdjustments,
      hasAudienceBidAdjustments,
      hasScheduleBidAdjustments
    ].filter(Boolean).length;
    
    // Score based on bid adjustments
    if (adjustmentCount >= 3) {
      adjustmentsResult.score = 90;
    } else if (adjustmentCount >= 2) {
      adjustmentsResult.score = 75;
      
      if (!hasMobileBidAdjustments) {
        adjustmentsResult.recommendations.push({
          text: "Add mobile bid adjustments to optimize performance across devices.",
          impact: 0.6
        });
      }
      
      if (!hasLocationBidAdjustments) {
        adjustmentsResult.recommendations.push({
          text: "Implement location bid adjustments to optimize for geographic performance differences.",
          impact: 0.6
        });
      }
    } else if (adjustmentCount >= 1) {
      adjustmentsResult.score = 60;
      adjustmentsResult.recommendations.push({
        text: "Expand your use of bid adjustments. You're only using " + adjustmentCount + " out of 4 possible adjustment types.",
        impact: 0.7
      });
    } else if (totalCampaigns > 0) {
      adjustmentsResult.score = 40;
      adjustmentsResult.recommendations.push({
        text: "Implement bid adjustments for device, location, audience, and ad schedule to optimize performance.",
        impact: 0.8
      });
    } else {
      adjustmentsResult.score = 0;
    }
    
    results.criteria.comprehensiveBidAdjustments = adjustmentsResult;
    
    // 4. Evaluate impression share and budget utilization
    const impressionShareResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get impression share data
    const impressionShare = accountData.bidding?.impressionShare || 0;
    const budgetLost = accountData.bidding?.budgetLost || 0;
    const rankLost = accountData.bidding?.rankLost || 0;
    
    impressionShareResult.details.impressionShare = impressionShare * 100;
    impressionShareResult.details.budgetLost = budgetLost * 100;
    impressionShareResult.details.rankLost = rankLost * 100;
    
    // Score based on impression share metrics
    if (impressionShare >= 0.8 && budgetLost <= 0.1) {
      impressionShareResult.score = 90;
    } else if (impressionShare >= 0.6) {
      impressionShareResult.score = 75;
      
      if (budgetLost > 0.2) {
        impressionShareResult.recommendations.push({
          text: "You're losing " + Math.round(budgetLost * 100) + "% impression share due to budget constraints. Consider increasing budgets for your best-performing campaigns.",
          impact: 0.8
        });
      }
      
      if (rankLost > 0.2) {
        impressionShareResult.recommendations.push({
          text: "You're losing " + Math.round(rankLost * 100) + "% impression share due to ad rank. Improve quality scores and consider bid adjustments.",
          impact: 0.7
        });
      }
    } else if (impressionShare > 0) {
      impressionShareResult.score = 50;
      impressionShareResult.recommendations.push({
        text: "Your search impression share is only " + Math.round(impressionShare * 100) + "%. Increase budgets and improve ad rank to show your ads more often.",
        impact: 0.8
      });
    } else {
      impressionShareResult.score = 30;
      impressionShareResult.recommendations.push({
        text: "No impression share data available. Ensure your campaigns are active and have sufficient budget.",
        impact: 0.7
      });
    }
    
    results.criteria.impressionShareAndBudgetUtilization = impressionShareResult;
    
    // Calculate overall category score (weighted average of criteria scores)
    const categoryInfo = EVALUATION_CATEGORIES.find(c => c.name === "Bidding Strategy");
    let weightedScoreSum = 0;
    let weightSum = 0;
    
    categoryInfo.criteria.forEach(criterion => {
      const criterionKey = criterion.name.toLowerCase().replace(/\s+|&/g, '').replace(/[^a-z0-9]/g, '');
      const criterionResult = results.criteria[criterionKey];
      
      if (criterionResult) {
        weightedScoreSum += criterionResult.score * criterion.weight;
        weightSum += criterion.weight;
        
        // Add recommendations to the category level
        criterionResult.recommendations.forEach(rec => {
          results.recommendations.push(rec);
        });
      }
    });
    
    
  // Calculate overall score using data-driven approach
  const categoryMetrics = {};
  const categoryBenchmarks = {};
  const categoryWeights = {};
  
  // Collect metrics from each criterion
  for (const criterion in results.criteria) {
    if (results.criteria[criterion] && results.criteria[criterion].score !== undefined) {
      categoryMetrics[criterion] = results.criteria[criterion].score;
      categoryBenchmarks[criterion] = 80; // Benchmark score for each criterion
      categoryWeights[criterion] = 1.0; // Default weight
    }
  }
  
  // Calculate overall score using data-driven approach
  if (typeof calculateDataDrivenScore === 'function' && Object.keys(categoryMetrics).length > 0) {
    results.score = calculateDataDrivenScore(categoryMetrics, categoryBenchmarks, {
      missingDataScore: 30,
      higherIsBetter: true,
      weights: categoryWeights,
      applyCurve: true,
      curveFactor: 1.2,
      minimumScore: 0,
      maximumScore: 100
    });
  } else {
    // Fallback to traditional calculation if the function doesn't exist or no metrics
    let weightedScoreSum = 0;
    let weightSum = 0;
    
    for (const criterion in results.criteria) {
      if (results.criteria[criterion] && results.criteria[criterion].score !== undefined) {
        const weight = categoryWeights[criterion] || 1.0;
        weightedScoreSum += results.criteria[criterion].score * weight;
        weightSum += weight;
      }
    }
    
    results.score = weightSum > 0 ? weightedScoreSum / weightSum : 0;
  } // Default to 30 if no data
    
    // Assign letter grade
    if (results.score >= CONFIG.gradeThresholds.A) {
      results.letter = 'A';
    } else if (results.score >= CONFIG.gradeThresholds.B) {
      results.letter = 'B';
    } else if (results.score >= CONFIG.gradeThresholds.C) {
      results.letter = 'C';
    } else if (results.score >= CONFIG.gradeThresholds.D) {
      results.letter = 'D';
    } else {
      results.letter = 'F';
    }
    
    return results;
  }
  
  /**
   * Evaluates ad creative and extensions
   * @param {Object} accountData The collected account data
   * @return {Object} Evaluation results for ad creative and extensions
   */
  function evaluateAdCreative(accountData) {
    Logger.log("Evaluating ad creative and extensions...");
    
    // Initialize results object
    const results = {
      score: 0,
      letter: '',
      criteria: {},
      recommendations: []
    };
    
    // 1. Evaluate responsive search ad adoption
    const rsaResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get RSA data
    const rsaPercentage = accountData.ads.rsaPercentage || 0;
    const averageHeadlinesPerRsa = accountData.ads.averageHeadlinesPerRsa || 0;
    const averageDescriptionsPerRsa = accountData.ads.averageDescriptionsPerRsa || 0;
    
    rsaResult.details.rsaPercentage = rsaPercentage * 100;
    rsaResult.details.averageHeadlinesPerRsa = averageHeadlinesPerRsa;
    rsaResult.details.averageDescriptionsPerRsa = averageDescriptionsPerRsa;
    
    // Score based on RSA adoption and asset count
    if (rsaPercentage >= 0.9 && averageHeadlinesPerRsa >= 12 && averageDescriptionsPerRsa >= 4) {
      rsaResult.score = 95;
    } else if (rsaPercentage >= 0.8 && averageHeadlinesPerRsa >= 10 && averageDescriptionsPerRsa >= 3) {
      rsaResult.score = 80;
      
      if (averageHeadlinesPerRsa < 12) {
        rsaResult.recommendations.push({
          text: "Add more headlines to your RSAs. You're using " + averageHeadlinesPerRsa.toFixed(1) + " on average, but should aim for all 15 possible headlines.",
          impact: 0.6
        });
      }
      
      if (averageDescriptionsPerRsa < 4) {
        rsaResult.recommendations.push({
          text: "Add more descriptions to your RSAs. You're using " + averageDescriptionsPerRsa.toFixed(1) + " on average, but should aim for all 4 possible descriptions.",
          impact: 0.5
        });
      }
    } else if (rsaPercentage >= 0.6) {
      rsaResult.score = 60;
      rsaResult.recommendations.push({
        text: "Increase your RSA adoption from " + Math.round(rsaPercentage * 100) + "% to at least 90% of all ad groups.",
        impact: 0.8
      });
    } else {
      rsaResult.score = 40;
      rsaResult.recommendations.push({
        text: "Upgrade to Responsive Search Ads in all ad groups. Only " + Math.round(rsaPercentage * 100) + "% of your ad groups use RSAs.",
        impact: 0.9
      });
    }
    
    results.criteria.responsiveSearchAdAdoption = rsaResult;
    
    // 2. Evaluate ad rotation and testing
    const rotationResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get ad rotation data
    const averageAdsPerAdGroup = accountData.ads.averageAdsPerAdGroup || 0;
    const singleAdAdGroupPercentage = accountData.ads.singleAdAdGroupPercentage || 0;
    
    rotationResult.details.averageAdsPerAdGroup = averageAdsPerAdGroup;
    rotationResult.details.singleAdAdGroupPercentage = singleAdAdGroupPercentage * 100;
    
    // Score based on ad count per ad group
    if (averageAdsPerAdGroup >= CONFIG.bestPractices.adsPerAdGroup && singleAdAdGroupPercentage <= 0.05) {
      rotationResult.score = 90;
    } else if (averageAdsPerAdGroup >= 2 && singleAdAdGroupPercentage <= 0.2) {
      rotationResult.score = 75;
      
      if (averageAdsPerAdGroup < CONFIG.bestPractices.adsPerAdGroup) {
        rotationResult.recommendations.push({
          text: "Increase your average ads per ad group from " + averageAdsPerAdGroup.toFixed(1) + " to at least " + CONFIG.bestPractices.adsPerAdGroup + " for better testing and performance.",
          impact: 0.7
        });
      }
    } else {
      rotationResult.score = 50;
      rotationResult.recommendations.push({
        text: Math.round(singleAdAdGroupPercentage * 100) + "% of your ad groups have only one ad. Add at least one more ad to each ad group for testing.",
        impact: 0.8
      });
    }
    
    results.criteria.adRotationAndTesting = rotationResult;
    
    // 3. Evaluate ad extensions
    const extensionsResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get extension data
    const extensionTypeCount = accountData.extensions.totalCount || 0;
    const impressionWithExtensionsPercentage = accountData.extensions.impressionWithExtensions / accountData.performance.impressions || 0;
    
    extensionsResult.details.extensionTypeCount = extensionTypeCount;
    extensionsResult.details.impressionWithExtensionsPercentage = impressionWithExtensionsPercentage * 100;
    
    // Score based on extension usage
    if (extensionTypeCount >= CONFIG.bestPractices.minExtensionTypes && impressionWithExtensionsPercentage >= 0.7) {
      extensionsResult.score = 90;
    } else if (extensionTypeCount >= 3 && impressionWithExtensionsPercentage >= 0.5) {
      extensionsResult.score = 75;
      
      if (extensionTypeCount < CONFIG.bestPractices.minExtensionTypes) {
        extensionsResult.recommendations.push({
          text: "Add more extension types. You're using " + extensionTypeCount + " types, but should aim for at least " + CONFIG.bestPractices.minExtensionTypes + ".",
          impact: 0.7
        });
      }
    } else if (extensionTypeCount >= 1) {
      extensionsResult.score = 50;
      extensionsResult.recommendations.push({
        text: "Expand your ad extension usage. Only " + Math.round(impressionWithExtensionsPercentage * 100) + "% of impressions include extensions.",
        impact: 0.8
      });
    } else {
      extensionsResult.score = 20;
      extensionsResult.recommendations.push({
        text: "Implement ad extensions immediately. Extensions increase CTR and provide additional information to users.",
        impact: 0.9
      });
    }
    
    results.criteria.adExtensions = extensionsResult;
    
    // Calculate overall category score (weighted average of criteria scores)
    const categoryInfo = EVALUATION_CATEGORIES.find(c => c.name === "Ad Creative & Extensions");
    let weightedScoreSum = 0;
    let weightSum = 0;
    
    categoryInfo.criteria.forEach(criterion => {
      const criterionKey = criterion.name.toLowerCase().replace(/\s+|&/g, '').replace(/[^a-z0-9]/g, '');
      const criterionResult = results.criteria[criterionKey];
      
      if (criterionResult) {
        weightedScoreSum += criterionResult.score * criterion.weight;
        weightSum += criterion.weight;
        
        // Add recommendations to the category level
        criterionResult.recommendations.forEach(rec => {
          results.recommendations.push(rec);
        });
      }
    });
    
    
  // Calculate overall score using data-driven approach
  const categoryMetrics = {};
  const categoryBenchmarks = {};
  const categoryWeights = {};
  
  // Collect metrics from each criterion
  for (const criterion in results.criteria) {
    if (results.criteria[criterion] && results.criteria[criterion].score !== undefined) {
      categoryMetrics[criterion] = results.criteria[criterion].score;
      categoryBenchmarks[criterion] = 80; // Benchmark score for each criterion
      categoryWeights[criterion] = 1.0; // Default weight
    }
  }
  
  // Calculate overall score using data-driven approach
  if (typeof calculateDataDrivenScore === 'function' && Object.keys(categoryMetrics).length > 0) {
    results.score = calculateDataDrivenScore(categoryMetrics, categoryBenchmarks, {
      missingDataScore: 30,
      higherIsBetter: true,
      weights: categoryWeights,
      applyCurve: true,
      curveFactor: 1.2,
      minimumScore: 0,
      maximumScore: 100
    });
  } else {
    // Fallback to traditional calculation if the function doesn't exist or no metrics
    let weightedScoreSum = 0;
    let weightSum = 0;
    
    for (const criterion in results.criteria) {
      if (results.criteria[criterion] && results.criteria[criterion].score !== undefined) {
        const weight = categoryWeights[criterion] || 1.0;
        weightedScoreSum += results.criteria[criterion].score * weight;
        weightSum += weight;
      }
    }
    
    results.score = weightSum > 0 ? weightedScoreSum / weightSum : 0;
  }
    
    // Assign letter grade
    if (results.score >= CONFIG.gradeThresholds.A) {
      results.letter = 'A';
    } else if (results.score >= CONFIG.gradeThresholds.B) {
      results.letter = 'B';
    } else if (results.score >= CONFIG.gradeThresholds.C) {
      results.letter = 'C';
    } else if (results.score >= CONFIG.gradeThresholds.D) {
      results.letter = 'D';
    } else {
      results.letter = 'F';
    }
    
    return results;
  }
  
  /**
   * Evaluates quality score
   * @param {Object} accountData The collected account data
   * @return {Object} Evaluation results for quality score
   */
  function evaluateQualityScore(accountData) {
    Logger.log("Evaluating quality score...");
    
    // Initialize results object
    const results = {
      score: 0,
      letter: '',
      criteria: {},
      recommendations: []
    };
    
    // 1. Evaluate average quality score
    const averageQsResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get quality score data - use the directly collected data, not structure
    const qualityScoreData = accountData.qualityScore || {};
    const averageQualityScore = qualityScoreData.averageQualityScore || 0;
    const benchmarkQualityScore = CONFIG.industryBenchmarks.qualityScore || 0;
    
    averageQsResult.details.averageQualityScore = averageQualityScore;
    averageQsResult.details.benchmarkQualityScore = benchmarkQualityScore;
    
    // Calculate QS comparison to benchmark
    const qsComparison = benchmarkQualityScore > 0 ? averageQualityScore / benchmarkQualityScore : 0;
    averageQsResult.details.qualityScoreComparison = qsComparison;
    
    // Score based on average quality score
    if (averageQualityScore >= CONFIG.bestPractices.minQualityScore + 1) {
      averageQsResult.score = 90;
    } else if (averageQualityScore >= CONFIG.bestPractices.minQualityScore) {
      averageQsResult.score = 80;
      averageQsResult.recommendations.push({
        text: "Your average quality score of " + averageQualityScore.toFixed(1) + " is good, but aim to improve it further through better ad relevance and landing page experience.",
        impact: 0.6
      });
    } else if (averageQualityScore >= 5) {
      averageQsResult.score = 60;
      averageQsResult.recommendations.push({
        text: "Your average quality score of " + averageQualityScore.toFixed(1) + " is average. Improve ad relevance and landing page experience to boost performance.",
        impact: 0.7
      });
    } else if (averageQualityScore > 0) {
      averageQsResult.score = 40;
      averageQsResult.recommendations.push({
        text: "Your average quality score of " + averageQualityScore.toFixed(1) + " is below average. Focus on improving ad relevance and landing page experience.",
        impact: 0.8
      });
    } else {
      averageQsResult.score = 30;
      averageQsResult.recommendations.push({
        text: "No quality score data available. Ensure your keywords have sufficient impression volume to receive quality scores.",
        impact: 0.8
      });
    }
    
    // 2. Evaluate quality score distribution
    const distributionResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get distribution data
    const distribution = qualityScoreData.distribution || {};
    const totalKeywords = qualityScoreData.totalKeywords || 0;
    
    // Calculate percentage of keywords with good quality scores (7-10)
    let goodQsCount = 0;
    for (let i = 7; i <= 10; i++) {
      goodQsCount += distribution[i] || 0;
    }
    
    const goodQsPercentage = totalKeywords > 0 ? (goodQsCount / totalKeywords) * 100 : 0;
    distributionResult.details.goodQsPercentage = goodQsPercentage;
    
    // Calculate percentage of keywords with poor quality scores (1-4)
    let poorQsCount = 0;
    for (let i = 1; i <= 4; i++) {
      poorQsCount += distribution[i] || 0;
    }
    
    const poorQsPercentage = totalKeywords > 0 ? (poorQsCount / totalKeywords) * 100 : 0;
    distributionResult.details.poorQsPercentage = poorQsPercentage;
    
    // Score based on distribution
    if (goodQsPercentage >= 70) {
      distributionResult.score = 90;
    } else if (goodQsPercentage >= 50) {
      distributionResult.score = 80;
      distributionResult.recommendations.push({
        text: "You have " + goodQsPercentage.toFixed(1) + "% of keywords with good quality scores (7-10). Continue optimizing the remaining keywords.",
        impact: 0.6
      });
    } else if (goodQsPercentage >= 30) {
      distributionResult.score = 60;
      distributionResult.recommendations.push({
        text: "Only " + goodQsPercentage.toFixed(1) + "% of your keywords have good quality scores (7-10). Focus on improving your lower-performing keywords.",
        impact: 0.7
      });
    } else if (goodQsPercentage > 0) {
      distributionResult.score = 40;
      distributionResult.recommendations.push({
        text: "Only " + goodQsPercentage.toFixed(1) + "% of your keywords have good quality scores (7-10). Consider restructuring ad groups for better keyword-to-ad relevance.",
        impact: 0.8
      });
    } else {
      distributionResult.score = 30;
      distributionResult.recommendations.push({
        text: "No keywords with good quality scores (7-10) found. Focus on improving ad relevance and landing page experience.",
        impact: 0.8
      });
    }
    
    // 3. Evaluate quality score components
    const componentsResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get component data
    const expectedCtr = qualityScoreData.expectedCtr || {};
    const adRelevance = qualityScoreData.adRelevance || {};
    const landingPage = qualityScoreData.landingPage || {};
    
    // Calculate percentage of keywords with above average components
    const aboveAvgCtrPercentage = totalKeywords > 0 ? ((expectedCtr.above_average || 0) / totalKeywords) * 100 : 0;
    const aboveAvgAdRelPercentage = totalKeywords > 0 ? ((adRelevance.above_average || 0) / totalKeywords) * 100 : 0;
    const aboveAvgLpPercentage = totalKeywords > 0 ? ((landingPage.above_average || 0) / totalKeywords) * 100 : 0;
    
    componentsResult.details.aboveAvgCtrPercentage = aboveAvgCtrPercentage;
    componentsResult.details.aboveAvgAdRelPercentage = aboveAvgAdRelPercentage;
    componentsResult.details.aboveAvgLpPercentage = aboveAvgLpPercentage;
    
    // Calculate percentage of keywords with below average components
    const belowAvgCtrPercentage = totalKeywords > 0 ? ((expectedCtr.below_average || 0) / totalKeywords) * 100 : 0;
    const belowAvgAdRelPercentage = totalKeywords > 0 ? ((adRelevance.below_average || 0) / totalKeywords) * 100 : 0;
    const belowAvgLpPercentage = totalKeywords > 0 ? ((landingPage.below_average || 0) / totalKeywords) * 100 : 0;
    
    componentsResult.details.belowAvgCtrPercentage = belowAvgCtrPercentage;
    componentsResult.details.belowAvgAdRelPercentage = belowAvgAdRelPercentage;
    componentsResult.details.belowAvgLpPercentage = belowAvgLpPercentage;
    
    // Identify the weakest component
    const weakestComponent = {
      name: '',
      percentage: 0
    };
    
    if (belowAvgCtrPercentage > weakestComponent.percentage) {
      weakestComponent.name = 'Expected CTR';
      weakestComponent.percentage = belowAvgCtrPercentage;
    }
    
    if (belowAvgAdRelPercentage > weakestComponent.percentage) {
      weakestComponent.name = 'Ad Relevance';
      weakestComponent.percentage = belowAvgAdRelPercentage;
    }
    
    if (belowAvgLpPercentage > weakestComponent.percentage) {
      weakestComponent.name = 'Landing Page Experience';
      weakestComponent.percentage = belowAvgLpPercentage;
    }
    
    componentsResult.details.weakestComponent = weakestComponent;
    
    // Score based on components
    const avgAbovePercentage = (aboveAvgCtrPercentage + aboveAvgAdRelPercentage + aboveAvgLpPercentage) / 3;
    
    if (avgAbovePercentage >= 70) {
      componentsResult.score = 90;
    } else if (avgAbovePercentage >= 50) {
      componentsResult.score = 80;
      componentsResult.recommendations.push({
        text: "Your quality score components are generally good, but focus on improving " + weakestComponent.name + " to boost overall quality scores.",
        impact: 0.6
      });
    } else if (avgAbovePercentage >= 30) {
      componentsResult.score = 60;
      componentsResult.recommendations.push({
        text: "Your " + weakestComponent.name + " needs improvement. " + getRecommendationForComponent(weakestComponent.name),
        impact: 0.7
      });
    } else if (avgAbovePercentage > 0) {
      componentsResult.score = 40;
      componentsResult.recommendations.push({
        text: "Your " + weakestComponent.name + " is significantly below average. " + getRecommendationForComponent(weakestComponent.name),
        impact: 0.8
      });
    } else {
      componentsResult.score = 30;
      componentsResult.recommendations.push({
        text: "No quality score component data available. Focus on improving ad relevance by ensuring ads closely match the keywords in each ad group.",
        impact: 0.8
      });
    }
    
    // Calculate overall quality score
    results.criteria.averageQualityScore = averageQsResult;
    results.criteria.qualityScoreDistribution = distributionResult;
    results.criteria.qualityScoreComponents = componentsResult;
    
    // Calculate weighted score
    const weightedScore = (
      averageQsResult.score * 0.4 +
      distributionResult.score * 0.3 +
      componentsResult.score * 0.3
    );
    
    
  // Calculate overall score using data-driven approach
  const categoryMetrics = {};
  const categoryBenchmarks = {};
  const categoryWeights = {};
  
  // Collect metrics from each criterion
  for (const criterion in results.criteria) {
    if (results.criteria[criterion] && results.criteria[criterion].score !== undefined) {
      categoryMetrics[criterion] = results.criteria[criterion].score;
      categoryBenchmarks[criterion] = 80; // Benchmark score for each criterion
      categoryWeights[criterion] = 1.0; // Default weight
    }
  }
  
  // Calculate overall score using data-driven approach
  if (typeof calculateDataDrivenScore === 'function' && Object.keys(categoryMetrics).length > 0) {
    results.score = calculateDataDrivenScore(categoryMetrics, categoryBenchmarks, {
      missingDataScore: 30,
      higherIsBetter: true,
      weights: categoryWeights,
      applyCurve: true,
      curveFactor: 1.2,
      minimumScore: 0,
      maximumScore: 100
    });
  } else {
    // Fallback to traditional calculation if the function doesn't exist or no metrics
    let weightedScoreSum = 0;
    let weightSum = 0;
    
    for (const criterion in results.criteria) {
      if (results.criteria[criterion] && results.criteria[criterion].score !== undefined) {
        const weight = categoryWeights[criterion] || 1.0;
        weightedScoreSum += results.criteria[criterion].score * weight;
        weightSum += weight;
      }
    }
    
    results.score = weightSum > 0 ? weightedScoreSum / weightSum : 0;
  }
    
    // Assign letter grade
    if (results.score >= 90) {
      results.letter = 'A';
    } else if (results.score >= 80) {
      results.letter = 'B';
    } else if (results.score >= 70) {
      results.letter = 'C';
    } else if (results.score >= 60) {
      results.letter = 'D';
    } else {
      results.letter = 'F';
    }
    
    // Compile recommendations
    const allRecommendations = [
      ...averageQsResult.recommendations,
      ...distributionResult.recommendations,
      ...componentsResult.recommendations
    ];
    
    // Sort by impact and take top 3
    allRecommendations.sort((a, b) => b.impact - a.impact);
    results.recommendations = allRecommendations.slice(0, 3);
    
    return results;
  }
  
  // Helper function to get recommendations for quality score components
  function getRecommendationForComponent(componentName) {
    switch (componentName) {
      case 'Expected CTR':
        return "Improve ad copy with stronger calls-to-action and more compelling headlines.";
      case 'Ad Relevance':
        return "Ensure your ads closely match the keywords in each ad group, possibly by creating more tightly themed ad groups.";
      case 'Landing Page Experience':
        return "Improve your landing pages to provide relevant, original content and a clear call-to-action with a good user experience.";
      default:
        return "Focus on improving all quality score components through better ad and landing page relevance.";
    }
  }
  
  /**
   * Evaluates audience strategy
   * @param {Object} accountData The collected account data
   * @return {Object} Evaluation results for audience strategy
   */
  function evaluateAudienceStrategy(accountData) {
    Logger.log("Evaluating audience strategy...");
    
    // Initialize results object
    const results = {
      score: 0,
      letter: '',
      criteria: {},
      recommendations: []
    };
    
    // 1. Evaluate remarketing implementation
    const remarketingResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get remarketing data
    const remarketingListCount = accountData.audiences.remarketingListCount || 0;
    const activeRemarketingCampaigns = accountData.audiences.activeRemarketingCampaigns || 0;
    const campaignCount = accountData.structure.campaignCount || 0;
    
    // Calculate remarketing coverage
    const remarketingCampaignPercentage = campaignCount > 0 ? 
      activeRemarketingCampaigns / campaignCount : 0;
    
    remarketingResult.details.remarketingListCount = remarketingListCount;
    remarketingResult.details.activeRemarketingCampaigns = activeRemarketingCampaigns;
    remarketingResult.details.remarketingCampaignPercentage = remarketingCampaignPercentage * 100;
    
    // Score based on remarketing implementation
    if (remarketingListCount >= 3 && remarketingCampaignPercentage >= 0.5) {
      remarketingResult.score = 90;
    } else if (remarketingListCount >= 1 && activeRemarketingCampaigns >= 1) {
      remarketingResult.score = 70;
      
      if (remarketingListCount < 3) {
        remarketingResult.recommendations.push({
          text: "Create more remarketing lists to target different user behaviors and funnel stages. You currently have " + remarketingListCount + " list(s).",
          impact: 0.7
        });
      }
      
      if (remarketingCampaignPercentage < 0.5) {
        remarketingResult.recommendations.push({
          text: "Expand remarketing to more campaigns. Only " + Math.round(remarketingCampaignPercentage * 100) + "% of your campaigns use remarketing audiences.",
          impact: 0.6
        });
      }
    } else if (remarketingListCount >= 1) {
      remarketingResult.score = 50;
      remarketingResult.recommendations.push({
        text: "Activate your remarketing lists in campaigns. You have lists created but they're not being used effectively.",
        impact: 0.8
      });
    } else {
      remarketingResult.score = 20;
      remarketingResult.recommendations.push({
        text: "Set up remarketing to re-engage past website visitors. This is a fundamental audience strategy missing from your account.",
        impact: 0.9
      });
    }
    
    results.criteria.remarketingImplementation = remarketingResult;
    
    // 2. Evaluate customer list targeting
    const customerListResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get customer list data
    const hasCustomerMatch = accountData.audiences.hasCustomerMatch || false;
    const customerMatchListCount = accountData.audiences.customerMatchListCount || 0;
    
    customerListResult.details.hasCustomerMatch = hasCustomerMatch;
    customerListResult.details.customerMatchListCount = customerMatchListCount;
    
    // Score based on customer list usage
    if (hasCustomerMatch && customerMatchListCount >= 2) {
      customerListResult.score = 90;
    } else if (hasCustomerMatch) {
      customerListResult.score = 70;
      customerListResult.recommendations.push({
        text: "Create more customer match lists to target different customer segments. You currently have only " + customerMatchListCount + " list(s).",
        impact: 0.6
      });
    } else {
      customerListResult.score = 30;
      customerListResult.recommendations.push({
        text: "Implement customer match to target your existing customers and similar audiences. This powerful feature is missing from your account.",
        impact: 0.8
      });
    }
    
    results.criteria.customerListTargeting = customerListResult;
    
    // 3. Evaluate in-market and affinity audiences
    const inMarketResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get in-market and affinity data
    const hasInMarketAudiences = accountData.audiences.hasInMarketAudiences || false;
    const hasAffinityAudiences = accountData.audiences.hasAffinityAudiences || false;
    const inMarketAudienceCount = accountData.audiences.inMarketAudienceCount || 0;
    const affinityAudienceCount = accountData.audiences.affinityAudienceCount || 0;
    
    inMarketResult.details.hasInMarketAudiences = hasInMarketAudiences;
    inMarketResult.details.hasAffinityAudiences = hasAffinityAudiences;
    inMarketResult.details.inMarketAudienceCount = inMarketAudienceCount;
    inMarketResult.details.affinityAudienceCount = affinityAudienceCount;
    
    // Score based on in-market and affinity usage
    if (hasInMarketAudiences && hasAffinityAudiences) {
      inMarketResult.score = 90;
    } else if (hasInMarketAudiences || hasAffinityAudiences) {
      inMarketResult.score = 70;
      
      if (!hasInMarketAudiences) {
        inMarketResult.recommendations.push({
          text: "Add in-market audiences to target users actively researching products or services like yours.",
          impact: 0.7
        });
      }
      
      if (!hasAffinityAudiences) {
        inMarketResult.recommendations.push({
          text: "Implement affinity audiences to reach users based on their long-term interests and habits.",
          impact: 0.6
        });
      }
    } else {
      inMarketResult.score = 40;
      inMarketResult.recommendations.push({
        text: "Start using Google's in-market and affinity audiences to expand your targeting to relevant prospects.",
        impact: 0.8
      });
    }
    
    results.criteria.inMarketAffinityAudiences = inMarketResult;
    
    // 4. Evaluate audience bid adjustments
    const bidAdjustmentResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get audience bid adjustment data
    const hasAudienceBidAdjustments = accountData.bidding.hasAudienceBidAdjustments || false;
    const audienceBidAdjustmentPercentage = accountData.audiences.audienceBidAdjustmentPercentage || 0;
    
    bidAdjustmentResult.details.hasAudienceBidAdjustments = hasAudienceBidAdjustments;
    bidAdjustmentResult.details.audienceBidAdjustmentPercentage = audienceBidAdjustmentPercentage * 100;
    
    // Score based on audience bid adjustments
    if (hasAudienceBidAdjustments && audienceBidAdjustmentPercentage >= 0.7) {
      bidAdjustmentResult.score = 90;
    } else if (hasAudienceBidAdjustments) {
      bidAdjustmentResult.score = 70;
      bidAdjustmentResult.recommendations.push({
        text: "Expand audience bid adjustments to more of your audiences. Currently only " + 
              Math.round(audienceBidAdjustmentPercentage * 100) + "% of your audiences have bid adjustments.",
        impact: 0.6
      });
    } else {
      bidAdjustmentResult.score = 40;
      bidAdjustmentResult.recommendations.push({
        text: "Implement bid adjustments for your audiences to optimize performance based on user behavior and interests.",
        impact: 0.7
      });
    }
    
    results.criteria.audienceBidAdjustments = bidAdjustmentResult;
    
    // Calculate overall category score (weighted average of criteria scores)
    const categoryInfo = EVALUATION_CATEGORIES.find(c => c.name === "Audience Strategy");
    let weightedScoreSum = 0;
    let weightSum = 0;
    
    categoryInfo.criteria.forEach(criterion => {
      const criterionKey = criterion.name.toLowerCase().replace(/\s+|&/g, '').replace(/[^a-z0-9]/g, '');
      const criterionResult = results.criteria[criterionKey];
      
      if (criterionResult) {
        weightedScoreSum += criterionResult.score * criterion.weight;
        weightSum += criterion.weight;
        
        // Add recommendations to the category level
        criterionResult.recommendations.forEach(rec => {
          results.recommendations.push(rec);
        });
      }
    });
    
    
  // Calculate overall score using data-driven approach
  const categoryMetrics = {};
  const categoryBenchmarks = {};
  const categoryWeights = {};
  
  // Collect metrics from each criterion
  for (const criterion in results.criteria) {
    if (results.criteria[criterion] && results.criteria[criterion].score !== undefined) {
      categoryMetrics[criterion] = results.criteria[criterion].score;
      categoryBenchmarks[criterion] = 80; // Benchmark score for each criterion
      categoryWeights[criterion] = 1.0; // Default weight
    }
  }
  
  // Calculate overall score using data-driven approach
  if (typeof calculateDataDrivenScore === 'function' && Object.keys(categoryMetrics).length > 0) {
    results.score = calculateDataDrivenScore(categoryMetrics, categoryBenchmarks, {
      missingDataScore: 30,
      higherIsBetter: true,
      weights: categoryWeights,
      applyCurve: true,
      curveFactor: 1.2,
      minimumScore: 0,
      maximumScore: 100
    });
  } else {
    // Fallback to traditional calculation if the function doesn't exist or no metrics
    let weightedScoreSum = 0;
    let weightSum = 0;
    
    for (const criterion in results.criteria) {
      if (results.criteria[criterion] && results.criteria[criterion].score !== undefined) {
        const weight = categoryWeights[criterion] || 1.0;
        weightedScoreSum += results.criteria[criterion].score * weight;
        weightSum += weight;
      }
    }
    
    results.score = weightSum > 0 ? weightedScoreSum / weightSum : 0;
  }
    
    // Assign letter grade
    if (results.score >= CONFIG.gradeThresholds.A) {
      results.letter = 'A';
    } else if (results.score >= CONFIG.gradeThresholds.B) {
      results.letter = 'B';
    } else if (results.score >= CONFIG.gradeThresholds.C) {
      results.letter = 'C';
    } else if (results.score >= CONFIG.gradeThresholds.D) {
      results.letter = 'D';
    } else {
      results.letter = 'F';
    }
    
    return results;
  }
  
  /**
   * Evaluates landing page optimization
   * @param {Object} accountData The collected account data
   * @return {Object} Evaluation results for landing page optimization
   */
  function evaluateLandingPage(accountData) {
    Logger.log("Evaluating landing page optimization...");
    
    // Initialize results object
    const results = {
      score: 0,
      letter: '',
      criteria: {},
      recommendations: []
    };
    
    // 1. Evaluate landing page relevance
    const relevanceResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get landing page relevance data
    const goodLandingPagePercentage = accountData.qualityScore.goodLandingPagePercentage || 0;
    const poorLandingPagePercentage = accountData.qualityScore.poorLandingPagePercentage || 0;
    
    relevanceResult.details.goodLandingPagePercentage = goodLandingPagePercentage * 100;
    relevanceResult.details.poorLandingPagePercentage = poorLandingPagePercentage * 100;
    
    // Score based on landing page relevance
    if (goodLandingPagePercentage >= 0.7 && poorLandingPagePercentage <= 0.1) {
      relevanceResult.score = 90;
    } else if (goodLandingPagePercentage >= 0.5) {
      relevanceResult.score = 70;
      relevanceResult.recommendations.push({
        text: "Improve landing page relevance for the " + Math.round(poorLandingPagePercentage * 100) + 
              "% of keywords with below average landing page experience.",
        impact: 0.7
      });
    } else {
      relevanceResult.score = 50;
      relevanceResult.recommendations.push({
        text: "Only " + Math.round(goodLandingPagePercentage * 100) + 
              "% of your keywords have above average landing page experience. Create more relevant landing pages that match search intent.",
        impact: 0.8
      });
    }
    
    results.criteria.landingPageRelevance = relevanceResult;
    
    // 2. Evaluate landing page performance
    const performanceResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get landing page performance data
    const landingPageSpeed = accountData.qualityScore.landingPageSpeed || 0;
    const landingPageConversionRate = accountData.landingPage.conversionRate || 0;
    const industryAvgConversionRate = CONFIG.industryBenchmarks.conversionRate || 3.75;
    
    performanceResult.details.landingPageSpeed = landingPageSpeed;
    performanceResult.details.landingPageConversionRate = landingPageConversionRate;
    performanceResult.details.industryAvgConversionRate = industryAvgConversionRate;
    
    // Score based on landing page performance
    if (landingPageSpeed >= 80 && landingPageConversionRate >= industryAvgConversionRate * 1.2) {
      performanceResult.score = 90;
    } else if (landingPageSpeed >= 70 && landingPageConversionRate >= industryAvgConversionRate * 0.8) {
      performanceResult.score = 70;
      
      if (landingPageSpeed < 80) {
        performanceResult.recommendations.push({
          text: "Improve landing page speed (currently " + landingPageSpeed + "/100). Faster pages lead to better user experience and higher conversion rates.",
          impact: 0.7
        });
      }
      
      if (landingPageConversionRate < industryAvgConversionRate) {
        performanceResult.recommendations.push({
          text: "Your landing page conversion rate (" + landingPageConversionRate.toFixed(2) + 
                "%) is below industry average (" + industryAvgConversionRate.toFixed(2) + "%). Test different layouts and calls-to-action.",
          impact: 0.8
        });
      }
    } else {
      performanceResult.score = 50;
      performanceResult.recommendations.push({
        text: "Your landing pages need significant improvement in both speed and conversion rate. Consider a redesign focused on user experience and conversion optimization.",
        impact: 0.9
      });
    }
    
    results.criteria.landingPagePerformance = performanceResult;
    
    // 3. Evaluate mobile optimization
    const mobileResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get mobile optimization data
    const isMobileFriendly = accountData.landingPage.isMobileFriendly || false;
    const mobileConversionRate = accountData.landingPage.mobileConversionRate || 0;
    const desktopConversionRate = accountData.landingPage.desktopConversionRate || 0;
    
    mobileResult.details.isMobileFriendly = isMobileFriendly;
    mobileResult.details.mobileConversionRate = mobileConversionRate;
    mobileResult.details.desktopConversionRate = desktopConversionRate;
    
    // Calculate mobile-to-desktop conversion ratio
    const mobileDesktopRatio = desktopConversionRate > 0 ? mobileConversionRate / desktopConversionRate : 0;
    mobileResult.details.mobileDesktopRatio = mobileDesktopRatio;
    
    // Score based on mobile optimization
    if (isMobileFriendly && mobileDesktopRatio >= 0.9) {
      mobileResult.score = 90;
    } else if (isMobileFriendly && mobileDesktopRatio >= 0.7) {
      mobileResult.score = 70;
      mobileResult.recommendations.push({
        text: "Your mobile conversion rate is " + Math.round(mobileDesktopRatio * 100) + 
              "% of your desktop rate. Improve mobile UX to close this gap.",
        impact: 0.7
      });
    } else if (isMobileFriendly) {
      mobileResult.score = 50;
      mobileResult.recommendations.push({
        text: "Your mobile conversion rate is significantly lower than desktop. Conduct mobile-specific usability testing to identify and fix issues.",
        impact: 0.8
      });
    } else {
      mobileResult.score = 30;
      mobileResult.recommendations.push({
        text: "Your landing pages are not mobile-friendly. Implement responsive design immediately as mobile traffic continues to grow.",
        impact: 0.9
      });
    }
    
    results.criteria.mobileOptimization = mobileResult;
    
    // 4. Evaluate A/B testing
    const testingResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get A/B testing data
    const isABTestingImplemented = accountData.landingPage.isABTestingImplemented || false;
    const abTestCount = accountData.landingPage.abTestCount || 0;
    
    testingResult.details.isABTestingImplemented = isABTestingImplemented;
    testingResult.details.abTestCount = abTestCount;
    
    // Score based on A/B testing
    if (isABTestingImplemented && abTestCount >= 3) {
      testingResult.score = 90;
    } else if (isABTestingImplemented) {
      testingResult.score = 70;
      testingResult.recommendations.push({
        text: "Expand your A/B testing program. You've run only " + abTestCount + 
              " tests. Aim for continuous testing of different page elements.",
        impact: 0.6
      });
    } else {
      testingResult.score = 40;
      testingResult.recommendations.push({
        text: "Implement A/B testing for your landing pages to systematically improve conversion rates over time.",
        impact: 0.8
      });
    }
    
    results.criteria.abTesting = testingResult;
    
    // Calculate overall category score (weighted average of criteria scores)
    const categoryInfo = EVALUATION_CATEGORIES.find(c => c.name === "Landing Page Optimization");
    let weightedScoreSum = 0;
    let weightSum = 0;
    
    categoryInfo.criteria.forEach(criterion => {
      const criterionKey = criterion.name.toLowerCase().replace(/\s+|&/g, '').replace(/[^a-z0-9]/g, '');
      const criterionResult = results.criteria[criterionKey];
      
      if (criterionResult) {
        weightedScoreSum += criterionResult.score * criterion.weight;
        weightSum += criterion.weight;
        
        // Add recommendations to the category level
        criterionResult.recommendations.forEach(rec => {
          results.recommendations.push(rec);
        });
      }
    });
    
    
  // Calculate overall score using data-driven approach
  const categoryMetrics = {};
  const categoryBenchmarks = {};
  const categoryWeights = {};
  
  // Collect metrics from each criterion
  for (const criterion in results.criteria) {
    if (results.criteria[criterion] && results.criteria[criterion].score !== undefined) {
      categoryMetrics[criterion] = results.criteria[criterion].score;
      categoryBenchmarks[criterion] = 80; // Benchmark score for each criterion
      categoryWeights[criterion] = 1.0; // Default weight
    }
  }
  
  // Calculate overall score using data-driven approach
  if (typeof calculateDataDrivenScore === 'function' && Object.keys(categoryMetrics).length > 0) {
    results.score = calculateDataDrivenScore(categoryMetrics, categoryBenchmarks, {
      missingDataScore: 30,
      higherIsBetter: true,
      weights: categoryWeights,
      applyCurve: true,
      curveFactor: 1.2,
      minimumScore: 0,
      maximumScore: 100
    });
  } else {
    // Fallback to traditional calculation if the function doesn't exist or no metrics
    let weightedScoreSum = 0;
    let weightSum = 0;
    
    for (const criterion in results.criteria) {
      if (results.criteria[criterion] && results.criteria[criterion].score !== undefined) {
        const weight = categoryWeights[criterion] || 1.0;
        weightedScoreSum += results.criteria[criterion].score * weight;
        weightSum += weight;
      }
    }
    
    results.score = weightSum > 0 ? weightedScoreSum / weightSum : 0;
  }
    
    // Assign letter grade
    if (results.score >= CONFIG.gradeThresholds.A) {
      results.letter = 'A';
    } else if (results.score >= CONFIG.gradeThresholds.B) {
      results.letter = 'B';
    } else if (results.score >= CONFIG.gradeThresholds.C) {
      results.letter = 'C';
    } else if (results.score >= CONFIG.gradeThresholds.D) {
      results.letter = 'D';
    } else {
      results.letter = 'F';
    }
    
    return results;
  }
  
  /**
   * Evaluates competitive analysis
   * @param {Object} accountData The collected account data
   * @return {Object} Evaluation results for competitive analysis
   */
  function evaluateCompetitiveAnalysis(accountData) {
    Logger.log("Evaluating competitive analysis...");
    
    // Initialize results object
    const results = {
      score: 0,
      letter: '',
      criteria: {},
      recommendations: []
    };
    
    // 1. Evaluate auction insights monitoring
    const auctionInsightsResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get auction insights data
    const hasAuctionInsightsData = accountData.competitive.hasAuctionInsightsData || false;
    const impressionShare = accountData.competitive.impressionShare || 0;
    const topImpressionShare = accountData.competitive.topImpressionShare || 0;
    
    auctionInsightsResult.details.hasAuctionInsightsData = hasAuctionInsightsData;
    auctionInsightsResult.details.impressionShare = impressionShare * 100;
    auctionInsightsResult.details.topImpressionShare = topImpressionShare * 100;
    
    // Score based on auction insights monitoring
    if (hasAuctionInsightsData && impressionShare >= 0.7) {
      auctionInsightsResult.score = 90;
    } else if (hasAuctionInsightsData && impressionShare >= 0.5) {
      auctionInsightsResult.score = 75;
      auctionInsightsResult.recommendations.push({
        text: "Work on improving your impression share from " + Math.round(impressionShare * 100) + 
              "% to at least 70% in your core markets.",
        impact: 0.7
      });
    } else if (hasAuctionInsightsData) {
      auctionInsightsResult.score = 60;
      auctionInsightsResult.recommendations.push({
        text: "Your impression share is low at " + Math.round(impressionShare * 100) + 
              "%. Increase budgets or improve quality scores to compete more effectively.",
        impact: 0.8
      });
    } else {
      auctionInsightsResult.score = 30;
      auctionInsightsResult.recommendations.push({
        text: "Start monitoring auction insights reports to understand your competitive position in the ad auction.",
        impact: 0.9
      });
    }
    
    results.criteria.auctionInsightsMonitoring = auctionInsightsResult;
    
    // 2. Evaluate competitor keyword targeting
    const competitorKeywordResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get competitor keyword data
    const hasCompetitorCampaigns = accountData.competitive.hasCompetitorCampaigns || false;
    const competitorKeywordCount = accountData.competitive.competitorKeywordCount || 0;
    
    competitorKeywordResult.details.hasCompetitorCampaigns = hasCompetitorCampaigns;
    competitorKeywordResult.details.competitorKeywordCount = competitorKeywordCount;
    
    // Score based on competitor keyword targeting
    if (hasCompetitorCampaigns && competitorKeywordCount >= 50) {
      competitorKeywordResult.score = 90;
    } else if (hasCompetitorCampaigns) {
      competitorKeywordResult.score = 70;
      competitorKeywordResult.recommendations.push({
        text: "Expand your competitor keyword targeting. You're only targeting " + 
              competitorKeywordCount + " competitor keywords.",
        impact: 0.7
      });
    } else {
      competitorKeywordResult.score = 40;
      competitorKeywordResult.recommendations.push({
        text: "Create campaigns targeting competitor brand terms to capture users comparing solutions.",
        impact: 0.8
      });
    }
    
    results.criteria.competitorKeywordTargeting = competitorKeywordResult;
    
    // 3. Evaluate competitive ad copy analysis
    const adCopyResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Get competitive ad copy data
    const hasCompetitiveAdCopyAnalysis = accountData.competitive.hasCompetitiveAdCopyAnalysis || false;
    const competitiveMessagingScore = accountData.competitive.competitiveMessagingScore || 0;
    
    adCopyResult.details.hasCompetitiveAdCopyAnalysis = hasCompetitiveAdCopyAnalysis;
    adCopyResult.details.competitiveMessagingScore = competitiveMessagingScore;
    
    // Score based on competitive ad copy analysis
    if (hasCompetitiveAdCopyAnalysis && competitiveMessagingScore >= 80) {
      adCopyResult.score = 90;
    } else if (hasCompetitiveAdCopyAnalysis) {
      adCopyResult.score = 70;
      adCopyResult.recommendations.push({
        text: "Improve your competitive messaging in ad copy to better differentiate from competitors.",
        impact: 0.6
      });
    } else {
      adCopyResult.score = 40;
      adCopyResult.recommendations.push({
        text: "Analyze competitor ads and develop messaging that highlights your unique value propositions.",
        impact: 0.7
      });
    }
    
    results.criteria.competitiveAdCopyAnalysis = adCopyResult;
    
    // Calculate overall category score (weighted average of criteria scores)
    const categoryInfo = EVALUATION_CATEGORIES.find(c => c.name === "Competitive Analysis");
    let weightedScoreSum = 0;
    let weightSum = 0;
    
    categoryInfo.criteria.forEach(criterion => {
      const criterionKey = criterion.name.toLowerCase().replace(/\s+|&/g, '').replace(/[^a-z0-9]/g, '');
      const criterionResult = results.criteria[criterionKey];
      
      if (criterionResult) {
        weightedScoreSum += criterionResult.score * criterion.weight;
        weightSum += criterion.weight;
        
        // Add recommendations to the category level
        criterionResult.recommendations.forEach(rec => {
          results.recommendations.push(rec);
        });
      }
    });
    
    
  // Calculate overall score using data-driven approach
  const categoryMetrics = {};
  const categoryBenchmarks = {};
  const categoryWeights = {};
  
  // Collect metrics from each criterion
  for (const criterion in results.criteria) {
    if (results.criteria[criterion] && results.criteria[criterion].score !== undefined) {
      categoryMetrics[criterion] = results.criteria[criterion].score;
      categoryBenchmarks[criterion] = 80; // Benchmark score for each criterion
      categoryWeights[criterion] = 1.0; // Default weight
    }
  }
  
  // Calculate overall score using data-driven approach
  if (typeof calculateDataDrivenScore === 'function' && Object.keys(categoryMetrics).length > 0) {
    results.score = calculateDataDrivenScore(categoryMetrics, categoryBenchmarks, {
      missingDataScore: 30,
      higherIsBetter: true,
      weights: categoryWeights,
      applyCurve: true,
      curveFactor: 1.2,
      minimumScore: 0,
      maximumScore: 100
    });
  } else {
    // Fallback to traditional calculation if the function doesn't exist or no metrics
    let weightedScoreSum = 0;
    let weightSum = 0;
    
    for (const criterion in results.criteria) {
      if (results.criteria[criterion] && results.criteria[criterion].score !== undefined) {
        const weight = categoryWeights[criterion] || 1.0;
        weightedScoreSum += results.criteria[criterion].score * weight;
        weightSum += weight;
      }
    }
    
    results.score = weightSum > 0 ? weightedScoreSum / weightSum : 0;
  }
    
    // Assign letter grade
    if (results.score >= CONFIG.gradeThresholds.A) {
      results.letter = 'A';
    } else if (results.score >= CONFIG.gradeThresholds.B) {
      results.letter = 'B';
    } else if (results.score >= CONFIG.gradeThresholds.C) {
      results.letter = 'C';
    } else if (results.score >= CONFIG.gradeThresholds.D) {
      results.letter = 'D';
    } else {
      results.letter = 'F';
    }
    
    return results;
  }
  
  // ===== NEW v2.2 EVALUATION FUNCTIONS =====
  
  /**
   * Evaluates budget efficiency (NEW 11th category)
   * @param {Object} accountData The collected account data
   * @return {Object} Evaluation results for budget efficiency
   */
  function evaluateBudgetEfficiency(accountData) {
    Logger.log("Evaluating budget efficiency...");
    
    // Initialize results object
    const results = {
      score: 0,
      letter: '',
      criteria: {},
      recommendations: [],
      data: {
        budgetEfficiency: accountData.budgetEfficiency || {},
        searchTerms: accountData.searchTerms || {}
      }
    };
    
    // 1. Evaluate wasted spend identification
    const wastedSpendResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    const totalCost = accountData.performance?.cost || 1;
    const wastedCost = accountData.budgetEfficiency?.totalWastedCost || 0;
    const wastedPercentage = (wastedCost / totalCost) * 100;
    const wastedKeywordCount = accountData.budgetEfficiency?.wastedSpendKeywords?.length || 0;
    
    wastedSpendResult.details.wastedCost = wastedCost;
    wastedSpendResult.details.wastedPercentage = wastedPercentage;
    wastedSpendResult.details.wastedKeywordCount = wastedKeywordCount;
    
    if (wastedPercentage <= 5) {
      wastedSpendResult.score = 90;
    } else if (wastedPercentage <= 10) {
      wastedSpendResult.score = 75;
      wastedSpendResult.recommendations.push({
        text: `You have ${wastedPercentage.toFixed(1)}% wasted spend ($${wastedCost.toFixed(2)}). Review and pause/optimize the ${wastedKeywordCount} low-performing keywords.`,
        impact: 8.5,
        timeToImplement: "2-4 hours",
        timeToSeeResults: "Immediate",
        pointsImprovement: "10-15 points",
        details: `Pausing these keywords could save $${wastedCost.toFixed(2)} per period.`
      });
    } else if (wastedPercentage <= 20) {
      wastedSpendResult.score = 50;
      wastedSpendResult.recommendations.push({
        text: `HIGH PRIORITY: ${wastedPercentage.toFixed(1)}% of budget ($${wastedCost.toFixed(2)}) is wasted on non-converting keywords. Immediate action required.`,
        impact: 9.5,
        timeToImplement: "1 day",
        timeToSeeResults: "Immediate",
        pointsImprovement: "20-30 points",
        details: `Top ${Math.min(10, wastedKeywordCount)} keywords account for most waste. Start there.`
      });
    } else {
      wastedSpendResult.score = 20;
      wastedSpendResult.recommendations.push({
        text: `CRITICAL: ${wastedPercentage.toFixed(1)}% of budget ($${wastedCost.toFixed(2)}) is completely wasted. This is a major issue requiring immediate attention.`,
        impact: 10.0,
        timeToImplement: "1-2 days",
        timeToSeeResults: "Immediate",
        pointsImprovement: "30-40 points",
        details: `Eliminating this waste could dramatically improve ROI. Consider campaign restructuring.`
      });
    }
    
    results.criteria.wastedSpendIdentification = wastedSpendResult;
    
    // 2. Evaluate budget allocation
    const allocationResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    const budgetConstrainedCount = accountData.budgetEfficiency?.budgetConstrainedCampaigns?.length || 0;
    const totalCampaigns = accountData.structure?.campaignCount || 1;
    const constrainedPercentage = (budgetConstrainedCount / totalCampaigns) * 100;
    
    // Get search term opportunities value
    const opportunitiesValue = accountData.searchTerms?.opportunitiesValue || 0;
    
    allocationResult.details.budgetConstrainedCount = budgetConstrainedCount;
    allocationResult.details.constrainedPercentage = constrainedPercentage;
    allocationResult.details.missedOpportunitiesValue = opportunitiesValue;
    
    if (constrainedPercentage <= 10 && wastedPercentage <= 5) {
      allocationResult.score = 90;
    } else if (constrainedPercentage <= 20) {
      allocationResult.score = 75;
      allocationResult.recommendations.push({
        text: `${budgetConstrainedCount} campaigns (${constrainedPercentage.toFixed(1)}%) are budget-constrained. Consider reallocating budget from low-performing campaigns.`,
        impact: 7.5,
        timeToImplement: "1-2 days",
        timeToSeeResults: "1 week",
        pointsImprovement: "10-15 points"
      });
    } else if (constrainedPercentage <= 40) {
      allocationResult.score = 50;
      allocationResult.recommendations.push({
        text: `${constrainedPercentage.toFixed(1)}% of campaigns are budget-constrained while you have $${wastedCost.toFixed(2)} in wasted spend. Reallocate budget immediately.`,
        impact: 9.0,
        timeToImplement: "1 day",
        timeToSeeResults: "1 week",
        pointsImprovement: "15-25 points"
      });
    } else {
      allocationResult.score = 30;
      allocationResult.recommendations.push({
        text: `CRITICAL: Most campaigns (${constrainedPercentage.toFixed(1)}%) are budget-constrained. Major budget reallocation needed.`,
        impact: 9.5,
        timeToImplement: "2-3 days",
        timeToSeeResults: "1-2 weeks",
        pointsImprovement: "25-35 points"
      });
    }
    
    results.criteria.budgetAllocationOptimization = allocationResult;
    
    // 3. Evaluate search term opportunities
    const opportunitiesResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    const convertingTermsCount = accountData.searchTerms?.convertingTermsNotInKeywords?.length || 0;
    const totalSearchTerms = accountData.searchTerms?.totalSearchTerms || 1;
    const opportunityPercentage = (convertingTermsCount / totalSearchTerms) * 100;
    
    opportunitiesResult.details.convertingTermsCount = convertingTermsCount;
    opportunitiesResult.details.opportunityPercentage = opportunityPercentage;
    opportunitiesResult.details.potentialValue = opportunitiesValue;
    
    if (convertingTermsCount === 0) {
      opportunitiesResult.score = 90;
    } else if (convertingTermsCount <= 10) {
      opportunitiesResult.score = 75;
      opportunitiesResult.recommendations.push({
        text: `Add ${convertingTermsCount} converting search terms as keywords (potential value: $${opportunitiesValue.toFixed(2)}).`,
        impact: 7.0,
        timeToImplement: "1-2 hours",
        timeToSeeResults: "1-2 weeks",
        pointsImprovement: "5-10 points"
      });
    } else if (convertingTermsCount <= 50) {
      opportunitiesResult.score = 60;
      opportunitiesResult.recommendations.push({
        text: `You're missing ${convertingTermsCount} keyword opportunities from converting search terms. Add top performers as keywords.`,
        impact: 8.0,
        timeToImplement: "4-6 hours",
        timeToSeeResults: "2-3 weeks",
        pointsImprovement: "10-15 points"
      });
    } else {
      opportunitiesResult.score = 40;
      opportunitiesResult.recommendations.push({
        text: `Major opportunity gap: ${convertingTermsCount} converting search terms not in your keyword list. Prioritize adding top 20.`,
        impact: 8.5,
        timeToImplement: "1 day",
        timeToSeeResults: "2-4 weeks",
        pointsImprovement: "15-20 points"
      });
    }
    
    results.criteria.searchTermOpportunities = opportunitiesResult;
    
    // 4. Evaluate overall budget efficiency
    const efficiencyResult = {
      score: 0,
      details: {},
      recommendations: []
    };
    
    // Calculate efficiency score based on waste and opportunities
    const efficiencyScore = 100 - wastedPercentage - (opportunityPercentage * 0.5);
    
    efficiencyResult.details.efficiencyScore = efficiencyScore;
    efficiencyResult.details.wasteImpact = wastedPercentage;
    efficiencyResult.details.opportunityImpact = opportunityPercentage;
    
    if (efficiencyScore >= 85) {
      efficiencyResult.score = 90;
    } else if (efficiencyScore >= 70) {
      efficiencyResult.score = 75;
    } else if (efficiencyScore >= 50) {
      efficiencyResult.score = 60;
    } else {
      efficiencyResult.score = 40;
    }
    
    results.criteria.overallBudgetEfficiency = efficiencyResult;
    
    // Calculate overall category score
    const categoryMetrics = {
      wastedSpend: wastedSpendResult.score,
      budgetAllocation: allocationResult.score,
      searchTermOpp: opportunitiesResult.score,
      efficiency: efficiencyResult.score
    };
    
    const categoryBenchmarks = {
      wastedSpend: 80,
      budgetAllocation: 80,
      searchTermOpp: 80,
      efficiency: 80
    };
    
    results.score = (wastedSpendResult.score + allocationResult.score + opportunitiesResult.score + efficiencyResult.score) / 4;
    
    // Compile all recommendations
    results.recommendations = [
      ...wastedSpendResult.recommendations,
      ...allocationResult.recommendations,
      ...opportunitiesResult.recommendations
    ];
    
    // Assign letter grade
    if (results.score >= CONFIG.gradeThresholds.A) {
      results.letter = 'A';
    } else if (results.score >= CONFIG.gradeThresholds.B) {
      results.letter = 'B';
    } else if (results.score >= CONFIG.gradeThresholds.C) {
      results.letter = 'C';
    } else if (results.score >= CONFIG.gradeThresholds.D) {
      results.letter = 'D';
    } else {
      results.letter = 'F';
    }
    
    Logger.log(`💰 Budget Efficiency Grade: ${results.letter} (${results.score.toFixed(1)})`);
    
    return results;
  }
  
  /**
   * Collects account structure data
   * @param {Object} accountData The account data object to populate
   */
  function collectAccountStructure(accountData) {
    Logger.log("Collecting account structure data...");
    
    // Initialize structure object if it doesn't exist
    accountData.structure = accountData.structure || {};
    
    // Get campaign count
    const campaignIterator = AdsApp.campaigns()
      .withCondition("Status IN ['ENABLED', 'PAUSED']")
      .get();
    
    let campaignCount = 0;
    let searchCampaignCount = 0;
    let displayCampaignCount = 0;
    let videoCampaignCount = 0;
    let shoppingCampaignCount = 0;
    let performanceMaxCampaignCount = 0;
    
    // Store campaign data for reporting
    const campaigns = [];
    
    while (campaignIterator.hasNext()) {
      const campaign = campaignIterator.next();
      campaignCount++;
      
      const campaignType = campaign.getAdvertisingChannelType();
      if (campaignType === 'SEARCH') {
        searchCampaignCount++;
      } else if (campaignType === 'DISPLAY') {
        displayCampaignCount++;
      } else if (campaignType === 'VIDEO') {
        videoCampaignCount++;
      } else if (campaignType === 'SHOPPING') {
        shoppingCampaignCount++;
      } else if (campaignType === 'PERFORMANCE_MAX') {
        performanceMaxCampaignCount++;
      }
      
      // Add campaign to the list
      campaigns.push({
        id: campaign.getId(),
        name: campaign.getName(),
        status: campaign.isEnabled() ? 'ENABLED' : 'PAUSED',
        type: campaignType,
        budget: campaign.getBudget().getAmount()
      });
    }
    
    // Get ad group count
    const adGroupIterator = AdsApp.adGroups()
      .withCondition("Status IN ['ENABLED', 'PAUSED']")
      .get();
    
    let adGroupCount = 0;
    while (adGroupIterator.hasNext()) {
      adGroupIterator.next();
      adGroupCount++;
    }
    
    // Get keyword count
    const keywordIterator = AdsApp.keywords()
      .withCondition("Status IN ['ENABLED', 'PAUSED']")
      .get();
    
    let keywordCount = 0;
    while (keywordIterator.hasNext()) {
      keywordIterator.next();
      keywordCount++;
    }
    
    // Calculate average ad groups per campaign
    const avgAdGroupsPerCampaign = campaignCount > 0 ? adGroupCount / campaignCount : 0;
    
    // Calculate average keywords per ad group
    const avgKeywordsPerAdGroup = adGroupCount > 0 ? keywordCount / adGroupCount : 0;
    
    // Store account structure data
    accountData.structure.campaignCount = campaignCount;
    accountData.structure.searchCampaignCount = searchCampaignCount;
    accountData.structure.displayCampaignCount = displayCampaignCount;
    accountData.structure.videoCampaignCount = videoCampaignCount;
    accountData.structure.shoppingCampaignCount = shoppingCampaignCount;
    accountData.structure.performanceMaxCampaignCount = performanceMaxCampaignCount;
    accountData.structure.adGroupCount = adGroupCount;
    accountData.structure.keywordCount = keywordCount;
    accountData.structure.avgAdGroupsPerCampaign = avgAdGroupsPerCampaign;
    accountData.structure.avgKeywordsPerAdGroup = avgKeywordsPerAdGroup;
    accountData.structure.campaigns = campaigns;
    
    // Also store at the top level for backward compatibility
    accountData.campaignCount = campaignCount;
    accountData.adGroupCount = adGroupCount;
    accountData.campaigns = campaigns;
    
    Logger.log(`Found ${campaignCount} campaigns, ${adGroupCount} ad groups, and ${keywordCount} keywords`);
    Logger.log(`Average ad groups per campaign: ${avgAdGroupsPerCampaign.toFixed(1)}`);
    Logger.log(`Average keywords per ad group: ${avgKeywordsPerAdGroup.toFixed(1)}`);
    
    return accountData.structure;
  }
  
  /**
   * Collects bidding data
   * @param {Object} accountData The account data object to populate
   * @param {Object} dateRange Optional date range for data collection
   */
  function collectBiddingData(accountData, dateRange = null) {
    Logger.log("Collecting bidding data...");
    
    // Use provided dateRange or get it from accountData
    const dateRangeToUse = dateRange || accountData.dateRange;
    
    // Initialize bidding object if it doesn't exist
    accountData.bidding = accountData.bidding || {};
    
    // Initialize counters
    const strategies = {};
    let smartBiddingCount = 0;
    let manualBiddingCount = 0;
    let enhancedCpcCount = 0;
    let targetCpaCount = 0;
    let targetRoasCount = 0;
    let maximizeConversionsCount = 0;
    let maximizeConversionValueCount = 0;
    let targetImpressionShareCount = 0;
    let totalCampaigns = 0;
    
    // Try direct campaign access first as it's more reliable
    try {
      Logger.log("Collecting bidding data directly from campaigns...");
      
      // Get campaigns directly
      const campaignIterator = AdsApp.campaigns()
        .withCondition("Status IN ['ENABLED', 'PAUSED']")
        .get();
      
      while (campaignIterator.hasNext()) {
        try {
          const campaign = campaignIterator.next();
          totalCampaigns++;
          
          // Get campaign name
          const campaignName = campaign.getName();
          
          // Check if enhanced CPC is enabled
          let enhancedCpc = false;
          try {
            enhancedCpc = campaign.isEnhancedCpcEnabled();
          } catch (e) {
            Logger.log(`Error checking enhanced CPC for campaign ${campaignName}: ${e.message}`);
          }
          
          // Get bidding strategy type
          let biddingStrategyType = 'UNKNOWN';
          try {
            biddingStrategyType = campaign.getBiddingStrategyType();
          } catch (e) {
            Logger.log(`Error getting bidding strategy type for campaign ${campaignName}: ${e.message}`);
          }
          
          // Format the bidding strategy for display
          let displayBiddingStrategy = biddingStrategyType;
          
          // Handle special cases based on the data shown in the user's account
          if (biddingStrategyType === 'MANUAL_CPC' && enhancedCpc) {
            displayBiddingStrategy = 'CPC (enhanced)';
          } else if (biddingStrategyType === 'MAXIMIZE_CONVERSIONS') {
            displayBiddingStrategy = 'Maximize Conversions';
          } else if (biddingStrategyType === 'MAXIMIZE_CONVERSION_VALUE') {
            displayBiddingStrategy = 'Maximize Conversion Value';
          } else if (biddingStrategyType === 'TARGET_CPA') {
            displayBiddingStrategy = 'Target CPA';
          } else if (biddingStrategyType === 'TARGET_ROAS') {
            displayBiddingStrategy = 'Target ROAS';
          }
          
          Logger.log(`Campaign: ${campaignName}, Raw bidding strategy: ${biddingStrategyType}, Enhanced CPC: ${enhancedCpc}`);
          
          // Count bidding strategies
          if (!strategies[displayBiddingStrategy]) {
            strategies[displayBiddingStrategy] = 0;
          }
          strategies[displayBiddingStrategy]++;
          
          // Count by type
          if (biddingStrategyType === 'MANUAL_CPC') {
            manualBiddingCount++;
            if (enhancedCpc) {
              enhancedCpcCount++;
            }
          } else if (biddingStrategyType === 'TARGET_CPA' || biddingStrategyType.includes('TARGET_CPA')) {
            targetCpaCount++;
            smartBiddingCount++;
          } else if (biddingStrategyType === 'TARGET_ROAS' || biddingStrategyType.includes('TARGET_ROAS')) {
            targetRoasCount++;
            smartBiddingCount++;
          } else if (biddingStrategyType === 'MAXIMIZE_CONVERSIONS' || biddingStrategyType.includes('MAXIMIZE_CONVERSIONS')) {
            maximizeConversionsCount++;
            smartBiddingCount++;
          } else if (biddingStrategyType === 'MAXIMIZE_CONVERSION_VALUE' || biddingStrategyType.includes('MAXIMIZE_CONVERSION_VALUE')) {
            maximizeConversionValueCount++;
            smartBiddingCount++;
          } else if (biddingStrategyType === 'TARGET_IMPRESSION_SHARE' || biddingStrategyType.includes('TARGET_IMPRESSION_SHARE')) {
            targetImpressionShareCount++;
          }
        } catch (campaignError) {
          Logger.log(`Error processing campaign: ${campaignError.message}`);
        }
      }
    } catch (e) {
      Logger.log(`Error getting campaigns directly: ${e.message}`);
      
      // Fallback to report method if direct access fails
      try {
        Logger.log("Falling back to report method for bidding data...");
        
        // Query for campaign bidding strategies
        const query = "SELECT CampaignName, BiddingStrategyType, EnhancedCpcEnabled " +
          "FROM CAMPAIGN_PERFORMANCE_REPORT" +
          (dateRangeToUse ? ` DURING ${dateRangeToUse.start},${dateRangeToUse.end}` : "");
    
    const report = AdsApp.report(query);
    const rows = report.rows();
    
        totalCampaigns = 0; // Reset counter
        
        // Process each row in the report
    while (rows.hasNext()) {
      const row = rows.next();
          const biddingStrategy = row['BiddingStrategyType'] || 'UNKNOWN';
          const enhancedCpc = row['EnhancedCpcEnabled'] === 'true';
          const campaignName = row['CampaignName'] || 'Unknown Campaign';
          
          totalCampaigns++;
          
          // Log the raw data for debugging
          Logger.log(`Campaign: ${campaignName}, Raw bidding strategy: ${biddingStrategy}, Enhanced CPC: ${enhancedCpc}`);
          
          // Format the bidding strategy for display
          let displayBiddingStrategy = biddingStrategy;
          
          // Handle special cases based on the data shown in the user's account
          if (biddingStrategy === 'MANUAL_CPC' && enhancedCpc) {
            displayBiddingStrategy = 'CPC (enhanced)';
          } else if (biddingStrategy === 'MAXIMIZE_CONVERSIONS') {
            displayBiddingStrategy = 'Maximize Conversions';
          } else if (biddingStrategy === 'MAXIMIZE_CONVERSION_VALUE') {
            displayBiddingStrategy = 'Maximize Conversion Value';
          } else if (biddingStrategy === 'TARGET_CPA') {
            displayBiddingStrategy = 'Target CPA';
          } else if (biddingStrategy === 'TARGET_ROAS') {
            displayBiddingStrategy = 'Target ROAS';
          }
          
          // Count bidding strategies
          if (!strategies[displayBiddingStrategy]) {
            strategies[displayBiddingStrategy] = 0;
          }
          strategies[displayBiddingStrategy]++;
          
          // Count by type
          if (biddingStrategy === 'MANUAL_CPC') {
            manualBiddingCount++;
            if (enhancedCpc) {
              enhancedCpcCount++;
            }
          } else if (biddingStrategy === 'TARGET_CPA' || biddingStrategy.includes('TARGET_CPA')) {
            targetCpaCount++;
            smartBiddingCount++;
          } else if (biddingStrategy === 'TARGET_ROAS' || biddingStrategy.includes('TARGET_ROAS')) {
            targetRoasCount++;
            smartBiddingCount++;
          } else if (biddingStrategy === 'MAXIMIZE_CONVERSIONS' || biddingStrategy.includes('MAXIMIZE_CONVERSIONS')) {
            maximizeConversionsCount++;
            smartBiddingCount++;
          } else if (biddingStrategy === 'MAXIMIZE_CONVERSION_VALUE' || biddingStrategy.includes('MAXIMIZE_CONVERSION_VALUE')) {
            maximizeConversionValueCount++;
            smartBiddingCount++;
          } else if (biddingStrategy === 'TARGET_IMPRESSION_SHARE' || biddingStrategy.includes('TARGET_IMPRESSION_SHARE')) {
            targetImpressionShareCount++;
          }
        }
      } catch (reportError) {
        Logger.log(`Error using report method for bidding data: ${reportError.message}`);
      }
    }
    
    // Portfolio bidding strategy collection with counts
    try {
      Logger.log("Collecting portfolio bidding strategy counts...");
      let portfolioBiddingStrategies = [];
      let portfolioCount = 0;
      
      // Track counts by type
      let portfolioCpaCount = 0;
      let portfolioRoasCount = 0;
      let portfolioMaxConvCount = 0;
      let portfolioMaxValueCount = 0;
      
      // Also track which campaigns use portfolio strategies
      let campaignsUsingPortfolio = new Set();
      
      // First get the strategies themselves
      try {
        const bidStrategyIterator = AdsApp.biddingStrategies().get();
        
        if (bidStrategyIterator && bidStrategyIterator.hasNext()) {
          Logger.log("Collecting portfolio bidding strategies using AdsApp.biddingStrategies()");
          
          while (bidStrategyIterator.hasNext()) {
            try {
              const bidStrategy = bidStrategyIterator.next();
              portfolioCount++;
              
              // Get strategy details with error handling
              let strategyName = "Unnamed Strategy";
              let strategyType = "UNKNOWN";
              let strategyStatus = "UNKNOWN";
              let strategyId = "";
              
              try { strategyName = bidStrategy.getName() || "Unnamed Strategy"; } 
              catch (e) { Logger.log(`Error getting strategy name: ${e.message}`); }
              
              try { strategyType = bidStrategy.getType() || "UNKNOWN"; } 
              catch (e) { Logger.log(`Error getting strategy type: ${e.message}`); }
              
              try { strategyStatus = bidStrategy.getEntityStatus() || "UNKNOWN"; } 
              catch (e) { Logger.log(`Error getting strategy status: ${e.message}`); }
              
              try { strategyId = bidStrategy.getId(); }
              catch (e) { Logger.log(`Error getting strategy ID: ${e.message}`); }
              
              // Count by strategy type
              if (strategyType.includes('TARGET_CPA')) {
                portfolioCpaCount++;
              } else if (strategyType.includes('TARGET_ROAS')) {
                portfolioRoasCount++;
              } else if (strategyType.includes('MAXIMIZE_CONVERSIONS')) {
                portfolioMaxConvCount++;
              } else if (strategyType.includes('MAXIMIZE_CONVERSION_VALUE')) {
                portfolioMaxValueCount++;
              }
              
              // Add to portfolio bidding strategies array
              portfolioBiddingStrategies.push({
                id: strategyId,
                name: strategyName,
                type: strategyType,
                status: strategyStatus,
                campaignCount: 0 // Will be populated later
              });
              
              Logger.log(`Portfolio strategy: ${strategyName}, Type: ${strategyType}, Status: ${strategyStatus}`);
            } catch (e) {
              Logger.log(`Error processing individual bidding strategy: ${e.message}`);
            }
          }
        }
      } catch (e) {
        Logger.log(`Error using AdsApp.biddingStrategies(): ${e.message}`);
      }
      
      // Now get campaigns using portfolio strategies
      try {
        // Query for campaigns using portfolio bidding strategies
        const query = "SELECT CampaignId, CampaignName, BiddingStrategyId, BiddingStrategyName, BiddingStrategyType " +
                     "FROM CAMPAIGN_PERFORMANCE_REPORT " +
                     "WHERE BiddingStrategyId != NULL";
    
    const report = AdsApp.report(query);
    const rows = report.rows();
    
        // Map to track count of campaigns per strategy
        const campaignsPerStrategy = {};
        
    while (rows.hasNext()) {
          try {
      const row = rows.next();
            const strategyId = row['BiddingStrategyId'];
            const strategyName = row['BiddingStrategyName'] || 'Unknown Strategy';
            const campaignId = row['CampaignId'];
            const campaignName = row['CampaignName'] || 'Unknown Campaign';
            
            // Count unique campaigns using portfolio strategies
            if (strategyId && campaignId) {
              campaignsUsingPortfolio.add(campaignId);
              
              // Track count per strategy
              if (!campaignsPerStrategy[strategyId]) {
                campaignsPerStrategy[strategyId] = new Set();
              }
              campaignsPerStrategy[strategyId].add(campaignId);
              
              Logger.log(`Campaign "${campaignName}" uses portfolio strategy "${strategyName}" (ID: ${strategyId})`);
            }
          } catch (rowError) {
            Logger.log(`Error processing campaign row: ${rowError.message}`);
          }
        }
        
        // Update campaign counts for each strategy
        portfolioBiddingStrategies.forEach(strategy => {
          if (strategy.id && campaignsPerStrategy[strategy.id]) {
            strategy.campaignCount = campaignsPerStrategy[strategy.id].size;
          }
        });
        
        Logger.log(`Found ${campaignsUsingPortfolio.size} campaigns using portfolio bidding strategies`);
      } catch (e) {
        Logger.log(`Error getting campaigns using portfolio strategies: ${e.message}`);
      }
      
      // Store all collected data
      accountData.bidding.portfolioBiddingStrategies = portfolioBiddingStrategies;
      accountData.bidding.portfolioBiddingStrategyCount = portfolioCount;
      accountData.bidding.portfolioCpaCount = portfolioCpaCount;
      accountData.bidding.portfolioRoasCount = portfolioRoasCount;
      accountData.bidding.portfolioMaxConvCount = portfolioMaxConvCount;
      accountData.bidding.portfolioMaxValueCount = portfolioMaxValueCount;
      accountData.bidding.campaignsUsingPortfolioCount = campaignsUsingPortfolio.size;
      
      // Add these counts to the strategies object for reporting
      strategies['TARGET_CPA (Portfolio)'] = portfolioCpaCount;
      strategies['TARGET_ROAS (Portfolio)'] = portfolioRoasCount;
      strategies['MAXIMIZE_CONVERSIONS (Portfolio)'] = portfolioMaxConvCount;
      strategies['MAXIMIZE_CONVERSION_VALUE (Portfolio)'] = portfolioMaxValueCount;
      
      Logger.log(`Portfolio bidding strategy counts - Total: ${portfolioCount}, CPA: ${portfolioCpaCount}, ROAS: ${portfolioRoasCount}, MaxConv: ${portfolioMaxConvCount}, MaxValue: ${portfolioMaxValueCount}`);
    } catch (e) {
      Logger.log(`Error in portfolio bidding strategy collection: ${e.message}`);
      // Initialize with empty arrays and zero counts if we couldn't get data
      accountData.bidding.portfolioBiddingStrategies = [];
      accountData.bidding.portfolioBiddingStrategyCount = 0;
      accountData.bidding.portfolioCpaCount = 0;
      accountData.bidding.portfolioRoasCount = 0;
      accountData.bidding.portfolioMaxConvCount = 0;
      accountData.bidding.portfolioMaxValueCount = 0;
      accountData.bidding.campaignsUsingPortfolioCount = 0;
    }
    
    // If we still don't have any strategies but have campaigns, create a default entry
    if (Object.keys(strategies).length === 0 && totalCampaigns > 0) {
      strategies['UNKNOWN'] = totalCampaigns;
      Logger.log(`No specific bidding strategies found, setting ${totalCampaigns} campaigns to UNKNOWN`);
    }
    
    // Calculate percentages (handle division by zero)
    const totalCampaignsForPercentage = totalCampaigns || 1; // Avoid division by zero
    const smartBiddingPercentage = (smartBiddingCount / totalCampaignsForPercentage) * 100;
    const manualBiddingPercentage = (manualBiddingCount / totalCampaignsForPercentage) * 100;
    const enhancedCpcPercentage = (enhancedCpcCount / totalCampaignsForPercentage) * 100;
    
    // Check for bid adjustments
    let hasDeviceBidAdjustments = false;
    let hasLocationBidAdjustments = false;
    let hasScheduleBidAdjustments = false;
    
    try {
      // Check a sample of campaigns for bid adjustments
      const campaignIterator = AdsApp.campaigns()
        .withCondition("Status = ENABLED")
        .withLimit(50)
        .get();
      
      while (campaignIterator.hasNext()) {
        const campaign = campaignIterator.next();
        
        // Check device bid adjustments
        if (!hasDeviceBidAdjustments) {
          try {
            const deviceIterator = campaign.targeting().platforms().get();
            while (deviceIterator.hasNext()) {
              const device = deviceIterator.next();
              if (device.getBidModifier() !== 1.0) {
                hasDeviceBidAdjustments = true;
                break;
              }
            }
          } catch (e) {
            // Ignore errors, just continue
          }
        }
    
    // Check location bid adjustments
        if (!hasLocationBidAdjustments) {
          try {
            const locationIterator = campaign.targeting().targetedLocations().get();
            while (locationIterator.hasNext()) {
              const location = locationIterator.next();
              if (location.getBidModifier() !== 1.0) {
                hasLocationBidAdjustments = true;
                break;
              }
            }
          } catch (e) {
            // Ignore errors, just continue
          }
        }
    
    // Check ad schedule bid adjustments
        if (!hasScheduleBidAdjustments) {
          try {
            const scheduleIterator = campaign.targeting().adSchedules().get();
            while (scheduleIterator.hasNext()) {
              const schedule = scheduleIterator.next();
              if (schedule.getBidModifier() !== 1.0) {
                hasScheduleBidAdjustments = true;
                break;
              }
            }
          } catch (e) {
            // Ignore errors, just continue
          }
        }
        
        // If all adjustments found, no need to check more campaigns
        if (hasDeviceBidAdjustments && hasLocationBidAdjustments && hasScheduleBidAdjustments) {
          break;
        }
      }
    } catch (e) {
      Logger.log("Error checking bid adjustments: " + e.message);
    }
    
    // Get impression share data
    try {
      const impressionShareQuery = "SELECT SearchImpressionShare, SearchBudgetLostImpressionShare, SearchRankLostImpressionShare " +
        "FROM CAMPAIGN_PERFORMANCE_REPORT " +
        "WHERE CampaignStatus = 'ENABLED'" +
        (dateRangeToUse ? ` DURING ${dateRangeToUse.start},${dateRangeToUse.end}` : "");
      
      const impressionShareReport = AdsApp.report(impressionShareQuery);
      const impressionShareRows = impressionShareReport.rows();
      
      let totalImpressionShare = 0;
      let totalBudgetLost = 0;
      let totalRankLost = 0;
      let campaignsWithImpressionShareData = 0;
      
      while (impressionShareRows.hasNext()) {
        const row = impressionShareRows.next();
        const impressionShare = parseFloat(row['SearchImpressionShare']) || 0;
        const budgetLost = parseFloat(row['SearchBudgetLostImpressionShare']) || 0;
        const rankLost = parseFloat(row['SearchRankLostImpressionShare']) || 0;
        
        if (!isNaN(impressionShare)) {
          totalImpressionShare += impressionShare;
          totalBudgetLost += budgetLost;
          totalRankLost += rankLost;
          campaignsWithImpressionShareData++;
        }
      }
      
      // Calculate averages
      const avgImpressionShare = campaignsWithImpressionShareData > 0 ? 
        totalImpressionShare / campaignsWithImpressionShareData : 0;
      const avgBudgetLost = campaignsWithImpressionShareData > 0 ? 
        totalBudgetLost / campaignsWithImpressionShareData : 0;
      const avgRankLost = campaignsWithImpressionShareData > 0 ? 
        totalRankLost / campaignsWithImpressionShareData : 0;
      
      // Store impression share data
      accountData.bidding.impressionShare = avgImpressionShare;
      accountData.bidding.budgetLost = avgBudgetLost;
      accountData.bidding.rankLost = avgRankLost;
    } catch (e) {
      Logger.log("Error collecting impression share data: " + e.message);
      // Initialize with zeros if we couldn't get data
      accountData.bidding.impressionShare = 0;
      accountData.bidding.budgetLost = 0;
      accountData.bidding.rankLost = 0;
    }
    
    // Store bidding data
    accountData.bidding.strategies = strategies;
    accountData.bidding.smartBiddingCount = smartBiddingCount;
    accountData.bidding.manualBiddingCount = manualBiddingCount;
    accountData.bidding.enhancedCpcCount = enhancedCpcCount;
    accountData.bidding.targetCpaCount = targetCpaCount;
    accountData.bidding.targetRoasCount = targetRoasCount;
    accountData.bidding.maximizeConversionsCount = maximizeConversionsCount;
    accountData.bidding.maximizeConversionValueCount = maximizeConversionValueCount;
    accountData.bidding.targetImpressionShareCount = targetImpressionShareCount;
    accountData.bidding.smartBiddingPercentage = smartBiddingPercentage;
    accountData.bidding.manualBiddingPercentage = manualBiddingPercentage;
    accountData.bidding.enhancedCpcPercentage = enhancedCpcPercentage;
    accountData.bidding.hasDeviceBidAdjustments = hasDeviceBidAdjustments;
    accountData.bidding.hasLocationBidAdjustments = hasLocationBidAdjustments;
    accountData.bidding.hasScheduleBidAdjustments = hasScheduleBidAdjustments;
    accountData.bidding.totalCampaigns = totalCampaigns;
    
    Logger.log(`Found ${totalCampaigns} campaigns with bidding strategies`);
    Logger.log(`Smart bidding: ${smartBiddingCount} campaigns (${smartBiddingPercentage.toFixed(2)}%)`);
    Logger.log(`Manual bidding: ${manualBiddingCount} campaigns (${manualBiddingPercentage.toFixed(2)}%)`);
    Logger.log(`Enhanced CPC: ${enhancedCpcCount} campaigns (${enhancedCpcPercentage.toFixed(2)}%)`);
    Logger.log(`Bidding strategies: ${JSON.stringify(strategies)}`);
    
    return accountData.bidding;
  }
  
  /**
   * Collects quality score data - SIMPLIFIED VERSION
   * @param {Object} accountData The account data object to populate
   */
  function collectQualityScoreData(accountData) {
    Logger.log("Collecting quality score data...");
    
    // Initialize quality score data with default values (all zeros)
    let qualityScoreData = {
      totalKeywords: 0,
      averageQualityScore: 0,
      historicalQualityScore: 0,
      averageClickShare: 0,
      distribution: {
        1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0
      },
      historicalDistribution: {
        1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0
      },
      expectedCtr: {
        below_average: 0,
        average: 0,
        above_average: 0
      },
      historicalExpectedCtr: {
        below_average: 0,
        average: 0,
        above_average: 0
      },
      adRelevance: {
        below_average: 0,
        average: 0,
        above_average: 0
      },
      historicalAdRelevance: {
        below_average: 0,
        average: 0,
        above_average: 0
      },
      landingPage: {
        below_average: 0,
        average: 0,
        above_average: 0
      },
      historicalLandingPage: {
        below_average: 0,
        average: 0,
        above_average: 0
      }
    };
    
    try {
      // First, make sure we have the correct keyword count
      if (accountData.keywordCount) {
        qualityScoreData.totalKeywords = accountData.keywordCount;
        Logger.log(`Using keyword count from accountData: ${accountData.keywordCount}`);
      } else if (accountData.structure && accountData.structure.keywordCount) {
        qualityScoreData.totalKeywords = accountData.structure.keywordCount;
        Logger.log(`Using keyword count from structure: ${accountData.structure.keywordCount}`);
      } else {
        // If keywordCount is not available, try to get it from keywords iterator
        try {
          const keywordIterator = AdsApp.keywords()
            .withCondition("Status IN ['ENABLED', 'PAUSED']")
            .get();
      
          let count = 0;
          while (keywordIterator.hasNext()) {
            keywordIterator.next();
            count++;
          }
      
          if (count > 0) {
            qualityScoreData.totalKeywords = count;
            Logger.log(`Counted ${count} keywords directly`);
          }
        } catch (e) {
          Logger.log(`Error counting keywords: ${e.message}`);
        }
      }
      
      // If we still don't have a keyword count, try one more approach
      if (qualityScoreData.totalKeywords === 0) {
        try {
          const query = "SELECT Count FROM KEYWORDS_PERFORMANCE_REPORT";
          const report = AdsApp.report(query);
          const rows = report.rows();
          
          let count = 0;
          while (rows.hasNext()) {
            count++;
            rows.next();
          }
          
          if (count > 0) {
            qualityScoreData.totalKeywords = count;
            Logger.log(`Counted ${count} keywords from report`);
          }
        } catch (e) {
          Logger.log(`Error counting keywords from report: ${e.message}`);
        }
      }
      
      // Try to get quality score data from KEYWORDS_PERFORMANCE_REPORT
      try {
        Logger.log("Using KEYWORDS_PERFORMANCE_REPORT for quality score data...");
        
        // Get the date range
        const dateRange = getDateRange();
        
        // Create a query for quality score data
        const query = "SELECT QualityScore, SearchPredictedCtr, CreativeQualityScore, PostClickQualityScore " +
                     "FROM KEYWORDS_PERFORMANCE_REPORT " +
                     "WHERE Status IN ['ENABLED', 'PAUSED'] " +
                     `DURING ${dateRange.start},${dateRange.end}`;
        
        const report = AdsApp.report(query);
        const rows = report.rows();
        
        let totalQualityScore = 0;
        let validQualityScoreCount = 0;
        
        // Process each row to extract quality score and component data
        while (rows.hasNext()) {
          const row = rows.next();
          
          // Process quality score
          try {
            const qualityScore = parseInt(row['QualityScore'], 10);
            if (!isNaN(qualityScore) && qualityScore > 0 && qualityScore <= 10) {
              totalQualityScore += qualityScore;
              qualityScoreData.distribution[qualityScore]++;
              validQualityScoreCount++;
            }
          } catch (e) {
            // Skip invalid quality scores
          }
          
          // Process expected CTR
          try {
            const expectedCtr = row['SearchPredictedCtr'] || '';
            if (expectedCtr === "ABOVE_AVERAGE") {
              qualityScoreData.expectedCtr.above_average++;
            } else if (expectedCtr === "AVERAGE") {
              qualityScoreData.expectedCtr.average++;
            } else if (expectedCtr === "BELOW_AVERAGE") {
              qualityScoreData.expectedCtr.below_average++;
            }
          } catch (e) {
            // Skip if field not available
          }
          
          // Process ad relevance
          try {
            const adRelevance = row['CreativeQualityScore'] || '';
            if (adRelevance === "ABOVE_AVERAGE") {
              qualityScoreData.adRelevance.above_average++;
            } else if (adRelevance === "AVERAGE") {
              qualityScoreData.adRelevance.average++;
            } else if (adRelevance === "BELOW_AVERAGE") {
              qualityScoreData.adRelevance.below_average++;
            }
          } catch (e) {
            // Skip if field not available
          }
          
          // Process landing page experience
          try {
            const landingPage = row['PostClickQualityScore'] || '';
            if (landingPage === "ABOVE_AVERAGE") {
              qualityScoreData.landingPage.above_average++;
            } else if (landingPage === "AVERAGE") {
              qualityScoreData.landingPage.average++;
            } else if (landingPage === "BELOW_AVERAGE") {
              qualityScoreData.landingPage.below_average++;
            }
          } catch (e) {
            // Skip if field not available
          }
        }
        
        // Calculate average quality score
        if (validQualityScoreCount > 0) {
          qualityScoreData.averageQualityScore = totalQualityScore / validQualityScoreCount;
          Logger.log(`Found ${validQualityScoreCount} keywords with quality scores, average: ${qualityScoreData.averageQualityScore.toFixed(1)}`);
        } else {
          Logger.log("No valid quality scores found in report");
        }
        
        // Set historical data to current data (since we don't have historical data)
        qualityScoreData.historicalQualityScore = qualityScoreData.averageQualityScore;
        for (let i = 1; i <= 10; i++) {
          qualityScoreData.historicalDistribution[i] = qualityScoreData.distribution[i];
        }
        
        // Copy component data to historical
        qualityScoreData.historicalExpectedCtr = { ...qualityScoreData.expectedCtr };
        qualityScoreData.historicalAdRelevance = { ...qualityScoreData.adRelevance };
        qualityScoreData.historicalLandingPage = { ...qualityScoreData.landingPage };
        
      } catch (e) {
        Logger.log(`Error using report method for quality score data: ${e.message}`);
      }
      
      // Use the date range from the report instead of the current date
      if (accountData.dateRange) {
        // Format the date range for display
        try {
          const startDate = new Date(accountData.dateRange.start.substring(0, 4) + '-' + 
                                     accountData.dateRange.start.substring(4, 6) + '-' + 
                                     accountData.dateRange.start.substring(6, 8));
          
          const endDate = new Date(accountData.dateRange.end.substring(0, 4) + '-' + 
                                  accountData.dateRange.end.substring(4, 6) + '-' + 
                                  accountData.dateRange.end.substring(6, 8));
          
          // Format as YYYY-MM-DD
          const formattedStartDate = Utilities.formatDate(startDate, AdsApp.currentAccount().getTimeZone(), 'yyyy-MM-dd');
          const formattedEndDate = Utilities.formatDate(endDate, AdsApp.currentAccount().getTimeZone(), 'yyyy-MM-dd');
          
          // Use the date range in the format "YYYY-MM-DD to YYYY-MM-DD"
          qualityScoreData.date = formattedStartDate + ' to ' + formattedEndDate;
          Logger.log(`Using date range for quality score data: ${qualityScoreData.date}`);
        } catch (e) {
          Logger.log(`Error formatting date range: ${e.message}`);
          // Fallback to current date if there's an error
          const today = new Date();
          qualityScoreData.date = Utilities.formatDate(today, AdsApp.currentAccount().getTimeZone(), 'yyyy-MM-dd');
        }
      } else {
        // Fallback to current date if no date range is available
        const today = new Date();
        qualityScoreData.date = Utilities.formatDate(today, AdsApp.currentAccount().getTimeZone(), 'yyyy-MM-dd');
      }
      
      // Final log of quality score data results
      Logger.log(`Quality Score Data Summary: Average=${qualityScoreData.averageQualityScore.toFixed(1)}, Keywords=${qualityScoreData.totalKeywords}`);
      
    } catch (e) {
      Logger.log(`Error in quality score data collection: ${e.message}`);
    }
    
    // Store quality score data
    accountData.qualityScore = qualityScoreData;
    
    return accountData.qualityScore;
  }
  
  /**
   * Sends an error notification email
   * @param {Error} error The error that occurred
   */
  function sendErrorNotification(error) {
    Logger.log("Sending error notification...");
    
    const accountName = AdsApp.currentAccount().getName();
    const accountId = AdsApp.currentAccount().getCustomerId();
    
    // Create email subject
    const subject = "ERROR: Google Ads Account Grader - " + accountName + " (" + accountId + ")";
    
    // Create email body
    let body = "<h2>Error Running Google Ads Account Grader</h2>";
    body += "<p><strong>Account:</strong> " + accountName + " (" + accountId + ")</p>";
    body += "<p><strong>Date:</strong> " + Utilities.formatDate(new Date(), AdsApp.currentAccount().getTimeZone(), "yyyy-MM-dd") + "</p>";
    body += "<p><strong>Error Message:</strong> " + error.message + "</p>";
    
    if (error.stack) {
      body += "<p><strong>Stack Trace:</strong></p>";
      body += "<pre>" + error.stack + "</pre>";
    }
    
    // Send the email
    MailApp.sendEmail({
      to: CONFIG.email.errorRecipients ? CONFIG.email.errorRecipients.join(",") : CONFIG.email.emailAddress,
      subject: subject,
      htmlBody: body
    });
        }

/**
 * Calculates the overall grade based on individual category grades
 * @param {Object} evaluationResults The evaluation results for each category
 * @returns {Object} The overall grade with letter and score
 */
/**
 * Calculates a data-driven score based on metrics and benchmarks
 * @param {Object} metrics The metrics to evaluate
 * @param {Object} benchmarks The benchmarks to compare against
 * @param {Object} options Additional options for scoring
 * @return {number} The calculated score (0-100)
 */
function calculateDataDrivenScore(metrics, benchmarks, options = {}) {
  // Default options
  const defaults = {
    // How to handle missing data (0 = lowest score, 50 = average score)
    missingDataScore: 0,
    
    // Whether higher values are better for this metric
    higherIsBetter: true,
    
    // Minimum score to return even if metrics are very poor
    minimumScore: 0,
    
    // Maximum score to return even if metrics are excellent
    maximumScore: 100,
    
    // How much to weight each metric in the final score
    weights: {},
    
    // Whether to apply a curve to make perfect scores more challenging
    applyCurve: true,
    
    // Curve factor (higher = more challenging to get perfect score)
    curveFactor: 1.2
  };
  
  // Merge provided options with defaults
  const settings = { ...defaults, ...options };
  
  // If metrics is empty or undefined, return the missing data score
  if (!metrics || Object.keys(metrics).length === 0) {
    return settings.missingDataScore;
  }
  
  // Calculate individual metric scores
  const metricScores = {};
  let totalWeight = 0;
  let weightedScoreSum = 0;
  
  for (const metric in metrics) {
    // Skip if metric value is undefined or null
    if (metrics[metric] === undefined || metrics[metric] === null) {
      continue;
    }
    
    // Get benchmark for this metric
    const benchmark = benchmarks[metric] || 0;
    
    // Get weight for this metric
    const weight = settings.weights[metric] || 1;
    totalWeight += weight;
    
    // Calculate score for this metric
    let score;
    
    if (settings.higherIsBetter) {
      // For metrics where higher is better (CTR, conversion rate, etc.)
      if (benchmark === 0) {
        // If benchmark is 0, any positive value is good
        score = metrics[metric] > 0 ? 100 : 0;
      } else {
        // Calculate percentage of benchmark
        const percentOfBenchmark = (metrics[metric] / benchmark) * 100;
        
        // Score based on percentage of benchmark
        if (percentOfBenchmark >= 150) {
          score = 100; // Excellent: 50% or more above benchmark
        } else if (percentOfBenchmark >= 120) {
          score = 90; // Very good: 20-50% above benchmark
        } else if (percentOfBenchmark >= 100) {
          score = 80; // Good: At or above benchmark
        } else if (percentOfBenchmark >= 80) {
          score = 70; // Fair: 80-100% of benchmark
        } else if (percentOfBenchmark >= 60) {
          score = 60; // Poor: 60-80% of benchmark
        } else if (percentOfBenchmark >= 40) {
          score = 50; // Very poor: 40-60% of benchmark
        } else if (percentOfBenchmark >= 20) {
          score = 30; // Bad: 20-40% of benchmark
        } else {
          score = 10; // Very bad: Less than 20% of benchmark
        }
      }
    } else {
      // For metrics where lower is better (CPC, bounce rate, etc.)
      if (benchmark === 0) {
        // If benchmark is 0, lower is always better
        score = metrics[metric] === 0 ? 100 : (metrics[metric] < 1 ? 80 : 50);
      } else {
        // Calculate percentage of benchmark (inverted for lower is better)
        const percentOfBenchmark = (benchmark / Math.max(metrics[metric], 0.001)) * 100;
        
        // Score based on percentage of benchmark
        if (percentOfBenchmark >= 150) {
          score = 100; // Excellent: 50% or more below benchmark
        } else if (percentOfBenchmark >= 120) {
          score = 90; // Very good: 20-50% below benchmark
        } else if (percentOfBenchmark >= 100) {
          score = 80; // Good: At or below benchmark
        } else if (percentOfBenchmark >= 80) {
          score = 70; // Fair: 80-100% of benchmark
        } else if (percentOfBenchmark >= 60) {
          score = 60; // Poor: 60-80% of benchmark
        } else if (percentOfBenchmark >= 40) {
          score = 50; // Very poor: 40-60% of benchmark
        } else if (percentOfBenchmark >= 20) {
          score = 30; // Bad: 20-40% of benchmark
        } else {
          score = 10; // Very bad: More than 5x benchmark
        }
      }
    }
    
    // Store score for this metric
    metricScores[metric] = score;
    
    // Add to weighted sum
    weightedScoreSum += score * weight;
  }
  
  // Calculate final score
  let finalScore = totalWeight > 0 ? weightedScoreSum / totalWeight : settings.missingDataScore;
  
  // Apply curve if enabled
  if (settings.applyCurve && finalScore > 0) {
    // Apply a curve that makes it harder to get a perfect score
    // The curve is steeper at the high end
    const curvedScore = 100 * Math.pow(finalScore / 100, settings.curveFactor);
    finalScore = curvedScore;
  }
  
  // Ensure score is within bounds
  finalScore = Math.max(settings.minimumScore, Math.min(settings.maximumScore, finalScore));
  
  // Round to nearest integer
  return Math.round(finalScore);
}

function calculateOverallGrade(evaluationResults) {
  // Define weights for each category
  const weights = {
    'campaignorganization': 1.0,
    'conversiontracking': 1.5,
    'keywordstrategy': 1.2,
    'negativekeywords': 1.0,
    'biddingstrategy': 1.0,
    'adcreative&extensions': 1.2,  // This key doesn't match what's in evaluationResults
    'qualityscore': 0.8,
    'audiencestrategy': 0.8,
    'landingpageoptimization': 0.8,
    'competitiveanalysis': 0.7
  };
  
  // Fix the keys to match what's in evaluationResults
  const fixedWeights = {};
  for (const category in evaluationResults) {
    if (category === 'adcreativeextensions') {
      fixedWeights[category] = weights['adcreative&extensions'];
    } else if (weights[category]) {
      fixedWeights[category] = weights[category];
    } else {
      fixedWeights[category] = 1.0; // Default weight if not specified
    }
  }
  
  let totalScore = 0;
  let totalWeight = 0;
  
  for (const category in evaluationResults) {
    if (evaluationResults[category] && evaluationResults[category].score !== undefined) {
      totalScore += evaluationResults[category].score * fixedWeights[category];
      totalWeight += fixedWeights[category];
    }
  }
  
  // Normalize score if not all categories were evaluated
  let overallScore = totalWeight > 0 ? totalScore / totalWeight : 0;
  
  // Ensure minimum score if we have data
  if (overallScore === 0) {
    // Check if we have any data in accountData
    let hasData = false;
    for (const category in evaluationResults) {
      if (evaluationResults[category] && 
          evaluationResults[category].data && 
          Object.keys(evaluationResults[category].data).length > 0) {
        hasData = true;
        break;
      }
    }
    
    if (hasData) {
      overallScore = 30; // Minimum F grade
    }
  }
  
  // Determine letter grade
  let letterGrade;
  if (overallScore >= 90) {
    letterGrade = "A";
  } else if (overallScore >= 80) {
    letterGrade = "B";
  } else if (overallScore >= 70) {
    letterGrade = "C";
  } else if (overallScore >= 60) {
    letterGrade = "D";
  } else {
    letterGrade = "F";
  }
  
  return {
    score: overallScore,
    letter: letterGrade
  };
}

/**
 * Helper function to add a data section to a sheet
 * @param {Object} dataObj The data object to add
 * @param {Sheet} sheet The sheet to add the data to
 * @param {number} startRow The row to start adding data at
 * @param {number} startCol The column to start adding data at
 * @param {string} prefix Optional prefix for nested objects
 * @returns {number} The next row after adding the data
 */
function addDataSection(dataObj, sheet, startRow, startCol, prefix = '') {
  let row = startRow;
  const col = startCol;
  
  // Handle null or undefined
  if (dataObj === null || dataObj === undefined) {
    return row;
  }
  
  // Special handling for extensions object
  if (prefix === '  Extensions' && dataObj.campaignsWithExtensions && dataObj.campaignsWithExtensions instanceof Set) {
    sheet.getRange(row, startCol).setValue('Campaigns with Extensions');
    sheet.getRange(row, startCol + 1).setValue(dataObj.campaignsWithExtensions.size);
    row++;
    
    // Add extension type counts
    if (dataObj.extensionTypeCounts) {
      Object.keys(dataObj.extensionTypeCounts).forEach(type => {
        const formattedType = type
          .replace(/([A-Z])/g, ' $1')
          .replace(/^./, function(str) { return str.toUpperCase(); });
        
        sheet.getRange(row, startCol).setValue(prefix + '  ' + formattedType);
        sheet.getRange(row, startCol + 1).setValue(dataObj.extensionTypeCounts[type]);
        row++;
      });
    }
    
    // Add campaign extension details header
    if (dataObj.campaignExtensionDetails && dataObj.campaignExtensionDetails.length > 0) {
      row++;
      
      // Add header row
      sheet.getRange(row, startCol).setValue(prefix + '    Campaign');
      sheet.getRange(row, startCol + 1).setValue('Extension Count');
      sheet.getRange(row, startCol, 1, 2).setFontWeight("bold").setBackground("#efefef");
      row++;
      
      // Add each campaign's extension details
      dataObj.campaignExtensionDetails.forEach(detail => {
        sheet.getRange(row, startCol).setValue(prefix + '    ' + detail.campaignName);
        sheet.getRange(row, startCol + 1).setValue(detail.extensionCount);
        row++;
      });
    }
    
    return row;
  }
  
  // Special handling for quality score data
  if (prefix === '  Quality Score' && dataObj && typeof dataObj === 'object') {
    // Format the quality score data according to the example
    
    // Add date if available
    if (dataObj.date) {
      sheet.getRange(row, startCol).setValue('Date:');
      sheet.getRange(row, startCol + 1).setValue(dataObj.date);
      row++;
    }
    
    // Add total keywords
    sheet.getRange(row, startCol).setValue('Total Keywords');
    sheet.getRange(row, startCol + 1).setValue(dataObj.totalKeywords || 0);
    row++;
    
    // Add average quality score
    sheet.getRange(row, startCol).setValue('Average Quality Score');
    sheet.getRange(row, startCol + 1).setValue((dataObj.averageQualityScore || 0).toFixed(1));
    row++;
    
    // Remove historical quality score
    
    // Add average click share
    sheet.getRange(row, startCol).setValue('Average Click Share');
    sheet.getRange(row, startCol + 1).setValue((dataObj.averageClickShare || 0).toFixed(1) + '%');
    row += 2;
    
    // Add distribution header - remove "vs Historical"
    sheet.getRange(row, startCol).setValue('Distribution');
    sheet.getRange(row, startCol).setFontWeight("bold");
    row++;
    
    // Add distribution header row - remove Historical column
    sheet.getRange(row, startCol).setValue('');
    sheet.getRange(row, startCol + 1).setValue('Count');
    sheet.getRange(row, startCol, 1, 2).setFontWeight("bold").setBackground("#efefef");
    row++;
    
    // Add distribution data - remove Historical column
    for (let i = 10; i >= 1; i--) {
      sheet.getRange(row, startCol).setValue(i);
      sheet.getRange(row, startCol + 1).setValue(dataObj.distribution ? (dataObj.distribution[i] || 0) : 0);
      row++;
    }
    
    // Add component data header
    row += 1;
    sheet.getRange(row, startCol).setValue('Components');
    sheet.getRange(row, startCol).setFontWeight("bold");
    row++;
    
    // Add component header row
    sheet.getRange(row, startCol).setValue('');
    sheet.getRange(row, startCol + 1).setValue('Above Average');
    sheet.getRange(row, startCol + 2).setValue('Average');
    sheet.getRange(row, startCol + 3).setValue('Below Average');
    sheet.getRange(row, startCol, 1, 4).setFontWeight("bold").setBackground("#efefef");
    row++;
    
    // Add component data
    if (dataObj.components) {
      const components = ['Expected CTR', 'Ad Relevance', 'Landing Page Experience'];
      components.forEach(component => {
        sheet.getRange(row, startCol).setValue(component);
        sheet.getRange(row, startCol + 1).setValue(dataObj.components[component] ? (dataObj.components[component].aboveAverage || 0) : 0);
        sheet.getRange(row, startCol + 2).setValue(dataObj.components[component] ? (dataObj.components[component].average || 0) : 0);
        sheet.getRange(row, startCol + 3).setValue(dataObj.components[component] ? (dataObj.components[component].belowAverage || 0) : 0);
        row++;
      });
    }
    
    return row;
  }
  
  // Special handling for landing page data when prefix is '  Landing Page'
  if (prefix === '  Landing Page' && dataObj) {
    // Add summary data
    sheet.getRange(row, startCol, 1, 2).setValues([['Landing Page Summary', '']]);
    sheet.getRange(row, startCol).setFontWeight("bold");
    row++;
    
    sheet.getRange(row, startCol, 5, 2).setValues([
      ['Unique URLs', dataObj.uniqueUrlCount || 0],
      ['Total Clicks', dataObj.totalClicks || 0],
      ['Total Impressions', dataObj.totalImpressions || 0],
      ['Total Conversions', dataObj.totalConversions || 0],
      ['Overall Conversion Rate', formatPercent(dataObj.conversionRate || 0)]
    ]);
    row += 6; // Add extra space after summary
    
    // Add top performers table if available
    if (dataObj.topPerformers && dataObj.topPerformers.length > 0) {
      sheet.getRange(row, startCol, 1, 2).setValues([['Top Performing Landing Pages', '']]);
      sheet.getRange(row, startCol).setFontWeight("bold");
      row++;
      
      // Create headers for the detailed table
      const headers = [
        'Landing Page URL', 
        'Clicks', 
        'Impressions', 
        'CTR', 
        'Cost', 
        'Conversions', 
        'Conv. Rate', 
        'Mobile Friendly',
        'Mobile Speed'
      ];
      
      sheet.getRange(row, startCol, 1, headers.length).setValues([headers]);
      sheet.getRange(row, startCol, 1, headers.length).setFontWeight("bold").setBackground("#efefef");
      row++;
      
      // Add data for each top performer
      dataObj.topPerformers.forEach(performer => {
        const ctr = performer.impressions > 0 ? performer.clicks / performer.impressions : 0;
        const convRate = performer.clicks > 0 ? performer.conversions / performer.clicks : 0;
        
        sheet.getRange(row, startCol, 1, headers.length).setValues([[
          performer.url,
          performer.clicks,
          performer.impressions,
          formatPercent(ctr),
          formatCurrency(performer.cost),
          performer.conversions,
          formatPercent(convRate),
          formatPercent(performer.mobileFriendlyClickRate),
          performer.mobileSpeedScore
        ]]);
        row++;
      });
      
      // Add device breakdown for the top performer
      if (dataObj.topPerformers.length > 0) {
        row += 1; // Add space
        const topPerformer = dataObj.topPerformers[0];
        
        sheet.getRange(row, startCol, 1, 2).setValues([['Device Breakdown for Top Landing Page', '']]);
        sheet.getRange(row, startCol).setFontWeight("bold");
        row++;
        
        // Headers for device breakdown
        const deviceHeaders = ['Device', 'Clicks', 'Impressions', 'Cost', 'Conversions', 'Conv. Rate'];
        sheet.getRange(row, startCol, 1, deviceHeaders.length).setValues([deviceHeaders]);
        sheet.getRange(row, startCol, 1, deviceHeaders.length).setFontWeight("bold").setBackground("#efefef");
        row++;
        
        // Add data for each device type
        const deviceTypes = ['mobile', 'desktop', 'tablet', 'other'];
        deviceTypes.forEach(deviceType => {
          if (topPerformer.deviceData && topPerformer.deviceData[deviceType]) {
            const deviceData = topPerformer.deviceData[deviceType];
            const deviceConvRate = deviceData.clicks > 0 ? deviceData.conversions / deviceData.clicks : 0;
            
            sheet.getRange(row, startCol, 1, deviceHeaders.length).setValues([[
              deviceType.charAt(0).toUpperCase() + deviceType.slice(1),
              deviceData.clicks,
              deviceData.impressions,
              formatCurrency(deviceData.cost),
              deviceData.conversions,
              formatPercent(deviceConvRate)
            ]]);
            row++;
          }
        });
      }
    }
    
    return row;
  }
  
  // Iterate through each key in the object
  for (const key in dataObj) {
    if (!dataObj.hasOwnProperty(key)) continue;
    
    // Special handling for landing page data
    if (key === 'landingPage') {
      sheet.getRange(row, startCol).setValue(prefix + 'Landing Page');
      sheet.getRange(row, startCol).setFontWeight("bold");
      row++;
      
      // Use the special landing page formatter
      row = addDataSection(dataObj[key], sheet, row, startCol, prefix + '  Landing Page');
      continue;
    }
    
    // Handle objects (but not arrays)
    if (typeof dataObj[key] === 'object' && !Array.isArray(dataObj[key]) && !(dataObj[key] instanceof Set)) {
      // This is a nested object, add a header for it
      const sectionName = key
        .replace(/([A-Z])/g, ' $1')
        .replace(/^./, function(str) { return str.toUpperCase(); });
      
      sheet.getRange(row, startCol).setValue(prefix + sectionName);
      sheet.getRange(row, startCol).setFontWeight("bold");
      row++;
      
      // Special handling for extensions object
      if (key === 'extensions') {
        row = addDataSection(dataObj[key], sheet, row, startCol, prefix + '  Extensions');
      } else {
        // Recursively add its contents
        row = addDataSection(dataObj[key], sheet, row, startCol, prefix + '  '); // Add indentation for nested items
      }
    } 
    // Handle arrays
    else if (Array.isArray(dataObj[key])) {
      const sectionName = key
        .replace(/([A-Z])/g, ' $1')
        .replace(/^./, function(str) { return str.toUpperCase(); });
      
      // Special handling for ad arrays - just show the count
      if (key === 'ads') {
        sheet.getRange(row, startCol).setValue(prefix + sectionName);
        sheet.getRange(row, startCol + 1).setValue(dataObj[key].length);
        row++;
      }
      // Skip large arrays
      else if (dataObj[key].length > 20) {
        sheet.getRange(row, startCol).setValue(prefix + sectionName);
        sheet.getRange(row, startCol + 1).setValue(dataObj[key].length);
        row++;
      } 
      // Show small arrays
      else if (dataObj[key].length > 0) {
        sheet.getRange(row, startCol).setValue(prefix + sectionName);
        sheet.getRange(row, startCol).setFontWeight("bold");
        row++;
        
        // Add each array item
        dataObj[key].forEach((item, index) => {
          if (typeof item === 'object') {
            sheet.getRange(row, startCol).setValue(prefix + `  Item ${index + 1}`);
            row++;
            
            row = addDataSection(item, sheet, row, startCol, prefix + '    ');
          } else {
            sheet.getRange(row, startCol).setValue(prefix + `  Item ${index + 1}`);
            sheet.getRange(row, startCol + 1).setValue(item);
            row++;
          }
        });
      } else {
        // Empty array
        sheet.getRange(row, startCol).setValue(prefix + sectionName);
        sheet.getRange(row, startCol + 1).setValue("0");
        row++;
      }
    } 
    // Handle Sets
    else if (dataObj[key] instanceof Set) {
      const sectionName = key
        .replace(/([A-Z])/g, ' $1')
        .replace(/^./, function(str) { return str.toUpperCase(); });
      
      sheet.getRange(row, startCol).setValue(prefix + sectionName);
      sheet.getRange(row, startCol + 1).setValue(dataObj[key].size);
      row++;
    }
    // Handle all other types
    else {
      const sectionName = key
        .replace(/([A-Z])/g, ' $1')
        .replace(/^./, function(str) { return str.toUpperCase(); });
      
      // Format the value
      let value = dataObj[key];
      if (typeof value === 'number') {
        if (key.toLowerCase().includes('percentage') || 
            key.toLowerCase().includes('share') || 
            key.toLowerCase().includes('rate')) {
          value = value.toFixed(2) + '%';
        } else if (Number.isInteger(value)) {
          value = value.toString();
        } else {
          value = value.toFixed(2);
        }
      } else if (typeof value === 'boolean') {
        value = value ? 'TRUE' : 'FALSE';
      }
      
      sheet.getRange(row, startCol).setValue(prefix + sectionName);
      sheet.getRange(row, startCol + 1).setValue(value);
      row++;
    }
  }
  
  return row;
}

// Helper function to format percentages
function formatPercent(value) {
  return (value * 100).toFixed(2) + '%';
}

// Helper function to format currency
function formatCurrency(value) {
  return '$' + value.toFixed(2);
}

// Helper function to format period-over-period change
function formatChangePercent(current, previous, isLowerBetter = false) {
  // Log the values for debugging
  Logger.log("formatChangePercent - current: " + current + ", previous: " + previous + ", isLowerBetter: " + isLowerBetter);
  
  // Handle undefined, null, or zero values
  if (current === undefined || current === null || previous === undefined || previous === null) {
    Logger.log("formatChangePercent - returning N/A due to undefined or null values");
    return 'N/A';
  }
  
  // Convert to numbers to ensure proper comparison
  const currentNum = parseFloat(current);
  const previousNum = parseFloat(previous);
  
  // Check for invalid numbers
  if (isNaN(currentNum) || isNaN(previousNum) || previousNum === 0) {
    Logger.log("formatChangePercent - returning N/A due to NaN or zero previous value");
    return 'N/A';
  }
  
  const change = (currentNum - previousNum) / previousNum;
  Logger.log("formatChangePercent - calculated change: " + change);
  
  const changePercent = Math.abs(change * 100).toFixed(1) + '%';
  
  // Determine if the change is positive or negative for the business
  // For metrics like CPC and Cost, lower is better
  const isPositive = isLowerBetter ? change < 0 : change > 0;
  
  // Format with color and arrow
  if (Math.abs(change) < 0.001) { // Consider very small changes as "no change"
    return '<span style="color: #5f6368;">No change</span>';
  } else if (isPositive) {
    return '<span style="color: #34a853;">▲ ' + changePercent + '</span>';
  } else {
    return '<span style="color: #ea4335;">▼ ' + changePercent + '</span>';
  }
}

/**
 * Helper function to run the account grader for a specific date range
 * @param {string} startDate Start date in YYYY-MM-DD format
 * @param {string} endDate End date in YYYY-MM-DD format
 * @return {string} URL of the generated report spreadsheet
 */
function runForDateRange(startDate, endDate) {
  // Convert dates from YYYY-MM-DD to YYYYMMDD format
  const formattedStartDate = startDate.replace(/-/g, '');
  const formattedEndDate = endDate.replace(/-/g, '');
  
  return main({
    startDate: formattedStartDate,
    endDate: formattedEndDate
  });
}

/**
 * Helper function to run the account grader for a specific month
 * @param {number} year The year (e.g., 2022)
 * @param {number} month The month (1-12)
 * @return {string} URL of the generated report spreadsheet
 */
function runForMonth(year, month) {
  // Create date objects for the first and last day of the month
  const startDate = new Date(year, month - 1, 1);
  const endDate = new Date(year, month, 0); // Last day of the month
  
  // Format dates as YYYYMMDD
  const formattedStartDate = Utilities.formatDate(startDate, AdsApp.currentAccount().getTimeZone(), 'yyyyMMdd');
  const formattedEndDate = Utilities.formatDate(endDate, AdsApp.currentAccount().getTimeZone(), 'yyyyMMdd');
  
  return main({
    startDate: formattedStartDate,
    endDate: formattedEndDate
  });
}

/**
 * Helper function to run the account grader for a specific quarter
 * @param {number} year The year (e.g., 2022)
 * @param {number} quarter The quarter (1-4)
 * @return {string} URL of the generated report spreadsheet
 */
function runForQuarter(year, quarter) {
  if (quarter < 1 || quarter > 4) {
    throw new Error("Quarter must be between 1 and 4");
  }
  
  // Calculate the start and end months for the quarter
  const startMonth = (quarter - 1) * 3 + 1;
  const endMonth = quarter * 3;
  
  // Create date objects for the first day of the start month and last day of the end month
  const startDate = new Date(year, startMonth - 1, 1);
  const endDate = new Date(year, endMonth, 0); // Last day of the end month
  
  // Format dates as YYYYMMDD
  const formattedStartDate = Utilities.formatDate(startDate, AdsApp.currentAccount().getTimeZone(), 'yyyyMMdd');
  const formattedEndDate = Utilities.formatDate(endDate, AdsApp.currentAccount().getTimeZone(), 'yyyyMMdd');
  
  return main({
    startDate: formattedStartDate,
    endDate: formattedEndDate
  });
}

// Examples of how to use the helper functions:
// To run for July 1, 2022 through August 28, 2022:
// runForDateRange('2022-07-01', '2022-08-28');
//
// To run for the entire month of July 2022:
// runForMonth(2022, 7);
//
// To run for Q3 2022 (July-September):
// runForQuarter(2022, 3);

/**
 * Enhances evaluation results by adding raw data from accountData to ensure detailed reports
 * @param {Object} evaluationResults The evaluation results object
 * @param {Object} accountData The collected account data
 */
function enhanceEvaluationResults(evaluationResults, accountData) {
  // IMPORTANT: This function only enhances the display of real data that was collected.
  // It does NOT create fake or estimated data. All data comes from the actual Google Ads account.
  Logger.log("Enhancing evaluation results with real account data (no estimates)...");
  
  // Make sure each category has a data property with relevant information
  
  // Campaign Organization
  if (evaluationResults.campaignorganization) {
    // Ensure minimum score
    if (evaluationResults.campaignorganization.score === 0) {
      evaluationResults.campaignorganization.score = 30;
      evaluationResults.campaignorganization.letter = 'F';
    }
    
    // Add data
    if (!evaluationResults.campaignorganization.data) {
      evaluationResults.campaignorganization.data = {};
    }
    
    // Add campaign data
    evaluationResults.campaignorganization.data.structure = accountData.structure || {};
    evaluationResults.campaignorganization.data.campaigns = accountData.campaigns || {};
    
    // Add default recommendations if none exist
    if (!evaluationResults.campaignorganization.recommendations || 
        evaluationResults.campaignorganization.recommendations.length === 0) {
      evaluationResults.campaignorganization.recommendations = [{
        text: "Review your campaign structure to ensure campaigns are organized by theme or product line",
        impact: 0.8
      }];
    }
  }
  
  // Conversion Tracking
  if (evaluationResults.conversiontracking) {
    // Ensure minimum score
    if (evaluationResults.conversiontracking.score === 0) {
      evaluationResults.conversiontracking.score = 30;
      evaluationResults.conversiontracking.letter = 'F';
    }
    
    // Add data
    if (!evaluationResults.conversiontracking.data) {
      evaluationResults.conversiontracking.data = {};
    }
    
    // Create a more detailed conversion tracking data structure
    const conversionTrackingData = {
      conversionActions: [],
      summary: {
        totalConversions: accountData.performance?.conversions || 0,
        conversionValue: accountData.performance?.conversionValue || 0,
        conversionRate: accountData.performance?.conversionRate || 0,
        totalConversionActions: accountData.conversionActionCount || 0,
        primaryConversions: accountData.primaryConversionCount || 0,
        websiteConversions: accountData.websiteConversionCount || 0,
        appConversions: accountData.appConversionCount || 0,
        phoneCallConversions: accountData.phoneCallConversionCount || 0,
        importedConversions: accountData.importedConversionCount || 0,
        storeVisitConversions: accountData.storeVisitConversionCount || 0,
        onePerClickCount: accountData.onePerClickCount || 0,
        manyPerClickCount: accountData.manyPerClickCount || 0
      },
      attributionModels: accountData.attributionModels || {
        lastClick: 0,
        firstClick: 0,
        linear: 0,
        timeDecay: 0,
        positionBased: 0,
        dataDriven: 0
      }
    };
    
    // If we don't have conversion actions data, try to collect it
    if (!accountData.conversionActions || accountData.conversionActions.length === 0) {
      try {
        Logger.log("No conversion actions found in accountData, attempting to collect them now...");
        
        // Get conversion action names
        const conversionActionNames = getConversionActionNames();
        
        // Create conversion actions with ZERO metrics initially
        // We will NOT distribute or create fake metrics
        const conversionActions = conversionActionNames.map(name => ({
          name: name,
          conversions: 0,
          conversionValue: 0
        }));
        
        // Try using the CAMPAIGN_PERFORMANCE_REPORT to get total conversion metrics
        try {
          // Get the date range used in the script
          const dateRange = getDateRange();
          
          // Get total conversions from the campaign report
          const campaignReport = AdsApp.report(
            "SELECT CampaignName, Conversions, ConversionValue " +
            "FROM CAMPAIGN_PERFORMANCE_REPORT " +
            `DURING ${dateRange.start},${dateRange.end}`
          );
          
          const campaignRows = campaignReport.rows();
          let totalConversions = 0;
          let totalConversionValue = 0;
          
          // Get total conversions and value from campaigns
          while (campaignRows.hasNext()) {
            const row = campaignRows.next();
            const conversions = parseFloat(row['Conversions']) || 0;
            const conversionValue = parseFloat(row['ConversionValue']) || 0;
            
            totalConversions += conversions;
            totalConversionValue += conversionValue;
          }
          
          // Create a single "Account Conversions" entry with the real total
          // This ensures we have at least one entry with real metrics
          if (totalConversions > 0) {
            const accountConversions = {
              name: "Account Conversions (Total)",
              conversions: totalConversions,
              conversionValue: totalConversionValue
            };
            
            // Add this to the beginning of the array
            conversionActions.unshift(accountConversions);
            
            Logger.log(`Added account-level conversion metrics: ${totalConversions} conversions, ${totalConversionValue} value`);
          }
          
          // Store the conversion actions
          conversionTrackingData.conversionActions = conversionActions;
          accountData.conversionActions = conversionActions;
          
          // Update summary counts
          conversionTrackingData.summary.totalConversionActions = conversionActions.length;
          conversionTrackingData.summary.totalConversions = totalConversions;
          conversionTrackingData.summary.conversionValue = totalConversionValue;
          
          Logger.log(`Created ${conversionActions.length} conversion actions with real account-level metrics`);
        } catch (campaignError) {
          Logger.log(`Error using CAMPAIGN_PERFORMANCE_REPORT: ${campaignError.message}`);
          
          // Still use the conversion actions with zero metrics
          conversionTrackingData.conversionActions = conversionActions;
          accountData.conversionActions = conversionActions;
          
          // Update summary counts
          conversionTrackingData.summary.totalConversionActions = conversionActions.length;
          
          Logger.log(`Created ${conversionActions.length} conversion actions with zero metrics`);
        }
      } catch (e) {
        Logger.log(`Error collecting conversion tracking data: ${e.message}`);
      }
    } else {
      Logger.log(`Using ${accountData.conversionActions.length} conversion actions from accountData`);
      conversionTrackingData.conversionActions = accountData.conversionActions;
    }
    
    // Add the conversion tracking data to the evaluation results
    evaluationResults.conversiontracking.data.conversions = accountData.performance || {};
    evaluationResults.conversiontracking.data.conversionTracking = conversionTrackingData;
    
    // Add default recommendations if none exist
    if (!evaluationResults.conversiontracking.recommendations || 
        evaluationResults.conversiontracking.recommendations.length === 0) {
      
      // Customize recommendations based on conversion data
      const recommendations = [];
      
      if (conversionTrackingData.conversionActions.length === 0) {
        recommendations.push({
          text: "Set up conversion tracking for all important actions on your website",
          impact: 0.9
        });
      } else if (conversionTrackingData.summary.websiteConversions === 0) {
        recommendations.push({
          text: "Add website conversion actions to track important user actions on your site",
          impact: 0.8
        });
      } else if (conversionTrackingData.summary.primaryConversions === 0) {
        recommendations.push({
          text: "Set at least one conversion action as a primary conversion to optimize your campaigns",
          impact: 0.7
        });
      } else if (conversionTrackingData.summary.totalConversions === 0) {
        recommendations.push({
          text: "Your conversion actions are set up but not recording conversions. Check your conversion tracking implementation",
          impact: 0.8
        });
      } else {
        recommendations.push({
          text: "Review your conversion tracking setup to ensure all valuable user actions are being tracked",
          impact: 0.6
        });
      }
      
      evaluationResults.conversiontracking.recommendations = recommendations;
    }
  }
  
  // Keyword Strategy
  if (evaluationResults.keywordstrategy) {
    // Ensure minimum score
    if (evaluationResults.keywordstrategy.score === 0) {
      evaluationResults.keywordstrategy.score = 30;
      evaluationResults.keywordstrategy.letter = 'F';
    }
    
    // Add data
    if (!evaluationResults.keywordstrategy.data) {
      evaluationResults.keywordstrategy.data = {};
    }
    evaluationResults.keywordstrategy.data.keywords = accountData.keywords || {};
    
    // Get real match type distribution data if it's missing
    if (accountData.keywords && 
        (!accountData.keywords.matchTypeDistribution || 
         (accountData.keywords.matchTypeDistribution.EXACT === 0 && 
          accountData.keywords.matchTypeDistribution.PHRASE === 0 && 
          accountData.keywords.matchTypeDistribution.BROAD === 0))) {
      
      try {
        Logger.log("Collecting real match type distribution data...");
        
        // Use AdsApp.keywords() to get match type distribution
        const matchTypeCounts = {
          EXACT: 0,
          PHRASE: 0,
          BROAD: 0
        };
        
        // Retrieve all non-removed keywords in the account
        const keywordIterator = AdsApp.keywords()
          .withCondition("Status != REMOVED")
          .get();
        
        // Loop through keywords and count each match type
        while (keywordIterator.hasNext()) {
          const keyword = keywordIterator.next();
          const matchType = keyword.getMatchType(); // Returns "EXACT", "PHRASE", or "BROAD"
          
          if (matchTypeCounts.hasOwnProperty(matchType)) {
            matchTypeCounts[matchType]++;
          }
        }
        
        // Calculate total keywords
        const totalKeywords = matchTypeCounts.EXACT + matchTypeCounts.PHRASE + matchTypeCounts.BROAD;
        
        // If we found keywords, use those counts
        if (totalKeywords > 0) {
          accountData.keywords.matchTypeDistribution = matchTypeCounts;
          Logger.log("Updated match type distribution with real data: " + 
                    JSON.stringify(matchTypeCounts));
        } else {
          Logger.log("No match type data found using keywords iterator.");
          
          // Try using the report as a fallback
          try {
            // Get the date range used in the script
            const dateRange = getDateRange();
            
            // Query the KEYWORDS_PERFORMANCE_REPORT to get match type data
            const report = AdsApp.report(
              'SELECT KeywordMatchType ' +
              'FROM KEYWORDS_PERFORMANCE_REPORT ' +
              'WHERE Status IN ["ENABLED", "PAUSED"] ' +
              `DURING ${dateRange.start},${dateRange.end}`
            );
            
            const reportMatchTypeCounts = {
              EXACT: 0,
              PHRASE: 0,
              BROAD: 0
            };
            
            const rows = report.rows();
    while (rows.hasNext()) {
      const row = rows.next();
              const matchType = row['KeywordMatchType'];
              
              if (reportMatchTypeCounts.hasOwnProperty(matchType)) {
                reportMatchTypeCounts[matchType]++;
              }
            }
            
            // Calculate total keywords from the report
            const reportTotalKeywords = reportMatchTypeCounts.EXACT + reportMatchTypeCounts.PHRASE + reportMatchTypeCounts.BROAD;
            
            // If we found keywords in the report, use those counts
            if (reportTotalKeywords > 0) {
              accountData.keywords.matchTypeDistribution = reportMatchTypeCounts;
              Logger.log("Updated match type distribution with report data: " + 
                        JSON.stringify(reportMatchTypeCounts));
            } else {
              Logger.log("No match type data found in report.");
            }
          } catch (reportError) {
            Logger.log("Error getting match type distribution from report: " + reportError.message);
          }
        }
      } catch (e) {
        Logger.log("Error getting match type distribution: " + e.message);
      }
    }
    
    // Add default recommendations if none exist
    if (!evaluationResults.keywordstrategy.recommendations || 
        evaluationResults.keywordstrategy.recommendations.length === 0) {
      evaluationResults.keywordstrategy.recommendations = [{
        text: "Expand your keyword list with more specific, long-tail keywords relevant to your business",
        impact: 0.7
      }];
    }
  }
  
  // Negative Keywords
  if (evaluationResults.negativekeywords) {
    // Ensure minimum score
    if (evaluationResults.negativekeywords.score === 0) {
      // If we have negative keywords data, give a higher score
      if (accountData.negativeKeywords && 
          (accountData.negativeKeywords.campaignNegativeCount > 0 || 
           accountData.negativeKeywords.adGroupNegativeCount > 0)) {
        evaluationResults.negativekeywords.score = 50;
        evaluationResults.negativekeywords.letter = 'D';
      } else {
        evaluationResults.negativekeywords.score = 30;
        evaluationResults.negativekeywords.letter = 'F';
      }
    }
    
    // Add data
    if (!evaluationResults.negativekeywords.data) {
      evaluationResults.negativekeywords.data = {};
    }
    evaluationResults.negativekeywords.data.negativeKeywords = accountData.negativeKeywords || {};
    
    // Add default recommendations if none exist
    if (!evaluationResults.negativekeywords.recommendations || 
        evaluationResults.negativekeywords.recommendations.length === 0) {
      evaluationResults.negativekeywords.recommendations = [{
        text: "Add negative keywords to filter out irrelevant search queries and improve ROI",
        impact: 0.7
      }];
    }
  }
  
  // Bidding Strategy
  if (evaluationResults.biddingstrategy) {
    // Ensure minimum score
    if (evaluationResults.biddingstrategy.score === 0) {
      evaluationResults.biddingstrategy.score = 30;
      evaluationResults.biddingstrategy.letter = 'F';
    }
    
    // Add data
    if (!evaluationResults.biddingstrategy.data) {
      evaluationResults.biddingstrategy.data = {};
    }
    
    // Make sure bidding data is properly formatted
    const biddingData = accountData.bidding || {};
    
    // Ensure strategies object is properly formatted for display
    if (biddingData.strategies) {
      // Convert strategies object to a more readable format if needed
      const formattedStrategies = {};
      for (const strategy in biddingData.strategies) {
        formattedStrategies[strategy || '--'] = biddingData.strategies[strategy];
      }
      biddingData.strategies = formattedStrategies;
    }
    
    evaluationResults.biddingstrategy.data.bidding = biddingData;
    
    // Add default recommendations if none exist
    if (!evaluationResults.biddingstrategy.recommendations || 
        evaluationResults.biddingstrategy.recommendations.length === 0) {
      evaluationResults.biddingstrategy.recommendations = [{
        text: "Consider using automated bidding strategies to optimize for conversions or conversion value",
        impact: 0.8
      }];
    }
  }
  
  // Ad Creative & Extensions
  if (evaluationResults.adcreativeextensions) {
    // Ensure minimum score
    if (evaluationResults.adcreativeextensions.score === 0) {
      // If we have extensions data, give a higher score
      if (accountData.extensions && accountData.extensions.totalExtensions > 0) {
        evaluationResults.adcreativeextensions.score = 50;
        evaluationResults.adcreativeextensions.letter = 'D';
      } else {
        evaluationResults.adcreativeextensions.score = 30;
        evaluationResults.adcreativeextensions.letter = 'F';
      }
    }
    
    // Add data
    if (!evaluationResults.adcreativeextensions.data) {
      evaluationResults.adcreativeextensions.data = {};
    }
    evaluationResults.adcreativeextensions.data.ads = accountData.ads || {};
    evaluationResults.adcreativeextensions.data.extensions = accountData.extensions || {};
    
    // Add default recommendations if none exist
    if (!evaluationResults.adcreativeextensions.recommendations || 
        evaluationResults.adcreativeextensions.recommendations.length === 0) {
      evaluationResults.adcreativeextensions.recommendations = [{
        text: "Create multiple ad variations for each ad group to test different messaging",
        impact: 0.7
      }];
    }
  }
  
  // Quality Score
  if (evaluationResults.qualityscore) {
    // Ensure minimum score
    if (evaluationResults.qualityscore.score === 0) {
      evaluationResults.qualityscore.score = 30;
      evaluationResults.qualityscore.letter = 'F';
    }
    
    // Add data
    if (!evaluationResults.qualityscore.data) {
      evaluationResults.qualityscore.data = {};
    }
    evaluationResults.qualityscore.data.qualityScore = accountData.qualityScore || {};
    
    // Add default recommendations if none exist
    if (!evaluationResults.qualityscore.recommendations || 
        evaluationResults.qualityscore.recommendations.length === 0) {
      evaluationResults.qualityscore.recommendations = [{
        text: "Improve ad relevance by ensuring ads closely match the keywords in each ad group",
        impact: 0.8
      }];
    }
  }
  
  // Audience Strategy
  if (evaluationResults.audiencestrategy) {
    // Ensure minimum score
    if (evaluationResults.audiencestrategy.score === 0) {
      // If we have audience data, give a higher score
      if (accountData.audiences && 
          (accountData.audiences.remarketingListCount > 0 || 
           accountData.audiences.activeRemarketingCampaigns > 0)) {
        evaluationResults.audiencestrategy.score = 50;
        evaluationResults.audiencestrategy.letter = 'D';
      } else {
        evaluationResults.audiencestrategy.score = 30;
        evaluationResults.audiencestrategy.letter = 'F';
      }
    }
    
    // Add data
    if (!evaluationResults.audiencestrategy.data) {
      evaluationResults.audiencestrategy.data = {};
    }
    evaluationResults.audiencestrategy.data.audiences = accountData.audiences || {};
    
    // Add default recommendations if none exist
    if (!evaluationResults.audiencestrategy.recommendations || 
        evaluationResults.audiencestrategy.recommendations.length === 0) {
      evaluationResults.audiencestrategy.recommendations = [{
        text: "Implement remarketing to target users who have previously visited your website",
        impact: 0.8
      }];
    }
  }
  
  // Landing Page Optimization
  if (evaluationResults.landingpageoptimization) {
    // Ensure minimum score
    if (evaluationResults.landingpageoptimization.score === 0) {
      evaluationResults.landingpageoptimization.score = 30;
      evaluationResults.landingpageoptimization.letter = 'F';
    }
    
    // Add data
    if (!evaluationResults.landingpageoptimization.data) {
      evaluationResults.landingpageoptimization.data = {};
    }
    evaluationResults.landingpageoptimization.data.landingPage = accountData.landingPage || {};
    
    // Add default recommendations if none exist
    if (!evaluationResults.landingpageoptimization.recommendations || 
        evaluationResults.landingpageoptimization.recommendations.length === 0) {
      evaluationResults.landingpageoptimization.recommendations = [{
        text: "Ensure landing pages are relevant to the ads and keywords that point to them",
        impact: 0.8
      }];
    }
  }
  
  // Competitive Analysis
  if (evaluationResults.competitiveanalysis) {
    // Ensure minimum score
    if (evaluationResults.competitiveanalysis.score === 0) {
      // If we have competitive data, give a higher score
      if (accountData.competitive && accountData.competitive.hasAuctionInsightsData) {
        evaluationResults.competitiveanalysis.score = 50;
        evaluationResults.competitiveanalysis.letter = 'D';
      } else {
        evaluationResults.competitiveanalysis.score = 30;
        evaluationResults.competitiveanalysis.letter = 'F';
      }
    }
    
    // Add data
    if (!evaluationResults.competitiveanalysis.data) {
      evaluationResults.competitiveanalysis.data = {};
    }
    evaluationResults.competitiveanalysis.data.competitive = accountData.competitive || {};
    
    // Add default recommendations if none exist
    if (!evaluationResults.competitiveanalysis.recommendations || 
        evaluationResults.competitiveanalysis.recommendations.length === 0) {
      evaluationResults.competitiveanalysis.recommendations = [{
        text: "Monitor competitor ads and adjust your strategy to maintain competitive advantage",
        impact: 0.7
      }];
    }
  }
  
  // NEW v2.2: Budget Efficiency
  if (evaluationResults.budgetefficiency) {
    // Ensure minimum score
    if (evaluationResults.budgetefficiency.score === 0) {
      evaluationResults.budgetefficiency.score = 30;
      evaluationResults.budgetefficiency.letter = 'F';
    }
    
    // Add data
    if (!evaluationResults.budgetefficiency.data) {
      evaluationResults.budgetefficiency.data = {};
    }
    evaluationResults.budgetefficiency.data.budgetEfficiency = accountData.budgetEfficiency || {};
    evaluationResults.budgetefficiency.data.searchTerms = accountData.searchTerms || {};
    
    // Add default recommendations if none exist
    if (!evaluationResults.budgetefficiency.recommendations || 
        evaluationResults.budgetefficiency.recommendations.length === 0) {
      const wastedCost = accountData.budgetEfficiency?.totalWastedCost || 0;
      if (wastedCost > 0) {
        evaluationResults.budgetefficiency.recommendations = [{
          text: `Eliminate $${wastedCost.toFixed(2)} in wasted spend by pausing or optimizing non-converting keywords`,
          impact: 0.9
        }];
      } else {
        evaluationResults.budgetefficiency.recommendations = [{
          text: "Continue monitoring budget allocation and search term performance for efficiency opportunities",
          impact: 0.6
        }];
      }
    }
  }
}

/**
 * Gets conversion action names from the account
 * This is a separate function to avoid breaking the main grader functionality
 * @return {Array} Array of conversion action names
 */
function getConversionActionNames() {
  try {
    Logger.log("Getting conversion action names...");
    
    // Try to get conversion actions from the API using different reports
    try {
      // Try using the CAMPAIGN_CONVERSION_ACTION_REPORT which should have conversion action names
      const report = AdsApp.report(
        "SELECT ConversionAction " +
        "FROM CAMPAIGN_CONVERSION_ACTION_REPORT"
      );
      
    const rows = report.rows();
      const conversionNames = new Set();
      
    while (rows.hasNext()) {
      const row = rows.next();
        const name = row['ConversionAction'];
        
        if (name && name.trim() !== '') {
          conversionNames.add(name);
        }
      }
      
      if (conversionNames.size > 0) {
        Logger.log(`Found ${conversionNames.size} conversion action names from CAMPAIGN_CONVERSION_ACTION_REPORT`);
        return Array.from(conversionNames);
      }
    } catch (e) {
      Logger.log(`Error getting conversion names from CAMPAIGN_CONVERSION_ACTION_REPORT: ${e.message}`);
      
      // Try a different report if the first one fails
      try {
        // Try using the CONVERSION_ACTION_REPORT
        const report = AdsApp.report(
          "SELECT ConversionActionName " +
          "FROM CONVERSION_ACTION_REPORT"
        );
        
        const rows = report.rows();
        const conversionNames = new Set();
        
        while (rows.hasNext()) {
          const row = rows.next();
          const name = row['ConversionActionName'];
          
          if (name && name.trim() !== '') {
            conversionNames.add(name);
          }
        }
        
        if (conversionNames.size > 0) {
          Logger.log(`Found ${conversionNames.size} conversion action names from CONVERSION_ACTION_REPORT`);
          return Array.from(conversionNames);
        }
      } catch (e2) {
        Logger.log(`Error getting conversion names from CONVERSION_ACTION_REPORT: ${e2.message}`);
      }
    }
    
    // If we couldn't get conversion action names from reports, try to extract them from campaign data
    try {
      // Get the date range used in the script
      const dateRange = getDateRange();
      
      // Try to extract conversion action names from the campaign performance report
      const campaignReport = AdsApp.report(
        "SELECT CampaignName, ConversionTypeName " +
        "FROM CAMPAIGN_PERFORMANCE_REPORT " +
        `DURING ${dateRange.start},${dateRange.end}`
      );
      
      const rows = campaignReport.rows();
      const conversionNames = new Set();
      
      while (rows.hasNext()) {
        const row = rows.next();
        try {
          const name = row['ConversionTypeName'];
          
          if (name && name.trim() !== '') {
            conversionNames.add(name);
          }
        } catch (fieldError) {
          // Field might not exist, continue to next row
          Logger.log(`ConversionTypeName field not available in CAMPAIGN_PERFORMANCE_REPORT`);
          break;
        }
      }
      
      if (conversionNames.size > 0) {
        Logger.log(`Found ${conversionNames.size} conversion action names from CAMPAIGN_PERFORMANCE_REPORT`);
        return Array.from(conversionNames);
      }
    } catch (e3) {
      Logger.log(`Error extracting conversion names from CAMPAIGN_PERFORMANCE_REPORT: ${e3.message}`);
    }
    
    // If all else fails, return an empty array - we'll just show account-level metrics
    Logger.log("Could not find conversion action names from any report");
    return [];
  } catch (e) {
    Logger.log(`Error in getConversionActionNames: ${e.message}`);
    return [];
  }
}

/**
 * Gets all bidding strategies in the account
 * @return {Iterator} Iterator of bidding strategies
 */
function getBiddingStrategies() {
  try {
    const bidStrategyIterator = AdsApp.biddingStrategies().get();
    return bidStrategyIterator;
  } catch (e) {
    Logger.log(`Error getting bidding strategies: ${e.message}`);
    return null;
  }
}

/**
 * Gets a bidding strategy by name
 * @param {string} biddingStrategyName The name of the bidding strategy
 * @return {Iterator} Iterator of bidding strategies matching the name
 */
function getBiddingStrategyIteratorByName(biddingStrategyName) {
  try {
    const biddingStrategiesIterator = AdsApp.biddingStrategies()
      .withCondition(`bidding_strategy.name = '${biddingStrategyName}'`)
      .get();
    return biddingStrategiesIterator;
  } catch (e) {
    Logger.log(`Error getting bidding strategy by name: ${e.message}`);
    return null;
  }
  }