// lib/secrets.ts
import { SecretManagerServiceClient } from '@google-cloud/secret-manager'

const client = new SecretManagerServiceClient()

export async function getSecret(name: string): Promise<string> {
  if (process.env.NODE_ENV === 'development') {
    return process.env[name] || ''
  }

  const [version] = await client.accessSecretVersion({
    name: `projects/${process.env.GCP_PROJECT}/secrets/${name}/versions/latest`,
  })

  return version.payload?.data?.toString() || ''
}

// Usage
const apiKey = await getSecret('STRIPE_SECRET_KEY')

// sentry.client.config.ts
import * as Sentry from '@sentry/nextjs'

Sentry.init({
  dsn: process.env.NEXT_PUBLIC_SENTRY_DSN,
  environment: process.env.NEXT_PUBLIC_ENV,

  // Performance monitoring
  tracesSampleRate: process.env.NODE_ENV === 'production' ? 0.1 : 1.0,

  // Session replay
  replaysSessionSampleRate: 0.1,
  replaysOnErrorSampleRate: 1.0,

  // From discovery requirements
  beforeSend(event, hint) {
    // Filter sensitive data
    if (event.request?.cookies) {
      delete event.request.cookies
    }
    if (event.user?.email) {
      event.user.email = '[REDACTED]'
    }
    return event
  },

  integrations: [
    new Sentry.BrowserTracing({
      tracingOrigins: ['localhost', 'example.com', /^\//],
    }),
    new Sentry.Replay({
      maskAllText: true,
      blockAllMedia: true,
      maskAllInputs: true,
    }),
    new Sentry.ProfilerIntegration(),
  ],

  // Ignore certain errors
  ignoreErrors: [
    'ResizeObserver loop limit exceeded',
    'Non-Error promise rejection captured',
  ],
})

// lib/analytics.ts
import mixpanel from 'mixpanel-browser'
import posthog from 'posthog-js'
import * as amplitude from '@amplitude/analytics-browser'

export class Analytics {
  constructor() {
    if (typeof window === 'undefined') return

    // Initialize based on discovery KPIs
    if (process.env.NEXT_PUBLIC_MIXPANEL_TOKEN) {
      mixpanel.init(process.env.NEXT_PUBLIC_MIXPANEL_TOKEN, {
        debug: process.env.NODE_ENV === 'development',
        track_pageview: true,
        persistence: 'localStorage',
      })
    }

    if (process.env.NEXT_PUBLIC_POSTHOG_KEY) {
      posthog.init(process.env.NEXT_PUBLIC_POSTHOG_KEY, {
        api_host: 'https://app.posthog.com',
        loaded: (posthog) => {
          if (process.env.NODE_ENV === 'development') {
            posthog.opt_out_capturing()
          }
        },
      })
    }

    if (process.env.NEXT_PUBLIC_AMPLITUDE_KEY) {
      amplitude.init(process.env.NEXT_PUBLIC_AMPLITUDE_KEY)
    }
  }

  identify(userId: string, traits?: Record<string, any>) {
    mixpanel?.identify(userId)
    mixpanel?.people.set(traits)
    posthog?.identify(userId, traits)
    amplitude?.setUserId(userId)
  }

  track(event: string, properties?: Record<string, any>) {
    // Track across all providers
    mixpanel?.track(event, properties)
    posthog?.capture(event, properties)
    amplitude?.track(event, properties)

    // Google Analytics 4
    if (window.gtag) {
      window.gtag('event', event, properties)
    }
  }

  // Track KPIs from discovery
  trackSignup(method: string) {
    this.track('user_signup', {
      method,
      timestamp: new Date().toISOString(),
    })
  }

  trackPurchase(amount: number, plan: string, currency = 'USD') {
    this.track('purchase_completed', {
      amount,
      plan,
      currency,
      timestamp: new Date().toISOString(),
    })
  }

  trackFeatureUsage(feature: string, metadata?: any) {
    this.track('feature_used', {
      feature,
      ...metadata,
    })
  }

  trackError(error: Error, context?: any) {
    this.track('error_occurred', {
      error_message: error.message,
      error_stack: error.stack,
      ...context,
    })
  }
}

export const analytics = new Analytics()

// lib/performance.ts
export class PerformanceMonitor {
  private metrics: Map<string, number[]> = new Map()

  measurePageLoad() {
    if (typeof window === 'undefined') return

    // Core Web Vitals
    const observer = new PerformanceObserver((list) => {
      for (const entry of list.getEntries()) {
        // Log to analytics
        analytics.track('web_vital', {
          name: entry.name,
          value: entry.startTime,
          rating: this.getRating(entry.name, entry.startTime),
        })

        // Send to monitoring service
        if (window.gtag) {
          window.gtag('event', entry.name, {
            value: Math.round(entry.startTime),
            metric_rating: this.getRating(entry.name, entry.startTime),
          })
        }
      }
    })

    observer.observe({ entryTypes: ['largest-contentful-paint'] })

    // First Input Delay
    new PerformanceObserver((list) => {
      const firstInput = list.getEntries()[0]
      const fid = firstInput.processingStart - firstInput.startTime

      analytics.track('web_vital', {
        name: 'FID',
        value: fid,
        rating: this.getRating('FID', fid),
      })
    }).observe({ type: 'first-input', buffered: true })

    // Cumulative Layout Shift
    let cls = 0
    new PerformanceObserver((list) => {
      for (const entry of list.getEntries()) {
        if (!entry.hadRecentInput) {
          cls += entry.value
        }
      }

      analytics.track('web_vital', {
        name: 'CLS',
        value: cls,
        rating: this.getRating('CLS', cls),
      })
    }).observe({ type: 'layout-shift', buffered: true })
  }

  private getRating(metric: string, value: number): 'good' | 'needs-improvement' | 'poor' {
    const thresholds = {
      LCP: [2500, 4000],
      FID: [100, 300],
      CLS: [0.1, 0.25],
      TTFB: [800, 1800],
    }

    const [good, poor] = thresholds[metric] || [0, 0]

    if (value <= good) return 'good'
    if (value <= poor) return 'needs-improvement'
    return 'poor'
  }

  // API Performance
  async measureAPICall<T>(
    name: string,
    fn: () => Promise<T>
  ): Promise<T> {
    const start = performance.now()

    try {
      const result = await fn()
      const duration = performance.now() - start

      this.recordMetric(name, duration)

      analytics.track('api_call', {
        endpoint: name,
        duration,
        success: true,
      })

      return result
    } catch (error) {
      const duration = performance.now() - start

      analytics.track('api_call', {
        endpoint: name,
        duration,
        success: false,
        error: error.message,
      })

      throw error
    }
  }

  private recordMetric(name: string, value: number) {
    if (!this.metrics.has(name)) {
      this.metrics.set(name, [])
    }

    const values = this.metrics.get(name)!
    values.push(value)

    // Keep only last 100 measurements
    if (values.length > 100) {
      values.shift()
    }
  }

  getMetricStats(name: string) {
    const values = this.metrics.get(name) || []

    if (values.length === 0) return null

    const sorted = [...values].sort((a, b) => a - b)

    return {
      min: Math.min(...values),
      max: Math.max(...values),
      avg: values.reduce((a, b) => a + b, 0) / values.length,
      p50: sorted[Math.floor(sorted.length * 0.5)],
      p95: sorted[Math.floor(sorted.length * 0.95)],
      p99: sorted[Math.floor(sorted.length * 0.99)],
    }
  }
}

export const performance = new PerformanceMonitor()

// app/api/health/route.ts
import { NextResponse } from 'next/server'
import { prisma } from '@/lib/prisma'
import { redis } from '@/lib/redis'
import { supabase } from '@/lib/supabase'

export async function GET() {
  const checks = {
    status: 'healthy',
    timestamp: new Date().toISOString(),
    uptime: process.uptime(),
    environment: process.env.NODE_ENV,
    version: process.env.npm_package_version,
    checks: {
      app: 'unknown',
      database: 'unknown',
      cache: 'unknown',
      storage: 'unknown',
      external: 'unknown',
    },
    metrics: {
      memory: process.memoryUsage(),
      cpu: process.cpuUsage(),
    }
  }

  // Check application
  checks.checks.app = 'healthy'

  // Check database
  try {
    await prisma.$queryRaw`SELECT 1`
    checks.checks.database = 'healthy'
  } catch (error) {
    checks.checks.database = 'unhealthy'
    checks.status = 'degraded'
  }

  // Check cache
  try {
    await redis.ping()
    checks.checks.cache = 'healthy'
  } catch (error) {
    checks.checks.cache = 'unhealthy'
    checks.status = 'degraded'
  }

  // Check storage
  try {
    const { error } = await supabase.storage
      .from('health-check')
      .list('', { limit: 1 })

    checks.checks.storage = error ? 'unhealthy' : 'healthy'
  } catch (error) {
    checks.checks.storage = 'unhealthy'
    checks.status = 'degraded'
  }

  // Check external APIs
  try {
    const response = await fetch('https://api.example.com/health', {
      signal: AbortSignal.timeout(5000)
    })
    checks.checks.external = response.ok ? 'healthy' : 'unhealthy'
  } catch (error) {
    checks.checks.external = 'unhealthy'
    // Don't degrade status for external services
  }

  const statusCode = checks.status === 'healthy' ? 200 : 503

  return NextResponse.json(checks, { status: statusCode })
}

// Readiness check
export async function HEAD() {
  try {
    await prisma.$queryRaw`SELECT 1`
    return new Response(null, { status: 200 })
  } catch {
    return new Response(null, { status: 503 })
  }
}