// Gin 路由定义与中间件使用示例
func main() {
    r := gin.Default()
    
    // 集成 Redis 缓存中间件（减少数据库访问压力）
    r.Use(redisMiddleware())
    
    // 文章路由组（API 版本化管理）
    articleGroup := r.Group("/api/v1/articles")
    {
        articleGroup.GET("", articleHandler.List)               // 公开访问：文章列表
        articleGroup.POST("", authMiddleware(), articleHandler.Create)  // 需认证：创建文章
        articleGroup.GET("/:id", articleHandler.Get)            // 公开访问：单篇文章详情
    }
    
    // 启动服务（监听 8080 端口）
    if err := r.Run(":8080"); err != nil {
        log.Fatalf("服务启动失败：%v", err)
    }
}

<template>
  <div class="article-detail">
    <h1>{{ article.title }}</h1>
    <div class="content" v-html="renderedContent" />
    <div class="comments">
      <CommentList :article-id="article.id" />
    </div>
  </div>
</template>

<script setup lang="ts">
import { marked } from 'marked'
import DOMPurify from 'dompurify'

const route = useRoute()
const { data: article } = await useFetch(`/api/v1/articles/${route.params.id}`)

// 服务端渲染 Markdown 内容，首屏秒开
const renderedContent = computed(() => {
  const raw = marked.parse(article.value?.content || '')
  return DOMPurify.sanitize(raw)
})

useHead({
  title: article.value?.title || '文章详情',
  meta: [
    { name: 'description', content: article.value?.summary }
  ]
})
</script>

// 图片上传至 COS 核心逻辑
func UploadToCOS(file *multipart.FileHeader) (string, error) {
    // 初始化 COS 客户端
    client := cos.NewClient(bucketURL, &cos.BaseURL{BucketURL: bucketDomain})
    
    // 打开上传文件
    f, err := file.Open()
    if err != nil {
        return "", fmt.Errorf("文件打开失败：%v", err)
    }
    defer f.Close()
    
    // 生成唯一文件名（避免冲突）
    key := fmt.Sprintf("images/%d-%s", time.Now().UnixMicro(), file.Filename)
    
    // 上传文件至 COS
    _, err = client.Object.Put(context.Background(), key, f, nil)
    if err != nil {
        return "", fmt.Errorf("COS 上传失败：%v", err)
    }
    
    // 返回 CDN 加速地址
    return fmt.Sprintf("%s/%s", cdnDomain, key), nil
}

// GitHub OAuth2 登录回调处理
func GitHubLoginCallback(c *gin.Context) {
    // 1. 用授权码兑换访问令牌
    code := c.Query("code")
    token, err := githubOAuth.Exchange(context.Background(), code)
    if err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": "授权失败"})
        return
    }
    
    // 2. 获取用户信息
    userInfo, err := githubOAuth.GetUserInfo(token.AccessToken)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": "获取用户信息失败"})
        return
    }
    
    // 3. 创建或更新本地用户
    user := models.FindOrCreateUser(userInfo)
    
    // 4. 生成 JWT 令牌（有效期 7 天）
    jwtToken, err := generateJWT(user.ID, 7*24*time.Hour)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": "令牌生成失败"})
        return
    }
    
    // 5. 跳转至首页（携带令牌）
    c.Redirect(http.StatusFound, fmt.Sprintf("/?token=%s", jwtToken))
}

// AI 写作助手交互逻辑
const askAI = async (question: string) => {
    // 显示加载状态
    isLoading.value = true
    aiResponse.value = ''
    
    try {
        // 发起流式请求
        const res = await fetch('/api/ai/ask', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({ question, context: currentDraft.value })
        })
        
        // 处理流式响应
        const reader = res.body?.getReader()
        const decoder = new TextDecoder()
        
        while (true) {
            const { done, value } = await reader.read()
            if (done) break
            
            // 实时拼接 AI 回复内容
            aiResponse.value += decoder.decode(value, { stream: true })
        }
    } catch (err) {
        aiResponse.value = 'AI 服务暂时不可用，请稍后再试'
    } finally {
        isLoading.value = false
    }
}

// nuxt.config.ts 关键配置
export default defineNuxtConfig({
  // SSR 编译兼容（Arco Design 需要 transpile 才能在服务端编译）
  build: {
    transpile: ['@arco-design/web-vue'],
  },
  
  // Nitro 开发代理（解决前后端分离跨域）
  nitro: {
    devProxy: {
      '/api': {
        target: 'http://127.0.0.1:8000/api',
        changeOrigin: true,
        ws: true,
      },
    },
  },
})

// 精细化 CORS 中间件实现
func CORSMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 允许指定域名（生产环境限制来源）
        origin := c.Request.Header.Get("Origin")
        if allowOrigin(origin) {
            c.Writer.Header().Set("Access-Control-Allow-Origin", origin)
        }
        
        // 允许的请求方法
        c.Writer.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
        
        // 允许的请求头
        c.Writer.Header().Set("Access-Control-Allow-Headers", "Origin, Content-Type, Authorization")
        
        // 允许携带凭证（如 Cookie）
        c.Writer.Header().Set("Access-Control-Allow-Credentials", "true")
        
        // 预检请求缓存时间
        c.Writer.Header().Set("Access-Control-Max-Age", "86400")
        
        // 处理预检请求
        if c.Request.Method == "OPTIONS" {
            c.AbortWithStatus(http.StatusNoContent)
            return
        }
        
        c.Next()
    }
}