Google Integrations

export async function refreshAccessToken(
  refreshToken: string
): Promise<{ accessToken: string; expiresAt: Date }> {
  const oauth2Client = createGoogleAuthClient();
  oauth2Client.setCredentials({ refresh_token: refreshToken });
  
  const { credentials } = await oauth2Client.refreshAccessToken();
  
  return {
    accessToken: credentials.access_token!,
    expiresAt: new Date(credentials.expiry_date!)
  };
}

export class SearchConsoleClient {
  async getPerformanceData(
    siteUrl: string,
    accessToken: string,
    startDate: string,
    endDate: string
  ): Promise<SearchConsoleData> {
    return await retryWithBackoff(async () => {
      const auth = createGoogleAuthClient();
      auth.setCredentials({ access_token: accessToken });
      
      // Fetch overall metrics, keywords, pages, and daily data in parallel
      const [overallResponse, topKeywords, topPages, dailyData] = 
        await Promise.all([
          this.searchconsole.searchanalytics.query({
            siteUrl,
            auth,
            requestBody: {
              startDate,
              endDate,
              dimensions: [],  // No dimensions = overall totals
              aggregationType: 'auto'
            }
          }),
          this.getTopKeywords(siteUrl, accessToken, 10),
          this.getTopPages(siteUrl, accessToken, 10),
          this.getDailyPerformanceData(siteUrl, accessToken, startDate, endDate)
        ]);
      
      return {
        totalClicks: Math.round(overallResponse.data.rows?.[0]?.clicks || 0),
        totalImpressions: Math.round(overallResponse.data.rows?.[0]?.impressions || 0),
        averagePosition: Number((overallResponse.data.rows?.[0]?.position || 0).toFixed(1)),
        averageCTR: Number(((overallResponse.data.rows?.[0]?.ctr || 0) * 100).toFixed(2)),
        topKeywords,
        topPages,
        dailyData,
        dateRange: { startDate, endDate }
      };
    });
  }
}

export class AnalyticsClient {
  async getOrganicTrafficData(
    propertyId: string,
    accessToken: string,
    startDate: string,
    endDate: string
  ): Promise<AnalyticsData> {
    const auth = createGoogleAuthClient();
    auth.setCredentials({ access_token: accessToken });
    
    // Calculate previous period for comparison
    const daysDiff = getDaysBetween(startDate, endDate);
    const prevStartDate = subtractDays(startDate, daysDiff);
    const prevEndDate = subtractDays(endDate, 1);
    
    // Fetch current and previous period in parallel
    const [currentResponse, previousResponse, landingPages, trafficTrend] = 
      await Promise.all([
        this.getOrganicMetrics(propertyId, auth, startDate, endDate),
        this.getOrganicMetrics(propertyId, auth, prevStartDate, prevEndDate),
        this.getTopLandingPages(propertyId, accessToken, startDate, endDate),
        this.getTrafficTrend(propertyId, auth, startDate, endDate)
      ]);
    
    return {
      organicSessions: currentResponse.sessions,
      sessionsDelta: calculateChange(
        currentResponse.sessions, 
        previousResponse.sessions
      ),
      bounceRate: currentResponse.bounceRate,
      averageSessionDuration: currentResponse.averageSessionDuration,
      topLandingPages: landingPages,
      trafficTrend: trafficTrend,
      dateRange: { startDate, endDate }
    };
  }
}

{
  dimensionFilter: {
    filter: {
      fieldName: 'sessionDefaultChannelGroup',
      stringFilter: {
        matchType: 'EXACT',
        value: 'Organic Search'
      }
    }
  }
}

export class PageSpeedClient {
  private readonly apiKey: string;
  private readonly baseUrl = 'https://www.googleapis.com/pagespeedonline/v5/runPagespeed';
  
  constructor() {
    this.apiKey = process.env.PAGESPEED_API_KEY!;
  }
  
  async getPageSpeedData(url: string): Promise<PageSpeedData> {
    // Fetch mobile and desktop in parallel
    const [mobileData, desktopData] = await Promise.all([
      this.getPageSpeedForStrategy(url, 'mobile'),
      this.getPageSpeedForStrategy(url, 'desktop')
    ]);
    
    return {
      url,
      mobileScore: Math.round(mobileData.score * 100),
      desktopScore: Math.round(desktopData.score * 100),
      coreWebVitals: this.extractCoreWebVitals(mobileData),
      opportunities: this.extractOpportunities(mobileData, desktopData)
    };
  }
}

private extractOpportunities(
  mobileData: PageSpeedResponse,
  desktopData: PageSpeedResponse
): PageSpeedOpportunity[] {
  const opportunities: PageSpeedOpportunity[] = [];
  
  // Key audits that provide optimization opportunities
  const opportunityAudits = [
    'unused-css-rules',
    'unused-javascript',
    'render-blocking-resources',
    'unminified-css',
    'modern-image-formats',
    'uses-webp-images',
    'server-response-time',
    // ... 10+ more audits
  ];
  
  for (const auditKey of opportunityAudits) {
    const audit = mobileData.lighthouseResult.audits[auditKey];
    
    if (audit && audit.score < 1) {
      const savings = this.extractSavings(audit);
      
      opportunities.push({
        title: audit.title,
        description: audit.description,
        savings: savings,  // milliseconds
        impact: this.categorizeImpact(savings)
      });
    }
  }
  
  // Sort by impact and return top 10
  return opportunities
    .sort((a, b) => b.savings - a.savings)
    .slice(0, 10);
}

export async function retryWithBackoff<T>(
  operation: () => Promise<T>,
  maxRetries: number = 3,
  baseDelay: number = 1000
): Promise<T> {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      return await operation();
    } catch (error) {
      if (attempt === maxRetries) throw error;
      
      // Check if error is retryable
      if (!isRetryableError(error)) throw error;
      
      // Exponential backoff: 1s, 2s, 4s, 8s...
      const delay = baseDelay * Math.pow(2, attempt);
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
}

function isRetryableError(error: any): boolean {
  const retryableStatusCodes = [429, 500, 502, 503, 504];
  return retryableStatusCodes.includes(error.statusCode);
}

export function handleGoogleAPIError(
  error: any,
  service: 'gsc' | 'ga4' | 'pagespeed'
): GoogleAPIError {
  const statusCode = error.response?.status || error.code || 500;
  
  switch (statusCode) {
    case 401:
      return {
        statusCode: 401,
        message: 'Google authentication expired. Please reconnect.',
        retryable: false,
        needsReauth: true
      };
      
    case 403:
      return {
        statusCode: 403,
        message: 'You do not have access to this Google resource.',
        retryable: false,
        needsReauth: false
      };
      
    case 429:
      return {
        statusCode: 429,
        message: 'Google API rate limit exceeded. Retrying...',
        retryable: true,
        needsReauth: false
      };
      
    default:
      return {
        statusCode,
        message: error.message || 'Failed to fetch Google data',
        retryable: statusCode >= 500,
        needsReauth: false
      };
  }
}

# 1. Check Search Console connection
GET /api/clients/{clientId}/google/search-console?startDate=2025-01-01&endDate=2025-01-31

# 2. Check Analytics connection  
GET /api/clients/{clientId}/google/analytics?startDate=2025-01-01&endDate=2025-01-31

# 3. Check PageSpeed
GET /api/clients/{clientId}/pagespeed

# Successful responses return 200 with data
# Failed responses return error codes with details