import { useAuth } from '@/contexts/auth-context'

function LoginPage() {
  const { loginWithOAuth } = useAuth()

  const handleIDmeLogin = async () => {
    try {
      await loginWithOAuth('idme')
      // User will be redirected to ID.me
    } catch (error) {
      console.error('ID.me login failed:', error)
    }
  }

  return (
    <button onClick={handleIDmeLogin} className="idme-button">
      <img src="/logos/idme.svg" alt="ID.me" />
      Sign in with ID.me
    </button>
  )
}

import { useUser } from '@/hooks/use-user'

function ProfileBadges() {
  const { user } = useUser()

  const militaryVerified = user?.groups?.some(
    (g) => g.type === 'military' && g.verified
  )

  const studentVerified = user?.groups?.some(
    (g) => g.type === 'student' && g.verified
  )

  return (
    <div>
      {militaryVerified && (
        <Badge variant="military">
          <Shield /> Military Verified
        </Badge>
      )}
      {studentVerified && (
        <Badge variant="student">
          <GraduationCap /> Student Verified
        </Badge>
      )}
    </div>
  )
}

import { IDmeProvider } from '@/services/auth/providers/idme.provider'

const idmeProvider = new IDmeProvider()

// Request specific verification
const authUrl = await idmeProvider.getAuthorizationUrl({
  scopes: ['military', 'student'],
  affiliationRequired: true,
})

// Redirect user
window.location.href = authUrl

// Require military verification for channel access
const militaryChannel = {
  name: 'Military Only',
  access: {
    requireVerification: true,
    allowedGroups: ['military'],
  },
}

// Check access in middleware
if (!user.groups?.some((g) => g.type === 'military' && g.verified)) {
  return res.status(403).json({ error: 'Military verification required' })
}

// Grant student role for discounts
if (user.groups?.some((g) => g.type === 'student' && g.verified)) {
  user.roles.push('student')
  user.discountEligible = true
}

// Teacher-only content
if (user.groups?.some((g) => g.type === 'teacher' && g.verified)) {
  user.roles.push('educator')
  user.accessLevel = 'premium'
}

describe('ID.me OAuth', () => {
  it('should redirect to ID.me authorization', async () => {
    const response = await fetch('/api/auth/oauth/authorize?provider=idme')
    const data = await response.json()

    expect(data.authUrl).toContain('id.me')
    expect(data.authUrl).toContain('client_id')
  })

  it('should handle callback with code', async () => {
    const response = await fetch(
      '/api/auth/oauth/callback?provider=idme&code=test-code&state=test-state'
    )

    expect([200, 302]).toContain(response.status)
  })
})

// Store tokens encrypted
import { encrypt, decrypt } from '@/lib/crypto'

const encryptedToken = encrypt(accessToken, process.env.ENCRYPTION_KEY)
await db.user.update({
  where: { id: user.id },
  data: { idmeToken: encryptedToken },
})

// Decrypt when needed
const accessToken = decrypt(user.idmeToken, process.env.ENCRYPTION_KEY)

import { captureEvent } from '@/lib/analytics'

// Track verification success
captureEvent('idme_verification_success', {
  userId: user.id,
  groupType: 'military',
  verificationLevel: 'IAL2',
})

// Track verification failure
captureEvent('idme_verification_failed', {
  userId: user.id,
  error: error.message,
})

await auditLog.create({
  event: 'idme_verification',
  userId: user.id,
  metadata: {
    groups: user.groups,
    verifiedAt: new Date(),
  },
})