import { createError } from 'h3'
import { createHmac, randomUUID } from 'node:crypto'
import { db } from '~/drizzle/db'
import { systemSettings } from '~/drizzle/schema'
import { asc } from 'drizzle-orm'
import {
  isSafeAggregateOAuthUrl,
  getAggregateOAuthLoginTypesOrDefault
} from './oauth-providers'

export interface OAuthUserInfo {
  id: string
  username: string
  email?: string
  name?: string
  avatar?: string
}

export interface OAuthStrategy {
  /**
   * 获取授权跳转 URL
   */
  getAuthorizeUrl(redirectUri: string, state: string): string

  /**
   * 使用 code 换取 access_token
   */
  exchangeToken(code: string, redirectUri: string): Promise<string>

  /**
   * 获取用户信息
   */
  getUserInfo(accessToken: string): Promise<OAuthUserInfo>
}

// GitHub 策略实现
const githubStrategy: OAuthStrategy = {
  getAuthorizeUrl(redirectUri: string, state: string) {
    const clientId = process.env.GITHUB_CLIENT_ID
    if (!clientId)
      throw createError({ statusCode: 500, message: 'GitHub Client ID not configured' })

    return `https://github.com/login/oauth/authorize?client_id=${clientId}&redirect_uri=${encodeURIComponent(redirectUri)}&scope=user:email&state=${encodeURIComponent(state)}`
  },

  async exchangeToken(code: string, redirectUri: string) {
    const clientId = process.env.GITHUB_CLIENT_ID
    const clientSecret = process.env.GITHUB_CLIENT_SECRET

    if (!clientId || !clientSecret) {
      throw createError({ statusCode: 500, message: 'GitHub config missing' })
    }

    try {
      const tokenResponse = await $fetch<any>('https://github.com/login/oauth/access_token', {
        method: 'POST',
        body: {
          client_id: clientId,
          client_secret: clientSecret,
          code,
          redirect_uri: redirectUri
        },
        headers: { Accept: 'application/json' }
      })

      if (tokenResponse.error) {
        console.error('GitHub Token Error:', tokenResponse.error)
        throw new Error('授权失败，请重试')
      }

      if (!tokenResponse.access_token) {
        console.error('GitHub Token Response missing access_token')
        throw new Error('未能获取访问令牌')
      }
      return tokenResponse.access_token
    } catch (e: any) {
      console.error('GitHub token exchange failed', e.message || e)
      const errorMessage = e.data?.error_description || e.message || '令牌请求失败'
      throw new Error(errorMessage)
    }
  },

  async getUserInfo(accessToken: string) {
    try {
      const userInfo = await $fetch<any>('https://api.github.com/user', {
        headers: { Authorization: `Bearer ${accessToken}` }
      })

      return {
        id: String(userInfo.id),
        username: userInfo.login,
        name: userInfo.name,
        email: userInfo.email,
        avatar: userInfo.avatar_url
      }
    } catch (e: any) {
      console.error('GitHub user info failed', e)
      throw new Error('获取用户信息失败')
    }
  }
}

// Casdoor 策略实现
const casdoorStrategy: OAuthStrategy = {
  getAuthorizeUrl(redirectUri: string, state: string) {
    const clientId = process.env.CASDOOR_CLIENT_ID
    const endpoint = process.env.CASDOOR_ENDPOINT
    if (!clientId || !endpoint)
      throw createError({ statusCode: 500, message: 'Casdoor config missing' })

    return `${endpoint}/login/oauth/authorize?client_id=${clientId}&response_type=code&redirect_uri=${encodeURIComponent(redirectUri)}&scope=read&state=${encodeURIComponent(state)}`
  },

  async exchangeToken(code: string, redirectUri: string) {
    const clientId = process.env.CASDOOR_CLIENT_ID
    const clientSecret = process.env.CASDOOR_CLIENT_SECRET
    const endpoint = process.env.CASDOOR_ENDPOINT

    if (!clientId || !clientSecret || !endpoint) {
      throw createError({ statusCode: 500, message: 'Casdoor config missing' })
    }

    try {
      const tokenResponse = await $fetch<any>(`${endpoint}/login/oauth/access_token`, {
        method: 'POST',
        body: {
          client_id: clientId,
          client_secret: clientSecret,
          code,
          grant_type: 'authorization_code',
          redirect_uri: redirectUri
        },
        headers: { Accept: 'application/json' }
      })

      if (tokenResponse.error) {
        console.error('Casdoor Token Error:', tokenResponse.error, tokenResponse.error_description)
        throw new Error(tokenResponse.error_description || '授权失败，请重试')
      }

      if (!tokenResponse.access_token) {
        console.error('Casdoor Token Response missing access_token')
        throw new Error('未能获取访问令牌，请检查 Casdoor 配置')
      }
      return tokenResponse.access_token
    } catch (e: any) {
      console.error('Casdoor token exchange failed', e.message || e)
      const errorMessage = e.data?.error_description || e.message || '令牌请求失败'
      throw new Error(errorMessage)
    }
  },

  async getUserInfo(accessToken: string) {
    const endpoint = process.env.CASDOOR_ENDPOINT
    if (!endpoint) throw createError({ statusCode: 500, message: 'Casdoor config missing' })

    let userInfo: any = {}
    try {
      // Casdoor 用户信息端点通常是 /api/get-account 或 /api/userinfo
      // 标准 OIDC 使用 /userinfo
      try {
        userInfo = await $fetch(`${endpoint}/api/userinfo`, {
          headers: { Authorization: `Bearer ${accessToken}` }
        })
      } catch (e) {
        // 尝试备用端点
        userInfo = await $fetch(`${endpoint}/api/get-account`, {
          headers: { Authorization: `Bearer ${accessToken}` }
        })
      }

      return {
        id: String(userInfo.id || userInfo.sub),
        username: userInfo.name || userInfo.preferred_username || userInfo.username,
        name: userInfo.displayName || userInfo.name,
        email: userInfo.email,
        avatar: userInfo.avatar
      }
    } catch (e: any) {
      console.error('Casdoor user info failed', e)
      throw new Error('获取用户信息失败')
    }
  }
}

// Google 策略实现
const googleStrategy: OAuthStrategy = {
  getAuthorizeUrl(redirectUri: string, state: string) {
    const clientId = process.env.GOOGLE_CLIENT_ID
    if (!clientId)
      throw createError({ statusCode: 500, message: 'Google Client ID not configured' })

    return `https://accounts.google.com/o/oauth2/v2/auth?client_id=${clientId}&redirect_uri=${encodeURIComponent(redirectUri)}&response_type=code&scope=openid%20email%20profile&state=${encodeURIComponent(state)}`
  },

  async exchangeToken(code: string, redirectUri: string) {
    const clientId = process.env.GOOGLE_CLIENT_ID
    const clientSecret = process.env.GOOGLE_CLIENT_SECRET

    if (!clientId || !clientSecret) {
      throw createError({ statusCode: 500, message: 'Google config missing' })
    }

    try {
      const tokenResponse = await $fetch<any>('https://oauth2.googleapis.com/token', {
        method: 'POST',
        body: {
          client_id: clientId,
          client_secret: clientSecret,
          code,
          grant_type: 'authorization_code',
          redirect_uri: redirectUri
        },
        headers: { Accept: 'application/json' }
      })

      if (tokenResponse.error) {
        console.error('Google Token Error:', tokenResponse.error)
        throw new Error('授权失败，请重试')
      }

      if (!tokenResponse.access_token) {
        console.error('Google Token Response missing access_token')
        throw new Error('未能获取访问令牌')
      }
      return tokenResponse.access_token
    } catch (e: any) {
      console.error('Google token exchange failed', e.message || e)
      const errorMessage = e.data?.error_description || e.message || '令牌请求失败'
      throw new Error(errorMessage)
    }
  },

  async getUserInfo(accessToken: string) {
    try {
      const userInfo = await $fetch<any>('https://www.googleapis.com/oauth2/v3/userinfo', {
        headers: { Authorization: `Bearer ${accessToken}` }
      })

      return {
        id: userInfo.sub,
        username: userInfo.email, // Google doesn't have a username, use email
        name: userInfo.name,
        email: userInfo.email,
        avatar: userInfo.picture
      }
    } catch (e: any) {
      console.error('Google user info failed', e)
      throw new Error('获取用户信息失败')
    }
  }
}

// 策略注册表
const strategies: Record<string, OAuthStrategy> = {
  github: githubStrategy,
  casdoor: casdoorStrategy,
  google: googleStrategy
}

async function loadAggregateSettings() {
  const row = await db
    .select({
      aggregateOAuthEnabled: systemSettings.aggregateOAuthEnabled,
      aggregateOAuthAppId: systemSettings.aggregateOAuthAppId,
      aggregateOAuthAppKey: systemSettings.aggregateOAuthAppKey,
      aggregateOAuthLoginType: systemSettings.aggregateOAuthLoginType,
      aggregateOAuthEndpoint: systemSettings.aggregateOAuthEndpoint
    })
    .from(systemSettings)
    .orderBy(asc(systemSettings.id))
    .limit(1)
  const base = row[0] ?? null
  const envAppId = process.env.AGGREGATE_OAUTH_APP_ID
  const envAppKey = process.env.AGGREGATE_OAUTH_APP_KEY
  const envLoginType = process.env.AGGREGATE_OAUTH_LOGIN_TYPE
  const envEndpoint = process.env.AGGREGATE_OAUTH_ENDPOINT
  const hasEnvConfig = !!(envAppId && envAppKey && envEndpoint)
  const dbEnabled = base?.aggregateOAuthEnabled
  const dbHasConfig = !!(
    base?.aggregateOAuthAppId &&
    base?.aggregateOAuthAppKey &&
    base?.aggregateOAuthEndpoint
  )
  const enabled = Boolean(dbEnabled ?? hasEnvConfig)
  const appId = (base?.aggregateOAuthAppId || envAppId || '') as string
  const appKey = (base?.aggregateOAuthAppKey || envAppKey || '') as string
  const loginType = ((base?.aggregateOAuthLoginType as string) || envLoginType || '') as string
  const endpoint = ((base?.aggregateOAuthEndpoint as string) || envEndpoint || '') as string

  return {
    aggregateOAuthEnabled: enabled && !!(appId && appKey && endpoint),
    aggregateOAuthAppId: appId,
    aggregateOAuthAppKey: appKey,
    aggregateOAuthLoginType: loginType,
    aggregateOAuthEndpoint: endpoint,
    _dbHasConfig: dbHasConfig,
    _hasEnvConfig: hasEnvConfig
  } as any
}

function normalizeEndpoint(endpoint: string): string {
  return endpoint.replace(/\/+$/, '')
}

function aggregateSign(params: Record<string, string>, appKey: string): string {
  const sorted = Object.keys(params)
    .filter((k) => params[k] !== undefined && params[k] !== null && params[k] !== '')
    .sort()
    .map((k) => `${k}=${params[k]}`)
    .join('&')
  return createHmac('sha256', appKey).update(sorted).digest('hex')
}

const auxxUserInfoCache = new Map<string, any>()

function isAuxxEndpoint(endpoint: string): boolean {
  return /(^|\.)auxx\.cn(\/|$)/i.test(endpoint)
}

const auxxStrategy: OAuthStrategy = {
  async getAuthorizeUrl(redirectUri: string, state: string) {
    const settings = await loadAggregateSettings()
    if (!settings?.aggregateOAuthEnabled || !settings.aggregateOAuthAppId || !settings.aggregateOAuthAppKey || !settings.aggregateOAuthEndpoint) {
      throw createError({ statusCode: 500, message: '聚合登录未配置' })
    }
    if (!isSafeAggregateOAuthUrl(settings.aggregateOAuthEndpoint)) {
      throw createError({ statusCode: 500, message: '聚合登录端点不安全或格式错误' })
    }
    const loginTypes = getAggregateOAuthLoginTypesOrDefault(settings.aggregateOAuthLoginType)
    const loginType = loginTypes[0] || 'qq'
    const endpoint = normalizeEndpoint(settings.aggregateOAuthEndpoint)
    const loginQuery = new URLSearchParams({
      act: 'login',
      appid: settings.aggregateOAuthAppId,
      appkey: settings.aggregateOAuthAppKey,
      type: loginType,
      redirect_uri: redirectUri
    }).toString()
    try {
      const resp: any = await $fetch(`${endpoint}/connect.php?${loginQuery}`, {
        headers: { Accept: 'application/json' }
      })
      if (resp.code !== 0 || !resp.url) {
        throw new Error(resp.msg || '获取登录跳转地址失败')
      }
      const sep = resp.url.includes('?') ? '&' : '?'
      return `${resp.url}${sep}state=${encodeURIComponent(state)}`
    } catch (e: any) {
      console.error('Auxx OAuth authorize URL failed', e)
      throw new Error(e.message || '获取登录跳转地址失败')
    }
  },
  async exchangeToken(code: string, redirectUri: string) {
    const settings = await loadAggregateSettings()
    if (!settings?.aggregateOAuthEnabled || !settings.aggregateOAuthAppId || !settings.aggregateOAuthAppKey || !settings.aggregateOAuthEndpoint) {
      throw createError({ statusCode: 500, message: '聚合登录未配置' })
    }
    const loginTypes = getAggregateOAuthLoginTypesOrDefault(settings.aggregateOAuthLoginType)
    const loginType = loginTypes[0] || 'qq'
    const endpoint = normalizeEndpoint(settings.aggregateOAuthEndpoint)
    const cbQuery = new URLSearchParams({
      act: 'callback',
      appid: settings.aggregateOAuthAppId,
      appkey: settings.aggregateOAuthAppKey,
      type: loginType,
      code
    }).toString()
    try {
      const resp: any = await $fetch(`${endpoint}/connect.php?${cbQuery}`, {
        headers: { Accept: 'application/json' }
      })
      if (resp.code !== 0 || !resp.access_token || !resp.social_uid) {
        throw new Error(resp.msg || '回调换取用户信息失败')
      }
      const cacheKey = `${settings.aggregateOAuthAppId}:${resp.access_token}`
      auxxUserInfoCache.set(cacheKey, resp)
      setTimeout(() => auxxUserInfoCache.delete(cacheKey), 10 * 60 * 1000)
      return String(resp.access_token)
    } catch (e: any) {
      console.error('Auxx OAuth token exchange failed', e)
      throw new Error(e.message || '回调换取用户信息失败')
    }
  },
  async getUserInfo(accessToken: string) {
    const settings = await loadAggregateSettings()
    const appId = settings?.aggregateOAuthAppId || ''
    const cacheKey = `${appId}:${accessToken}`
    let resp = auxxUserInfoCache.get(cacheKey)
    if (!resp) {
      resp = Array.from(auxxUserInfoCache.values()).find((r: any) => r.access_token === accessToken)
    }
    if (!resp || resp.code !== 0 || !resp.social_uid) {
      throw new Error('获取用户信息失败')
    }
    return {
      id: String(resp.social_uid),
      username: resp.nickname || `wx_${String(resp.social_uid).slice(0, 8)}`,
      name: resp.nickname || undefined,
      email: undefined,
      avatar: resp.faceimg || undefined
    }
  }
}

const standardAggregateStrategy: OAuthStrategy = {
  async getAuthorizeUrl(redirectUri: string, state: string) {
    const settings = await loadAggregateSettings()
    if (!settings?.aggregateOAuthEnabled || !settings.aggregateOAuthAppId || !settings.aggregateOAuthAppKey || !settings.aggregateOAuthEndpoint) {
      throw createError({ statusCode: 500, message: '聚合登录未配置' })
    }
    if (!isSafeAggregateOAuthUrl(settings.aggregateOAuthEndpoint)) {
      throw createError({ statusCode: 500, message: '聚合登录端点不安全或格式错误' })
    }

    const loginTypes = getAggregateOAuthLoginTypesOrDefault(settings.aggregateOAuthLoginType)
    const loginType = loginTypes[0] || 'qq'
    const endpoint = normalizeEndpoint(settings.aggregateOAuthEndpoint)
    const timestamp = String(Math.floor(Date.now() / 1000))
    const nonce = randomUUID().replace(/-/g, '')
    const baseParams: Record<string, string> = {
      app_id: settings.aggregateOAuthAppId,
      response_type: 'code',
      redirect_uri: redirectUri,
      state,
      login_type: loginType,
      timestamp,
      nonce
    }
    const sign = aggregateSign(baseParams, settings.aggregateOAuthAppKey)
    const query = new URLSearchParams({ ...baseParams, sign }).toString()
    return `${endpoint}/oauth/authorize?${query}`
  },

  async exchangeToken(code: string, redirectUri: string) {
    const settings = await loadAggregateSettings()
    if (!settings?.aggregateOAuthEnabled || !settings.aggregateOAuthAppId || !settings.aggregateOAuthAppKey || !settings.aggregateOAuthEndpoint) {
      throw createError({ statusCode: 500, message: '聚合登录未配置' })
    }
    const endpoint = normalizeEndpoint(settings.aggregateOAuthEndpoint)
    const timestamp = String(Math.floor(Date.now() / 1000))
    const nonce = randomUUID().replace(/-/g, '')
    const baseParams: Record<string, string> = {
      app_id: settings.aggregateOAuthAppId,
      grant_type: 'authorization_code',
      code,
      redirect_uri: redirectUri,
      timestamp,
      nonce
    }
    const sign = aggregateSign(baseParams, settings.aggregateOAuthAppKey)

    try {
      const tokenResponse = await $fetch<any>(`${endpoint}/oauth/token`, {
        method: 'POST',
        body: { ...baseParams, sign },
        headers: { Accept: 'application/json' }
      })
      if (tokenResponse.error) {
        throw new Error(tokenResponse.error_description || tokenResponse.error || '令牌请求失败')
      }
      const accessToken = tokenResponse.access_token || tokenResponse.accessToken
      if (!accessToken) {
        throw new Error('未能获取访问令牌')
      }
      return accessToken
    } catch (e: any) {
      console.error('Aggregate OAuth token exchange failed', e)
      throw new Error(e.message || '令牌请求失败')
    }
  },

  async getUserInfo(accessToken: string) {
    const settings = await loadAggregateSettings()
    if (!settings?.aggregateOAuthAppId || !settings?.aggregateOAuthAppKey || !settings?.aggregateOAuthEndpoint) {
      throw createError({ statusCode: 500, message: '聚合登录未配置' })
    }
    const endpoint = normalizeEndpoint(settings.aggregateOAuthEndpoint)
    const timestamp = String(Math.floor(Date.now() / 1000))
    const nonce = randomUUID().replace(/-/g, '')
    const baseParams: Record<string, string> = {
      app_id: settings.aggregateOAuthAppId,
      access_token: accessToken,
      timestamp,
      nonce
    }
    const sign = aggregateSign(baseParams, settings.aggregateOAuthAppKey)

    try {
      const userInfo = await $fetch<any>(`${endpoint}/oauth/userinfo`, {
        method: 'POST',
        body: { ...baseParams, sign },
        headers: { Accept: 'application/json' }
      })
      return {
        id: String(userInfo.id || userInfo.openid || userInfo.sub || userInfo.userId || ''),
        username: userInfo.username || userInfo.nickname || userInfo.name || String(userInfo.id || 'user'),
        name: userInfo.name || userInfo.nickname || undefined,
        email: userInfo.email || undefined,
        avatar: userInfo.avatar || userInfo.avatar_url || userInfo.headimgurl || undefined
      }
    } catch (e: any) {
      console.error('Aggregate OAuth user info failed', e)
      throw new Error('获取用户信息失败')
    }
  }
}

const aggregateStrategy: OAuthStrategy = {
  async getAuthorizeUrl(redirectUri: string, state: string) {
    const settings = await loadAggregateSettings()
    const endpoint = settings?.aggregateOAuthEndpoint || ''
    return isAuxxEndpoint(endpoint)
      ? auxxStrategy.getAuthorizeUrl(redirectUri, state)
      : standardAggregateStrategy.getAuthorizeUrl(redirectUri, state)
  },
  async exchangeToken(code: string, redirectUri: string) {
    const settings = await loadAggregateSettings()
    const endpoint = settings?.aggregateOAuthEndpoint || ''
    return isAuxxEndpoint(endpoint)
      ? auxxStrategy.exchangeToken(code, redirectUri)
      : standardAggregateStrategy.exchangeToken(code, redirectUri)
  },
  async getUserInfo(accessToken: string) {
    const settings = await loadAggregateSettings()
    const endpoint = settings?.aggregateOAuthEndpoint || ''
    return isAuxxEndpoint(endpoint)
      ? auxxStrategy.getUserInfo(accessToken)
      : standardAggregateStrategy.getUserInfo(accessToken)
  }
}

strategies.aggregate = aggregateStrategy

export const getOAuthStrategy = (provider: string): OAuthStrategy => {
  const strategy = strategies[provider]
  if (!strategy) {
    throw createError({ statusCode: 400, message: `Unknown provider: ${provider}` })
  }
  return strategy
}