package main

import (
    "time"

    "github.com/darkit/gin"
    "github.com/darkit/gin/cache"
    "github.com/darkit/gin/pkg/sse"
)

func main() {
    // 使用新的选项式API创建路由器
    router := gin.NewRouter(
        gin.WithGinMode("debug"),
        gin.WithJWT("your-super-secret-key"),
        gin.WithCache(&cache.Config{
            TTL:             30 * time.Minute,
            CleanupInterval: 5 * time.Minute,
        }),
        gin.WithSSE(&sse.Config{
            HistorySize:  1000,
            PingInterval: 30 * time.Second,
        }),
        gin.WithOpenAPI(&gin.OpenAPI{
            Title:   "My API",
            Version: "1.0.0",
        }),
        gin.WithCORS("http://localhost:3000"),
        gin.WithRateLimit(100), // 100 requests per minute
        gin.WithRequestID(),
        gin.WithTimeout(30*time.Second),
    )

    // 自动添加健康检查和监控端点
    router.Health()        // GET /health
    router.Metrics()       // GET /metrics

    // 启用Swagger UI
    router.EnableSwagger("/swagger")

    // 基础路由
    router.GET("/ping", func(c *gin.Context) {
        c.Success("pong")
    })

    // 启动服务器
router.Run(":8080")
}

router := gin.NewRouter(
    gin.WithSecurityConfig(func(sec *gin.SecurityConfig) {
        sec.CORSAllowedOrigins = []string{"https://example.com"}
        sec.RateLimitRequestsPerMinute = 200
    }),
    gin.WithConfig(func(cfg *gin.Config) {
        cfg.ErrorHandlerEnabled = true
    }),
)

func main() {
    // 传统方式仍然支持
    config := gin.DefaultConfig()
    config.SSEEnabled = true
    config.ErrorHandlerEnabled = true
    config.SecurityConfig.SensitiveFilter = true

    server := gin.New(config)
    router := server.Router
    // 或者直接使用
    // router := gin.NewRouter(nil)  // 兼容旧用法

    router.GET("/ping", func(c *gin.Context) {
        c.Success("pong")
    })

    router.Run(":8080")
}

router.GET("/users", func(c *gin.Context) {
    users := getUserList()

    // 分页响应
    c.Paginated(users, 1, 10, 100) // data, page, pageSize, total
})

router.POST("/users", func(c *gin.Context) {
    var user User
    if !c.BindJSON(&user) {
        c.ValidationError(gin.H{"error": "无效的数据格式"})
        return
    }

    // 创建成功响应
    c.Created(user) // 201 status
})

router.GET("/users/:id", func(c *gin.Context) {
    id := c.Param("id")
    user := getUserByID(id)

    if user == nil {
        c.NotFound("用户不存在") // 404 status
        return
    }

    c.Success(user) // 200 status
})

// 其他便捷响应方法
router.GET("/forbidden", func(c *gin.Context) {
    c.Forbidden("访问被拒绝") // 403 status
})

router.GET("/unauthorized", func(c *gin.Context) {
    c.Unauthorized("需要身份验证") // 401 status
})

router.GET("/error", func(c *gin.Context) {
    c.ServerError("服务器内部错误") // 500 status
})

router.POST("/process", func(c *gin.Context) {
    c.Accepted("请求已接受，正在处理") // 202 status
})

router.DELETE("/users/:id", func(c *gin.Context) {
    deleteUser(c.Param("id"))
    c.NoContent() // 204 status
})

// 自动读取 ?page=&page_size= 并输出分页响应
router.GET("/orders", func(c *gin.Context) {
    c.PaginateResponse(func(page, size int) (interface{}, int64) {
        orders, total := queryOrders(page, size)
        return orders, total
    })
})

router := gin.NewRouter(
    // CORS 跨域配置
    gin.WithCORS("http://localhost:3000", "https://example.com"),

    // 简单内存限流 (100次/分钟)
    gin.WithRateLimit(100),

    // 自动请求ID生成
    gin.WithRequestID(),

    // 请求超时控制
    gin.WithTimeout(30*time.Second),

    // 传统中间件也支持
    gin.WithMiddleware(gin.Logger(), gin.Recovery()),
)

// 手动获取请求ID（符合UUID v5标准）
router.GET("/request-info", func(c *gin.Context) {
    requestID := c.GetString("request_id")

    // 也可以手动生成新的请求ID
    customID := c.GenerateRequestID()

    c.Success(gin.H{
        "middleware_request_id": requestID,
        "custom_request_id":     customID,
        "format":                "UUID v5 standard",
        "example":               "a1b2c3d4-e5f6-5789-8abc-def012345678",
    })
})

// 编译期受保护的 CRUD 注册（实现 ResourceHandler 接口）
type PostResource struct{}

func (p *PostResource) Index(c *gin.Context)  { c.Success(listPosts()) }
func (p *PostResource) Show(c *gin.Context)   { c.Success(showPost(c.Param("id"))) }
func (p *PostResource) Create(c *gin.Context) { c.Created(createPost(c)) }
func (p *PostResource) Update(c *gin.Context) { c.Success(updatePost(c.Param("id"), c)) }
func (p *PostResource) Delete(c *gin.Context) { c.Success(deletePost(c.Param("id"))) }

// 快速创建完整的 CRUD 路由
router.CRUD("posts", &PostResource{})

func showPost(c *gin.Context) {
    id := c.Param("id")
    post := getPost(id)
    if post == nil {
        c.NotFound("帖子不存在")
        return
    }
    c.Success(post)
}

func createPost(c *gin.Context) {
    var post Post
    if !c.BindJSON(&post) {
        c.ValidationError(gin.H{"error": "数据格式错误"})
        return
    }

    createdPost := savePost(post)
    c.Created(createdPost)
}

// 使用 REST(...) 可以自定义 ID 参数、附加中间件或文档
router.REST("projects", projectController,
    gin.RESTWithIDParam("project_id"),
    gin.RESTWithMiddleware(AuthMiddleware),
    gin.RESTWithDoc("list", gin.Summary("获取项目列表")),
)

type projectController struct{}

func (projectController) Index(c *gin.Context)  { /* ... */ }
func (projectController) Show(c *gin.Context)   { /* ... */ }
func (projectController) Create(c *gin.Context) { /* ... */ }
func (projectController) Update(c *gin.Context) { /* ... */ }
func (projectController) Delete(c *gin.Context) { /* ... */ }

// 也可以在分组上使用
api := router.Group("/api", router.RequireAuth())
api.REST("users", userController{}, gin.RESTWithDoc("show", gin.Summary("用户详情")))

// 创建不同版本的API
v1 := router.API("v1") // 创建 /api/v1 路由组
{
    v1.GET("/users", func(c *gin.Context) {
        c.Success(gin.H{"version": "v1", "users": []string{"user1", "user2"}})
    })
}

v2 := router.API("v2") // 创建 /api/v2 路由组
{
    v2.GET("/users", func(c *gin.Context) {
        c.Success(gin.H{"version": "v2", "users": getUsersWithDetails()})
    })
}

// 简化的文件上传路由
router.Upload("/upload", func(c *gin.Context, file *multipart.FileHeader) error {
    // 验证文件类型
    if !isValidFileType(file.Filename) {
        return errors.New("不支持的文件类型")
    }

    // 验证文件大小
    if file.Size > 10*1024*1024 { // 10MB
        return errors.New("文件太大")
    }

    // 保存文件逻辑
    return saveUploadedFile(file)
})

// 文件下载
router.GET("/files/:name", func(c *gin.Context) {
    filename := c.Param("name")
    c.StreamFile(buildFilePath(filename), filename)
})

// 静态文件服务（增强版）
router.StaticFiles("/static", "./public", authMiddleware) // 支持中间件

// 自动添加健康检查端点
router.Health() // GET /health
// 返回: {"status": "ok", "timestamp": 1234567890, "uptime": 123.45}

// 自定义健康检查路径
router.Health("/status")

// 添加监控端点
router.Metrics() // GET /metrics
// 返回: {"total_routes": 10, "total_groups": 2, "uptime_seconds": 123.45, ...}

// 自定义监控路径
router.Metrics("/stats")

// 用户登录
router.POST("/auth/login", func(c *gin.Context) {
    var loginForm LoginForm
    if !c.BindJSON(&loginForm) {
        c.ValidationError(gin.H{"error": "登录信息格式错误"})
        return
    }

    // 验证用户凭据
    user := authenticateUser(loginForm.Username, loginForm.Password)
    if user == nil {
        c.Unauthorized("用户名或密码错误")
        return
    }

    // 创建JWT载荷
    payload := gin.H{
        "user_id":  user.ID,
        "username": user.Username,
        "role":     user.Role,
    }

    // 生成JWT令牌
    token, err := c.CreateJWTSession("your-secret-key", 2*time.Hour, payload)
    if err != nil {
        c.ServerError("生成令牌失败")
        return
    }

    c.Success(gin.H{
        "token":      token,
        "user":       user,
        "expires_in": 7200, // 2小时
    })
})

// 角色保护
admin := router.Group("/admin")
admin.Use(router.RequireAuth(), router.RequireRoles("admin"))
admin.GET("/stats", func(c *gin.Context) {
    info, _ := c.AuthInfo()
    c.Success(gin.H{"operator": info.Username})
})

// JWT认证中间件
func AuthMiddleware(c *gin.Context) {
    jwt, ok := c.RequireJWT()
    if !ok {
        return // RequireJWT已处理错误响应
    }

    // 设置用户信息到上下文
    c.Set("user_id", jwt["user_id"])
    c.Set("username", jwt["username"])
    c.Set("role", jwt["role"])

    c.Next()
}

// 受保护的路由
protected := router.Group("/api")
protected.Use(AuthMiddleware)
{
    protected.GET("/profile", func(c *gin.Context) {
        userID := c.GetString("user_id")
        username := c.GetString("username")

        c.Success(gin.H{
            "user_id":  userID,
            "username": username,
        })
    })
}

// 刷新令牌
router.POST("/auth/refresh", func(c *gin.Context) {
    token, err := c.RefreshJWTSession("your-secret-key", 2*time.Hour)
    if err != nil {
        c.Unauthorized("刷新令牌失败")
        return
    }

    c.Success(gin.H{"token": token})
})

// 注销
router.POST("/auth/logout", func(c *gin.Context) {
    c.ClearJWT()
    c.Success("注销成功")
})

router := gin.NewRouter(
    gin.WithJWT(os.Getenv("JWT_SECRET")),
)

router.JWTAuthRoutes(gin.JWTAuthRoutesConfig{
    BasePath: "/auth",
    Authenticate: func(c *gin.Context) (*gin.AuthInfo, error) {
        var form LoginForm
        if !c.BindJSON(&form) {
            return nil, fmt.Errorf("无效的登录信息")
        }
        user, err := authService.Login(form.Username, form.Password)
        if err != nil {
            return nil, err
        }
        return &gin.AuthInfo{
            UserID:   user.ID,
            Username: user.Username,
            Email:    user.Email,
            Roles:    user.Roles,
        }, nil
    },
})
// 自动生成 /auth/login /auth/refresh /auth/logout

router.GET("/profile", router.RequireAuth(), func(c *gin.Context) {
    if info, ok := c.AuthInfo(); ok {
        c.Success(gin.H{
            "user_id": info.UserID,
            "username": info.Username,
            "roles": info.Roles,
        })
        return
    }
    c.Unauthorized("令牌无效")
})

router.GET("/reports", func(c *gin.Context) {
    if !c.HasAnyRole("admin", "auditor") {
        c.Forbidden("需要管理员或审计权限")
        return
    }
    // ...
})

// 创建支持OAuth的路由器
router := gin.NewRouter(
    gin.Default(),
    gin.WithJWT("your-secret-key"),
)

// 添加OAuth端点 - 自动创建认证相关路由
router.OAuth()

// 受保护的API
router.GET("/api/profile", func(c *gin.Context) {
    payload := c.GetJWTPayload()
    c.Success(gin.H{"user": payload})
}, router.RequireAuth())

// 手动生成令牌
userClaims := gin.UserClaims{
    UserID:   "user123",
    Username: "john",
    Email:    "john@example.com",
    Roles:    []string{"user", "admin"},
    Scope:    "read write",
}

// 使用默认配置
tokens, err := c.GenerateTokens(userClaims)

// 使用自定义配置
config := &gin.OAuthConfig{
    AccessTokenTTL:  30 * time.Minute,   // 访问令牌30分钟
    RefreshTokenTTL: 7 * 24 * time.Hour, // 刷新令牌7天
    Issuer:          "my-app",
    DefaultScope:    "read",
}
tokens, err := c.GenerateTokens(userClaims, config)

// 基本认证中间件
router.GET("/api/profile", handler, router.RequireAuth())

// 需要特定权限
router.GET("/api/admin", handler, router.RequireAuth("admin"))

// 需要多个权限（AND关系）
router.POST("/api/users", handler, router.RequireAuth("write", "admin"))

// 自定义权限检查
router.GET("/api/data", func(c *gin.Context) {
    payload := c.GetJWTPayload()
    userRoles := payload["roles"].([]string)

    // 自定义权限逻辑
    if !hasRole(userRoles, "manager") {
        c.Forbidden("需要管理员权限")
        return
    }

    c.Success(gin.H{"data": "sensitive information"})
}, router.RequireAuth())

// 撤销特定令牌
router.POST("/logout", func(c *gin.Context) {
    var req struct {
        Token string `json:"token" binding:"required"`
    }
    c.ShouldBindJSON(&req)

    // 调用OAuth撤销端点或手动撤销
    jwtAdapter := c.getJWTAdapter()
    payload, err := jwtAdapter.ValidateToken(req.Token)
    if err != nil {
        c.ValidationError(gin.H{"error": "无效令牌"})
        return
    }

    // 获取JTI和过期时间进行撤销
    jti, _ := payload.GetClaim("jti")
    exp, _ := payload.GetClaim("exp")

    if jtiStr, ok := jti.(string); ok {
        var expTime time.Time
        if expVal, ok := exp.(float64); ok {
            expTime = time.Unix(int64(expVal), 0)
        }

        err := jwtAdapter.RevokeToken(jtiStr, expTime)
        if err != nil {
            c.ServerError("撤销失败")
            return
        }
    }

    c.Success(gin.H{"message": "登出成功"})
})

// 撤销用户所有令牌（管理功能）
router.POST("/admin/revoke-user", func(c *gin.Context) {
    var req struct {
        UserID string `json:"user_id"`
    }
    c.ShouldBindJSON(&req)

    // 实际实现中需要：
    // 1. 查询数据库中该用户的所有活跃令牌
    // 2. 逐个撤销这些令牌
    // 3. 或者使用用户级别的撤销机制

    c.Success(gin.H{"message": "已撤销用户所有令牌"})
}, router.RequireAuth("admin"))

func main() {
    router := gin.NewRouter(
        gin.Default(),
        gin.WithJWT("secret-key"),
    )

    // OAuth路由
    router.OAuth()

    // 自定义登录
    router.POST("/login", func(c *gin.Context) {
        var req struct {
            Username string `json:"username"`
            Password string `json:"password"`
        }
        c.ShouldBindJSON(&req)

        // 验证用户...
        if validateUser(req.Username, req.Password) {
            tokens, _ := c.GenerateTokens(gin.UserClaims{
                UserID:   req.Username,
                Username: req.Username,
                Scope:    "read write",
            })
            c.Success(tokens)
        } else {
            c.Unauthorized("登录失败")
        }
    })

    // 受保护的API
    api := router.Group("/api")
    {
        api.GET("/profile", getProfile, router.RequireAuth())
        api.GET("/admin", adminOnly, router.RequireAuth("admin"))
    }

    router.Run(":8080")
}

// 启用OpenAPI文档生成
router := gin.NewRouter(
    gin.WithOpenAPI(&gin.OpenAPI{
        Title:   "用户管理系统 API",
        Version: "1.0.0",
        Servers: gin.Servers{
            {URL: "http://localhost:8080", Description: "开发服务器"},
            {URL: "https://api.example.com", Description: "生产服务器"},
        },
        SecuritySchemes: gin.SecuritySchemes{
            {
                Name:         "bearerAuth",
                Type:         "http",
                Scheme:       "bearer",
                BearerFormat: "JWT",
            },
        },
    }),
)

// 启用Swagger UI
router.EnableSwagger("/swagger")

// 传统方式 - 使用独立的文档选项
router.GET("/users/:id", getUserHandler,
    gin.Summary("获取用户详情"),
    gin.Description("根据用户ID获取用户详细信息"),
    gin.PathParam("id", "int", "用户ID"),
    gin.Response(200, User{}),
    gin.Response(404, ErrorResponse{}),
)

// 泛型方式 - 类型安全的API定义
router.POST("/users", createUserHandler,
    gin.Summary("创建用户"),
    gin.ReqBody[CreateUserRequest](),  // 泛型请求体
    gin.Resp[User](201),               // 泛型响应
    gin.Resp[ValidationError](400),
)

// 链式构建器模式
router.PUT("/users/:id", updateUserHandler,
    gin.Doc().
        Summary("更新用户").
        Description("更新用户信息").
        PathParam("id", "int", "用户ID").
        RequestBody(CreateUserRequest{}).
        Response(200, User{}).
        Response(400, ValidationError{}).
        Build(),
)

// 为路由组设置默认标签和安全配置
users := router.Group("/api/users").
    WithTags("User Management").
    WithSecurity("bearerAuth")

// 继承组配置的路由
users.GET("/", listUsersHandler,
    gin.Summary("获取用户列表"),
    gin.QueryParam("page", "int", "页码", false),
    gin.Response(200, []User{}),
)

// 管理员API - 继承并扩展安全配置
admin := users.Group("/admin").
    WithTags("Admin Management").
    WithSecurity("bearerAuth", "admin:write")

// 路径参数
gin.PathParam("id", "uuid", "用户唯一标识符")

// 查询参数
gin.QueryParam("search", "string", "搜索关键词", false)

// 请求头
gin.Header("X-Request-ID", "string", "请求追踪ID", false)

// 响应头
gin.ResponseHeader("X-Rate-Limit", "int", "速率限制")

// 认证要求
gin.BearerAuth()  // Bearer令牌认证
gin.BasicAuth()   // Basic认证

// 标记为已弃用
gin.Deprecated()

// 隐藏API（不在文档中显示）
gin.Hide()

// 定义API结构体
type CreateUserRequest struct {
    Username string `json:"username" binding:"required"`
    Email    string `json:"email" binding:"required,email"`
    Name     string `json:"name" binding:"required"`
}

type User struct {
    ID       int    `json:"id"`
    Username string `json:"username"`
    Email    string `json:"email"`
    Name     string `json:"name"`
}

// 使用泛型方法
router.POST("/users", createUserHandler,
    gin.ReqBody[CreateUserRequest](),  // 自动生成请求体schema
    gin.Resp[User](201),               // 自动生成201响应schema
    gin.Resp[ValidationError](400),    // 自动生成400错误schema
)

// 自动提取路径参数并生成文档
router.GET("/users/:id/posts/:post_id", getPostHandler,
    gin.DocAutoPathParams(),  // 自动识别id和post_id参数
    gin.Summary("获取用户帖子详情"),
)

func main() {
    // 创建带OpenAPI支持的路由器
    router := gin.NewRouter(
        gin.WithOpenAPI(&gin.OpenAPI{
            Title:   "用户管理系统 API",
            Version: "1.0.0",
            License: gin.License{
                Name: "MIT",
                URL:  "https://opensource.org/licenses/MIT",
            },
            Contact: gin.Contact{
                Name:  "API Support",
                Email: "support@example.com",
            },
        }),
    )

    // 用户API路由组
    users := router.Group("/api/users").
        WithTags("User Management").
        WithSecurity("bearerAuth")

    users.GET("/", listUsersHandler,
        gin.Summary("获取用户列表"),
        gin.QueryParam("page", "int", "页码", false),
        gin.QueryParam("size", "int", "每页数量", false),
        gin.Resp[[]User](200),
    )

    users.POST("/", createUserHandler,
        gin.Summary("创建用户"),
        gin.ReqBody[CreateUserRequest](),
        gin.Resp[User](201),
        gin.Resp[ValidationError](400),
    )

    // 启用Swagger UI
    router.EnableSwagger("/swagger")

    // 根路径重定向到文档
    router.GET("/", func(c *gin.Context) {
        c.Redirect(302, "/swagger/index.html")
    })

    router.Run(":8080")
}

// 启用SSE并配置
router := gin.NewRouter(
    gin.WithSSE(&sse.Config{
        HistorySize:  1000,           // 历史消息数量
        PingInterval: 30 * time.Second, // 心跳间隔
    }),
)

// 获取SSE Hub
hub := router.GetSSEHub()

// SSE连接端点
router.GET("/events", func(c *gin.Context) {
    clientID := c.Query("client_id")
    if clientID == "" {
        c.ValidationError(gin.H{"error": "缺少client_id参数"})
        return
    }

    // 创建SSE客户端，支持事件过滤和自定义ID
    client := c.NewSSEClientWithOptions(
        []string{"user.created", "user.updated", "system.notice"},
        sse.WithClientID(clientID),
    )
    if client == nil {
        c.ServerError("SSE服务不可用")
        return
    }

    // 发送连接成功消息
    hub.SendToClient(clientID, &sse.Event{
        Event: "system.notice",
        Data: gin.H{
            "message": "连接成功",
            "time":    time.Now().Format("2006-01-02 15:04:05"),
        },
    })

    // 等待连接断开
    <-client.Disconnected
})

// 广播消息
router.POST("/broadcast", func(c *gin.Context) {
    var req struct {
        Event   string `json:"event"`
        Message string `json:"message"`
    }

    if !c.BindJSON(&req) {
        c.ValidationError(gin.H{"error": "请求格式错误"})
        return
    }

    // 广播到所有客户端
    hub.Broadcast(&sse.Event{
        Event: req.Event,
        Data: gin.H{
            "message": req.Message,
            "time":    time.Now().Format("2006-01-02 15:04:05"),
        },
    })

    c.Success(gin.H{
        "message": "广播成功",
        "clients": len(hub.GetClients()),
    })
})

// 发送消息给特定客户端
router.POST("/send/:clientID", func(c *gin.Context) {
    clientID := c.Param("clientID")

    var req struct {
        Event   string `json:"event"`
        Message string `json:"message"`
    }

    if !c.BindJSON(&req) {
        c.ValidationError(gin.H{"error": "请求格式错误"})
        return
    }

    // 发送给指定客户端
    success := hub.SendToClient(clientID, &sse.Event{
        Event: req.Event,
        Data: gin.H{
            "message": req.Message,
            "time":    time.Now().Format("2006-01-02 15:04:05"),
        },
    })

    if !success {
        c.NotFound("客户端不存在")
        return
    }

    c.Success("发送成功")
})

// 获取客户端列表
router.GET("/clients", func(c *gin.Context) {
    clients := hub.GetClients()
    clientList := make([]gin.H, 0, len(clients))

    for _, client := range clients {
        clientList = append(clientList, gin.H{
            "id":          client.ID,
            "connected_at": client.ConnectedAt.Format("2006-01-02 15:04:05"),
            "event_types": client.EventTypes,
        })
    }

    c.Success(gin.H{
        "total":   len(clients),
        "clients": clientList,
    })
})

router := gin.NewRouter(
    gin.WithCache(&cache.Config{
        TTL:             time.Hour,      // 默认过期时间
        CleanupInterval: 10 * time.Minute, // 清理间隔
    }),
)

router.GET("/users/:id", func(c *gin.Context) {
    id := c.Param("id")
    cacheKey := "user:" + id

    // 获取缓存
    cache := c.GetCache()
    if cachedUser, found := cache.Get(cacheKey); found {
        c.Success(cachedUser)
        return
    }

    // 从数据库获取
    user := getUserFromDB(id)
    if user == nil {
        c.NotFound("用户不存在")
        return
    }

    // 设置缓存，5分钟过期
    cache.Set(cacheKey, user, 5*time.Minute)

    c.Success(user)
})

router.GET("/queue", func(c *gin.Context) {
    cache := c.GetCache()
    queueKey := "task_queue"

    // 创建列表缓存
    cache.SetList(queueKey, 10*time.Minute)

    // 添加任务到队列
    cache.LPush(queueKey, "task1", "task2", "task3")
    cache.RPush(queueKey, "task4", "task5")

    // 获取所有任务
    allTasks := cache.LRange(queueKey, 0, -1)

    // 弹出任务
    firstTask, _ := cache.LPop(queueKey)
    lastTask, _ := cache.RPop(queueKey)

    c.Success(gin.H{
        "all_tasks":   allTasks,
        "first_task":  firstTask,
        "last_task":   lastTask,
        "queue_size":  cache.LLen(queueKey),
    })
})

// 1. 使用默认安全配置
config := gin.DefaultConfig()
config.SecurityConfig = gin.DefaultSecurityConfig()

server := gin.New(config)

// 2. 自定义安全配置
config.SecurityConfig = &gin.SecurityConfig{
    // CORS 配置
    CORSAllowedOrigins:  []string{"https://example.com", "https://app.example.com"},
    CORSAllowedMethods:  []string{"GET", "POST", "PUT", "DELETE"},
    CORSAllowedHeaders:  []string{"Content-Type", "Authorization"},
    CORSAllowCredentials: true,
    CORSMaxAge:          3600,

    // 安全头配置
    EnableSecurityHeaders: true,
    CSPPolicy: "default-src 'self'; script-src 'self' 'unsafe-inline'",

    // 敏感信息过滤
    SensitiveFilter: true,
    SensitiveFields: []string{"password", "secret", "token", "key"},
}

// 3. 使用便捷选项
router := gin.NewRouter(
    gin.WithCORS("https://example.com", "https://app.example.com"),
)

// 安全的 CORS 配置会自动验证
router := gin.NewRouter(
    gin.WithCORS("https://example.com"),  // 安全：明确的域名
)

// 以下配置会触发安全警告
// gin.WithCORS("*")  // 危险：允许所有域名

// 如果需要更细的自定义，可自行编写中间件
router.Use(func(c *gin.Context) {
    origin := c.GetHeader("Origin")
    if origin != "https://example.com" {
        c.AbortWithStatus(http.StatusForbidden)
        return
    }

    c.Header("Access-Control-Allow-Origin", origin)
    c.Header("Access-Control-Allow-Methods", "GET,POST")
    c.Header("Access-Control-Allow-Headers", "Content-Type")
    c.Header("Access-Control-Expose-Headers", "X-Total-Count")
    c.Header("Access-Control-Allow-Credentials", "true")
    if c.Request.Method == http.MethodOptions {
        c.AbortWithStatus(http.StatusNoContent)
        return
    }
    c.Next()
})

router.GET("/secure", func(c *gin.Context) {
    // 设置常用安全头
    c.SetSecureHeaders()

    // 设置内容安全策略
    c.SetCSP("default-src 'self'; script-src 'self' https://trusted.cdn.com")

    // 防止点击劫持
    c.SetXFrameOptions("DENY")

    c.Success("安全头已设置")
})

// 全局安全头中间件
router.Use(func(c *gin.Context) {
    c.SetSecureHeaders()
    c.Next()
})

// 启用敏感信息过滤
config := gin.DefaultConfig()
config.SecurityConfig.SensitiveFilter = true
config.SecurityConfig.SensitiveFields = []string{
    "password", "secret", "token", "key", "auth",
}

// 自动过滤日志和响应中的敏感字段
router.POST("/user/login", func(c *gin.Context) {
    var req struct {
        Username string `json:"username"`
        Password string `json:"password"`  // 将被自动过滤
    }

    if !c.BindJSON(&req) {
        return
    }

    // 处理登录逻辑...
    c.Success(gin.H{"message": "登录成功"})
})

router.GET("/info", func(c *gin.Context) {
    info := gin.H{
        "method":      c.Method(),
        "host":        c.Host(),
        "domain":      c.Domain(),
        "scheme":      c.Scheme(),
        "port":        c.Port(),
        "is_ssl":      c.IsSSL(),
        "is_ajax":     c.IsAjax(),
        "content_type": c.ContentType(),
        "user_agent":  c.Request.UserAgent(),
        "client_ip":   c.ClientIP(),
    }

    c.Success(info)
})

router.GET("/i18n", func(c *gin.Context) {
    lang := c.DefaultQuery("lang", "zh-CN")

    messages := map[string]map[string]string{
        "zh-CN": {
            "greeting": "你好，世界！",
            "welcome": "欢迎使用我们的服务",
        },
        "en-US": {
            "greeting": "Hello, World!",
            "welcome": "Welcome to our service",
        },
        "ja-JP": {
            "greeting": "こんにちは、世界！",
            "welcome": "私たちのサービスへようこそ",
        },
    }

    if msg, ok := messages[lang]; ok {
        c.Success(msg)
    } else {
        c.Success(messages["zh-CN"]) // 默认语言
    }
})

// 1. 默认 slog 实现（推荐）
config := gin.DefaultConfig()
config.LoggerConfig = &gin.LoggerConfig{
    UseDefaultLogger: true,
    CustomLogger:     nil,
}

// 2. Gin 兼容实现（默认）
config.LoggerConfig = gin.DefaultLoggerConfig() // UseDefaultLogger: false

// 3. 自定义实现
type MyLogger struct{}
func (l *MyLogger) Debug(format string, args ...any) { /* 自定义逻辑 */ }
func (l *MyLogger) Info(format string, args ...any)  { /* 自定义逻辑 */ }
func (l *MyLogger) Warn(format string, args ...any)  { /* 自定义逻辑 */ }
func (l *MyLogger) Error(format string, args ...any) { /* 自定义逻辑 */ }

config.LoggerConfig = &gin.LoggerConfig{
    CustomLogger: &MyLogger{},
}

// 4. 文件日志实现
fileLogger, err := gin.NewFileLogger("APP", "app.log")
if err == nil {
    config.LoggerConfig = &gin.LoggerConfig{
        CustomLogger: fileLogger,
    }
    defer fileLogger.Close()
}

// 5. 禁用日志
config.LoggerConfig = &gin.LoggerConfig{
    CustomLogger: gin.NewNoOpLogger(),
}

// 在处理函数中访问日志器（需要时）
router.GET("/debug", func(c *gin.Context) {
    // 注意：Context 不直接暴露 logger，遵循单一职责原则
    // 如需在业务代码中记录日志，建议使用全局日志器或依赖注入

    c.Success(gin.H{"message": "请求处理完成"})
})

package main

import (
    "time"

    "github.com/darkit/gin"
    "github.com/darkit/gin/cache"
)

func main() {
    // 创建增强版路由器
    router := gin.NewRouter(
        gin.WithGinMode("debug"),
        gin.WithCache(&cache.Config{
            TTL:             30 * time.Minute,
            CleanupInterval: 5 * time.Minute,
        }),
        gin.WithJWT("your-super-secret-key"),
        gin.WithCORS("*"),
        gin.WithRateLimit(1000),
        gin.WithRequestID(),
    )

    // 健康检查和监控
    router.Health()
    router.Metrics()

    // 公开API
    public := router.Group("/api/public")
    {
        public.POST("/login", handleLogin)
        public.POST("/register", handleRegister)
    }

    // 受保护的API
    protected := router.Group("/api")
    protected.Use(AuthMiddleware)
    {
        // 使用CRUD快捷方法
        protected.CRUD("users", map[string]gin.HandlerFunc{
            "list":   listUsers,
            "show":   showUser,
            "create": createUser,
            "update": updateUser,
            "delete": deleteUser,
        })

        // 文件上传
        protected.Upload("/upload", handleFileUpload)
    }

    // API版本管理
    v1 := router.API("v1")
    v2 := router.API("v2")

    v1.GET("/features", func(c *gin.Context) {
        c.Success([]string{"basic_features"})
    })

    v2.GET("/features", func(c *gin.Context) {
        c.Success([]string{"basic_features", "advanced_features"})
    })

    // SSE事件流
    router.GET("/events", handleSSE)
    router.POST("/broadcast", handleBroadcast)

    // 启动服务器
    router.Run(":8080")
}

// 处理器实现
func handleLogin(c *gin.Context) {
    var req LoginRequest
    if !c.BindJSON(&req) {
        c.ValidationError(gin.H{"error": "登录信息格式错误"})
        return
    }

    user := authenticateUser(req.Username, req.Password)
    if user == nil {
        c.Unauthorized("用户名或密码错误")
        return
    }

    token, _ := c.CreateJWTSession("your-super-secret-key", 2*time.Hour, gin.H{
        "user_id": user.ID,
        "username": user.Username,
    })

    c.Success(gin.H{
        "token": token,
        "user":  user,
    })
}

func listUsers(c *gin.Context) {
    page := c.DefaultInt("page", 1)
    size := c.DefaultInt("size", 10)

    users, total := getUsersPaginated(page, size)
    c.Paginated(users, int64(page), int64(size), int64(total))
}

func createUser(c *gin.Context) {
    var user User
    if !c.BindJSON(&user) {
        c.ValidationError(gin.H{"error": "用户数据格式错误"})
        return
    }

    if !c.Validate(user) {
        return
    }

    createdUser := saveUser(user)
    c.Created(createdUser)
}

func AuthMiddleware(c *gin.Context) {
    jwt, ok := c.RequireJWT()
    if !ok {
        return
    }

    c.Set("user_id", jwt["user_id"])
    c.Next()
}

type LoginRequest struct {
    Username string `json:"username"`
    Password string `json:"password"`
}

type User struct {
    ID       int    `json:"id"`
    Username string `json:"username"`
    Email    string `json:"email"`
}

func (u User) Validate() (bool, string) {
    if u.Username == "" {
        return false, "用户名不能为空"
    }
    if u.Email == "" {
        return false, "邮箱不能为空"
    }
    return true, ""
}

// 原生 Gin 代码
import "github.com/gin-gonic/gin"

r := gin.Default()
r.GET("/ping", func(c *gin.Context) {
    c.JSON(200, gin.H{"message": "pong"})
})

// 迁移到增强版
import gin "github.com/darkit/gin"

r := gin.Default() // 兼容原有用法
r.GET("/ping", func(c *gin.Context) {
    c.Success("pong") // 使用新的响应方法
})

config := gin.DefaultConfig()

// 服务器配置
config.Host = "0.0.0.0"
config.Port = "8080"
config.ReadTimeout = 30 * time.Second
config.WriteTimeout = 30 * time.Second

// 缓存配置
config.CacheEnabled = true
config.CacheConfig = &cache.Config{
    TTL:             time.Hour,
    CleanupInterval: 10 * time.Minute,
}

// SSE配置
config.SSEEnabled = true
config.SSEConfig = &sse.Config{
    HistorySize:  1000,
    PingInterval: 30 * time.Second,
}

// 错误处理配置
config.ErrorHandlerEnabled = true

// 安全配置
config.SecurityConfig = &gin.SecurityConfig{
    CORSAllowedOrigins:    []string{"https://example.com"},
    CORSAllowedMethods:    []string{"GET", "POST", "PUT", "DELETE"},
    CORSAllowedHeaders:    []string{"Content-Type", "Authorization"},
    CORSAllowCredentials:  false,
    EnableSecurityHeaders: true,
    CSPPolicy:            "default-src 'self'",
    SensitiveFilter:      true,
    SensitiveFields:      []string{"password", "secret", "token"},
}

// 日志配置
config.LoggerConfig = &gin.LoggerConfig{
    UseDefaultLogger: true,  // 使用 slog
}

// OpenAPI配置
config.OpenAPIEnabled = true
config.OpenAPI = &gin.OpenAPI{
    Title:   "My API",
    Version: "1.0.0",
    Servers: gin.Servers{
        {URL: "http://localhost:8080", Description: "开发环境"},
    },
}

server := gin.New(config)

// 启用调试模式查看详细日志
router := gin.NewRouter(gin.WithGinMode("debug"))

// 生产环境建议使用发布模式
router := gin.NewRouter(gin.WithGinMode("release"))

//go:embed static/*
var staticFS embed.FS

//go:embed templates/*
var templatesFS embed.FS

func main() {
    router := gin.NewRouter(gin.Default())

    // 基本静态文件服务
    // 访问: /static/style.css -> embed.FS/static/style.css
    router.SetEmbed("/static", staticFS)

    // 移除路径前缀
    // 访问: /assets/style.css -> embed.FS/templates/style.css（但实际为embed.FS/style.css）
    router.SetEmbed("/assets", templatesFS, "templates")

    router.Run(":8080")
}

//go:embed favicon.ico
var faviconFS embed.FS

//go:embed robots.txt
var robotsFS embed.FS

func main() {
    router := gin.NewRouter(gin.Default())

    // 单文件路由，自动识别Content-Type
    router.SetEmbedFile("/favicon.ico", faviconFS, "favicon.ico")
    router.SetEmbedFile("/robots.txt", robotsFS, "robots.txt")

    router.Run(":8080")
}

//go:embed web/dist/*
var webFS embed.FS

//go:embed docs/build/*
var docsFS embed.FS

func main() {
    router := gin.NewRouter(gin.Default())

    // SPA应用资源
    router.SetEmbed("/app", webFS, "web/dist")

    // API文档
    router.SetEmbed("/docs", docsFS, "docs/build")

    // API与静态资源共存
    api := router.Group("/api")
    {
        api.GET("/status", func(c *gin.Context) {
            c.Success(gin.H{"status": "ok"})
        })
    }

    router.Run(":8080")
}

if err := router.SetEmbed("/static", staticFS, "static"); err != nil {
    log.Fatal("嵌入静态资源失败:", err)
}

if err := router.SetEmbedFile("/favicon.ico", faviconFS, "favicon.ico"); err != nil {
    log.Fatal("嵌入单文件失败:", err)
}

func main() {
    router := gin.Default()

    // 基本ZIP文件系统服务
    err := router.SetZipFS("./web.zip", "/app")
    if err != nil {
        log.Fatal("设置ZIP文件系统失败:", err)
    }

    // 访问: http://localhost:8080/app/index.html -> web.zip/index.html
    // 访问: http://localhost:8080/app/css/style.css -> web.zip/css/style.css

    router.Run(":8080")
}

func main() {
    router := gin.Default()

    // 服务ZIP中的特定文件
    err := router.SetZipFile("/api/spec", "./docs.zip", "api.json")
    if err != nil {
        log.Fatal("设置ZIP文件失败:", err)
    }

    // 访问: http://localhost:8080/api/spec -> docs.zip/api.json

    router.Run(":8080")
}

// 启用热更新，每3秒检查ZIP文件变化
router.SetZipFS("./web.zip", "/app",
    gin.WithHotReload(3*time.Second),
)

// 单文件热更新
router.SetZipFile("/config", "./config.zip", "app.json",
    gin.WithFileHotReload(5*time.Second),
)

// 设置默认首页文件
router.SetZipFS("./web.zip", "/app",
    gin.WithIndexFile("main.html"), // 默认为index.html
)

// 访问 /app/ 将自动服务 main.html

// 只允许访问ZIP中的特定路径
router.SetZipFS("./assets.zip", "/static",
    gin.WithSubPaths("/public", "/assets/css", "/assets/js"),
)

// 只能访问:
// /static/public/* -> assets.zip/public/*
// /static/assets/css/* -> assets.zip/assets/css/*
// /static/assets/js/* -> assets.zip/assets/js/*
//
// 访问其他路径将返回404

// 服务加密的ZIP文件
router.SetZipFS("./protected.zip", "/secure",
    gin.WithPassword("your-password"),
    gin.WithHotReload(10*time.Second),
)

// 单文件密码保护
router.SetZipFile("/secret-config", "./encrypted.zip", "config.json",
    gin.WithFilePassword("secret123"),
)

// 为ZIP文件系统添加认证中间件
config := gin.NewZipFSConfig("./admin.zip", "/admin",
    gin.WithPassword("admin123"),
    gin.WithHotReload(5*time.Second),
)

err := router.SetZipFSWithMiddleware(config,
    authMiddleware(),    // 认证中间件
    corsMiddleware(),    // CORS中间件
    loggingMiddleware(), // 日志中间件
)
if err != nil {
    log.Fatal("设置带中间件的ZIP文件系统失败:", err)
}

// 在路由组中使用ZIP文件系统
adminGroup := router.Group("/admin")
adminGroup.Use(authMiddleware()) // 组级认证

// 为整个路由组设置ZIP文件系统
err := adminGroup.SetZipFS("./admin-ui.zip",
    gin.WithHotReload(3*time.Second),
    gin.WithIndexFile("dashboard.html"),
)

// 路由组中的单文件服务
err = adminGroup.SetZipFile("/config", "./admin-config.zip", "settings.json",
    gin.WithFileHotReload(10*time.Second),
)

func main() {
    router := gin.NewRouter(gin.Default())

    // 1. 公开的静态资源（无密码）
    router.SetZipFS("./public.zip", "/public",
        gin.WithHotReload(5*time.Second),
        gin.WithIndexFile("index.html"),
        gin.WithSubPaths("/css", "/js", "/images"), // 安全限制
    )

    // 2. 管理后台（密码保护）
    router.SetZipFS("./admin.zip", "/admin",
        gin.WithPassword("admin-secret"),
        gin.WithHotReload(10*time.Second),
        gin.WithIndexFile("dashboard.html"),
    )

    // 3. API文档（单文件服务）
    router.SetZipFile("/api/docs", "./docs.zip", "swagger.json",
        gin.WithFileHotReload(30*time.Second),
        gin.WithContentType("application/json"),
    )

    // 4. 带中间件的安全区域
    secureConfig := gin.NewZipFSConfig("./secure.zip", "/secure",
        gin.WithPassword("secure123"),
        gin.WithSubPaths("/allowed"),
    )

    router.SetZipFSWithMiddleware(secureConfig,
        authMiddleware(),
        rateLimitMiddleware(),
    )

    // 5. 普通API路由
    router.GET("/api/status", func(c *gin.Context) {
        c.Success(gin.H{"status": "ok"})
    })

    router.Run(":8080")
}

// 获取ZIP文件系统的监控指标
router.GET("/admin/zipfs/metrics", func(c *gin.Context) {
    // 注意：这需要你保存ZIP文件系统的引用
    zfs, _ := gin.NewZipFileSystem(config)
    metrics := zfs.GetMetrics()

    c.Success(gin.H{
        "reload_count":   metrics.ReloadCount,   // 重载次数
        "last_reload":    metrics.LastReload,    // 最后重载时间
        "error_count":    metrics.ErrorCount,    // 错误次数
        "request_count":  metrics.RequestCount,  // 请求次数
    })
})

// ZIP文件不存在
err := router.SetZipFS("./nonexistent.zip", "/app")
if err != nil {
    log.Printf("ZIP文件系统设置失败: %v", err)
    // 可以设置回退处理
}

// 密码错误
err = router.SetZipFS("./encrypted.zip", "/secure",
    gin.WithPassword("wrong-password"),
)
if err != nil {
    log.Printf("密码可能错误: %v", err)
}

// 文件系统监控
router.GET("/admin/zipfs/status", func(c *gin.Context) {
    // 检查ZIP文件系统状态
    if _, err := os.Stat("./web.zip"); err != nil {
        c.ServerError("ZIP文件不可访问: " + err.Error())
        return
    }
    c.Success("ZIP文件系统正常")
})