// internal/schema/validate.go
import "regexp"

var validSchemaSlug = regexp.MustCompile(`^[a-z0-9_]{3,50}$`)

// 保留名称，禁止作为站点 slug
var reservedSlugs = map[string]bool{
    "public": true, "pg_catalog": true, "information_schema": true,
    "pg_toast": true, "pg_temp": true, "site": true, "admin": true,
    "api": true, "setup": true, "system": true, "default": true,
    "template": true, "test": true,
}

func IsValidSiteSlug(slug string) bool {
    if !validSchemaSlug.MatchString(slug) {
        return false
    }
    return !reservedSlugs[slug]
}

// internal/middleware/schema.go — 关键安全逻辑
func SchemaMiddleware(db *bun.DB) gin.HandlerFunc {
    return func(c *gin.Context) {
        slug := c.GetString("site_slug") // 由 SiteResolver 从 sites 表查询注入

        // 二次校验（防御性编程）
        if !schema.IsValidSiteSlug(slug) {
            c.AbortWithStatusJSON(400, gin.H{"error": "invalid site"})
            return
        }

        schemaName := "site_" + slug
        // 使用 fmt.Sprintf 拼接 Schema 名称是安全的，因为 slug 已经过严格校验
        // 仅允许 [a-z0-9_]，不可能包含 SQL 注入载荷
        _, err := db.ExecContext(c.Request.Context(),
            fmt.Sprintf("SET search_path TO '%s', 'public'", schemaName))
        if err != nil {
            c.AbortWithStatusJSON(500, gin.H{"error": "failed to set site context"})
            return
        }

        c.Next()
    }
}

// TokenPair JWT 令牌对
type TokenPair struct {
    AccessToken  string `json:"access_token"`
    RefreshToken string `json:"refresh_token"`
    ExpiresIn    int64  `json:"expires_in"`    // Access Token 过期时间（秒）
    TokenType    string `json:"token_type"`     // 固定值 "Bearer"
}

// service/auth_service.go — Refresh Token 轮换

// Handler 层从 httpOnly Cookie 中提取 Refresh Token 原始值，
// 传递给 Service 层进行哈希比对和轮换。
// Service 层不直接访问 HTTP Cookie，保持层间解耦。
func (s *AuthService) RefreshToken(ctx context.Context, rawToken string) (*TokenPair, error) {
    // 1. 查找并验证旧 Refresh Token（从 public.sfc_refresh_tokens）
    rt, err := s.repo.FindRefreshToken(ctx, hashSHA256(rawToken))
    if err != nil || rt.Revoked || rt.ExpiresAt.Before(time.Now()) {
        return nil, ErrInvalidRefreshToken
    }

    // 2. 立即吊销旧 Token（防止重放攻击）
    if err := s.repo.RevokeRefreshToken(ctx, rt.ID); err != nil {
        return nil, err
    }

    // 3. 颁发新的 Token 对（Access Token 不含 role，角色通过 RBAC 中间件 per-request 解析）
    accessToken, err := s.generateAccessToken(rt.UserID)
    if err != nil {
        return nil, err
    }

    newRefreshToken, err := s.generateRefreshToken(ctx, rt.UserID)
    if err != nil {
        return nil, err
    }

    return &TokenPair{
        AccessToken:  accessToken,
        RefreshToken: newRefreshToken,
        ExpiresIn:    900, // 15 min
    }, nil
}

// service/auth_service.go — 登出黑名单
func (s *AuthService) Logout(ctx context.Context, claims *jwt.Claims) error {
    // 计算 Access Token 剩余有效期
    remaining := time.Until(time.Unix(claims.ExpiresAt, 0))
    if remaining <= 0 {
        return nil // Token 已过期，无需加入黑名单
    }

    // Access Token JTI 加入黑名单
    key := fmt.Sprintf("auth:blacklist:%s", claims.TokenID)
    if err := s.redis.Set(ctx, key, "1", remaining).Err(); err != nil {
        return fmt.Errorf("failed to blacklist token: %w", err)
    }

    // Token 吊销使用 Serializable 隔离级别（见 standard.md §1.3）
    tx, err := s.db.BeginTx(ctx, &sql.TxOptions{
        Isolation: sql.LevelSerializable,
    })
    if err != nil {
        return err
    }
    defer tx.Rollback()

    // 吊销关联的 Refresh Token（从 public.sfc_refresh_tokens）
    if err := s.repo.RevokeRefreshTokensByUserIDTx(tx, claims.UserID); err != nil {
        return err
    }

    return tx.Commit()
}

// pkg/crypto/totp_encryption.go — AES-256-GCM 加密 TOTP 密钥
func EncryptTOTPSecret(plaintext string) (string, error) {
    block, _ := aes.NewCipher(totpEncryptionKey) // 32 bytes from env
    aesGCM, _ := cipher.NewGCM(block)

    nonce := make([]byte, aesGCM.NonceSize()) // 12 bytes
    io.ReadFull(rand.Reader, nonce)

    ciphertext := aesGCM.Seal(nonce, nonce, []byte(plaintext), nil)
    return base64.StdEncoding.EncodeToString(ciphertext), nil
}

// service/auth_service.go — TOTP 防重放
func (s *AuthService) ValidateTOTP(ctx context.Context, userID uuid.UUID, code string) error {
    // 1. 检查是否已使用（防重放）
    replayKey := fmt.Sprintf("2fa:used:%s:%s", userID, code)
    if exists, _ := s.redis.Exists(ctx, replayKey).Result(); exists > 0 {
        return ErrCodeAlreadyUsed
    }

    // 2. 解密 TOTP 密钥并验证码
    secret, err := s.getTOTPSecret(ctx, userID) // 从 public.sfc_user_totp 获取并解密
    if err != nil {
        return err
    }
    if !totp.Validate(code, secret) {
        return ErrInvalidTOTPCode
    }

    // 3. 标记为已使用
    s.redis.Set(ctx, replayKey, "1", 90*time.Second)
    return nil
}

// 评论内容使用 bluemonday 严格白名单，仅允许基础格式化标签
var commentPolicy = bluemonday.NewPolicy()

func init() {
    // 仅允许基础内联标签
    commentPolicy.AllowElements("strong", "em", "code", "a", "br")
    commentPolicy.AllowAttrs("href").OnElements("a")
    commentPolicy.AllowAttrs("rel").Matching(regexp.MustCompile(`^noopener noreferrer$`)).OnElements("a")
    commentPolicy.AllowURLSchemes("https", "http")
}

func SanitizeCommentHTML(input string) string {
    return commentPolicy.Sanitize(input)
}

func GravatarURL(email string, size int) string {
    email = strings.ToLower(strings.TrimSpace(email))
    hash := md5.Sum([]byte(email)) // Gravatar 要求 MD5
    return fmt.Sprintf("https://www.gravatar.com/avatar/%x?s=%d&d=mp", hash, size)
}

// pkg/crypto/preview_token.go
func GeneratePreviewToken() (raw string, hash string, err error) {
    bytes := make([]byte, 32)
    if _, err = rand.Read(bytes); err != nil {
        return "", "", err
    }
    raw = "sky_preview_" + base64.RawURLEncoding.EncodeToString(bytes)
    h := sha256.Sum256([]byte(raw))
    hash = hex.EncodeToString(h[:])
    return raw, hash, nil
}

// pkg/crypto/password.go
import "golang.org/x/crypto/bcrypt"

const bcryptCost = 12

func HashPassword(password string) (string, error) {
    bytes, err := bcrypt.GenerateFromPassword([]byte(password), bcryptCost)
    return string(bytes), err
}

func CheckPassword(password, hash string) bool {
    err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))
    return err == nil
}

// pkg/crypto/password_validator.go
import (
    "regexp"
    "unicode/utf8"
)

var (
    hasUpperCase = regexp.MustCompile(`[A-Z]`)
    hasDigit     = regexp.MustCompile(`[0-9]`)
)

func ValidatePasswordStrength(password string) error {
    if utf8.RuneCountInString(password) < 8 {
        return errors.New("密码长度不能少于 8 位")
    }
    if len(password) > 72 {
        return errors.New("密码长度不能超过 72 字节")
    }
    if !hasUpperCase.MatchString(password) {
        return errors.New("密码必须包含至少一个大写字母")
    }
    if !hasDigit.MatchString(password) {
        return errors.New("密码必须包含至少一个数字")
    }
    return nil
}

// service/auth_service.go — 密码修改
func (s *AuthService) ChangePassword(ctx context.Context, userID uuid.UUID, req ChangePasswordRequest) error {
    user, err := s.userRepo.FindByID(ctx, userID)
    if err != nil {
        return ErrUserNotFound
    }

    // 1. 验证旧密码
    if !crypto.CheckPassword(req.CurrentPassword, user.PasswordHash) {
        return ErrInvalidPassword
    }

    // 2. 校验新密码复杂度
    if err := crypto.ValidatePasswordStrength(req.NewPassword); err != nil {
        return err
    }

    // 3. 哈希新密码
    newHash, err := crypto.HashPassword(req.NewPassword)
    if err != nil {
        return err
    }

    // 4. 密码修改使用 Serializable 隔离级别（见 standard.md §1.3）
    tx, err := s.db.BeginTx(ctx, &sql.TxOptions{
        Isolation: sql.LevelSerializable,
    })
    if err != nil {
        return err
    }
    defer tx.Rollback()

    // 5. 更新密码（public.sfc_users）
    if err := s.userRepo.UpdatePasswordTx(tx, userID, newHash); err != nil {
        return err
    }

    // 6. 吊销所有 Refresh Token，强制重新登录（public.sfc_refresh_tokens）
    if err := s.repo.RevokeRefreshTokensByUserIDTx(tx, userID); err != nil {
        return err
    }

    return tx.Commit()
}

// service/auth_service.go — 登录失败锁定
const (
    maxLoginAttempts = 5
    lockoutDuration  = 15 * time.Minute // 900s
)

func (s *AuthService) checkLoginLockout(ctx context.Context, email string) error {
    key := fmt.Sprintf("login_fail:%s", email)
    count, err := s.redis.Get(ctx, key).Int()
    if err != nil && err != redis.Nil {
        return err
    }
    if count >= maxLoginAttempts {
        return ErrAccountLocked // 返回 429
    }
    return nil
}

func (s *AuthService) recordLoginFailure(ctx context.Context, email string) (int64, error) {
    key := fmt.Sprintf("login_fail:%s", email)
    pipe := s.redis.Pipeline()
    incr := pipe.Incr(ctx, key)
    pipe.Expire(ctx, key, lockoutDuration)
    if _, err := pipe.Exec(ctx); err != nil {
        return 0, err
    }
    return incr.Val(), nil
}

func (s *AuthService) resetLoginFailures(ctx context.Context, email string) {
    key := fmt.Sprintf("login_fail:%s", email)
    s.redis.Del(ctx, key)
}

// handler/auth.go — 安全的登录错误响应
func (h *AuthHandler) Login(c *gin.Context) {
    // ... 省略参数绑定

    err := h.authService.Login(ctx, req)
    switch {
    case errors.Is(err, service.ErrAccountLocked):
        c.JSON(429, ErrorResponse("RATE_LIMITED", "账号已锁定，请 15 分钟后重试"))
    case errors.Is(err, service.ErrInvalidCredentials),
         errors.Is(err, service.ErrUserNotFound): // 邮箱不存在也返回相同消息
        c.JSON(401, ErrorResponse("UNAUTHORIZED", "邮箱或密码错误"))
    default:
        c.JSON(500, ErrorResponse("INTERNAL_ERROR", "登录失败"))
    }
}

// 审计日志记录内容
sfc_site_audits {
    actor_email:   "user@example.com",
    action:        "login",              // login / logout
    resource_type: "session",
    ip_address:    "203.0.113.1",        // 从 X-Forwarded-For 或 RemoteAddr 获取
    user_agent:    "Mozilla/5.0 ...",    // 请求 User-Agent
    created_at:    "2026-02-21T10:00:00Z"
}

// middleware/ratelimit.go — Redis 滑动窗口限流

// Lua Script：原子操作，保证并发安全
var slidingWindowScript = redis.NewScript(`
    local key = KEYS[1]
    local now = tonumber(ARGV[1])
    local window = tonumber(ARGV[2])
    local limit = tonumber(ARGV[3])

    -- 移除窗口外的过期记录
    redis.call('ZREMRANGEBYSCORE', key, 0, now - window)

    -- 获取当前窗口内请求数
    local count = redis.call('ZCARD', key)

    if count < limit then
        -- 未超限，添加当前请求
        redis.call('ZADD', key, now, now .. '-' .. math.random(1000000))
        redis.call('EXPIRE', key, window / 1000)
        return 0  -- 允许
    else
        return 1  -- 拒绝
    end
`)

func RateLimitMiddleware(limit int, window time.Duration) gin.HandlerFunc {
    return func(c *gin.Context) {
        // 根据请求类型确定限流键
        var key string
        if apiKey := c.GetString("api_key_hash"); apiKey != "" {
            key = fmt.Sprintf("ratelimit:api:%s", apiKey)       // 公开 API: 按 API Key
        } else if userID := c.GetString("user_id"); userID != "" {
            key = fmt.Sprintf("ratelimit:user:%s", userID)      // 管理 API: 按用户
        } else {
            key = fmt.Sprintf("ratelimit:ip:%s", c.ClientIP())  // 未认证: 按 IP
        }

        now := time.Now().UnixMilli()
        result, err := slidingWindowScript.Run(c, redisClient,
            []string{key},
            now,
            window.Milliseconds(),
            limit,
        ).Int()

        if err != nil {
            c.Next() // Redis 故障时放行，避免影响可用性
            return
        }

        if result == 1 {
            c.Header("Retry-After", strconv.Itoa(int(window.Seconds())))
            c.AbortWithStatusJSON(429, ErrorResponse("RATE_LIMITED", "请求频率超限"))
            return
        }
        c.Next()
    }
}

// pkg/crypto/apikey.go
import (
    "crypto/rand"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
)

const apiKeyPrefix = "cms_live_"

func GenerateAPIKey() (raw string, hash string, prefix string, err error) {
    // 生成 32 字节随机数
    bytes := make([]byte, 32)
    if _, err = rand.Read(bytes); err != nil {
        return
    }

    // 原始 Key：前缀 + hex 编码
    raw = apiKeyPrefix + hex.EncodeToString(bytes)

    // SHA-256 哈希存储
    h := sha256.Sum256([]byte(raw))
    hash = hex.EncodeToString(h[:])

    // 展示前缀（用于用户识别）
    prefix = raw[:len(apiKeyPrefix)+4] // cms_live_xxxx

    return
}

// middleware/cors.go
import "github.com/gin-contrib/cors"

func CORSMiddleware(allowedOrigins []string) gin.HandlerFunc {
    return cors.New(cors.Config{
        AllowOrigins:     allowedOrigins,     // 从配置文件读取白名单
        AllowMethods:     []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
        AllowHeaders:     []string{"Authorization", "Content-Type", "X-API-Key", "X-Site-Slug"},
        ExposeHeaders:    []string{"X-Request-ID", "Retry-After"},
        AllowCredentials: true,               // 允许 Cookie（Refresh Token）
        MaxAge:           12 * time.Hour,     // 预检请求缓存 12 小时
    })
}

// 正确：参数化查询
func (r *PostRepo) FindByID(ctx context.Context, id uuid.UUID) (*model.Post, error) {
    var post model.Post
    err := r.db.NewSelect().
        Model(&post).
        Where("id = ?", id).
        Where("deleted_at IS NULL").
        Scan(ctx)
    return &post, err
}

// 搜索通过 Meilisearch 实现，不在 SQL 层执行
func (s *PostService) Search(ctx context.Context, siteSlug, keyword string) ([]*model.Post, error) {
    resp, err := s.meili.Index("posts-" + siteSlug).Search(keyword, &meilisearch.SearchRequest{Limit: 20})
    if err != nil { return nil, fmt.Errorf("meilisearch search: %w", err) }
    // 从搜索结果提取 ID，再批量从 DB 加载完整实体
    ids := extractIDs(resp.Hits)
    var posts []*model.Post
    err = s.db.NewSelect().Model(&posts).Where("id IN (?)", bun.In(ids)).Scan(ctx)
    return posts, err
}

// 错误：字符串拼接 SQL（严禁使用）
func (r *PostRepo) FindByStatus_UNSAFE(ctx context.Context, status string) ([]*model.Post, error) {
    query := fmt.Sprintf("SELECT * FROM sfc_site_posts WHERE status = '%s'", status)
    // 攻击者传入 status = "'; DROP TABLE sfc_site_posts; --" 即可注入
    return r.db.QueryContext(ctx, query)
}

// pkg/sanitizer/html.go
import "github.com/microcosm-cc/bluemonday"

var contentPolicy *bluemonday.Policy

func init() {
    contentPolicy = bluemonday.NewPolicy()

    // 允许的块级标签
    contentPolicy.AllowElements("p", "h1", "h2", "h3", "h4", "h5", "h6")
    contentPolicy.AllowElements("blockquote", "pre", "code")
    contentPolicy.AllowElements("ul", "ol", "li")
    contentPolicy.AllowElements("table", "thead", "tbody", "tr", "th", "td")
    contentPolicy.AllowElements("hr", "br")
    contentPolicy.AllowElements("figure", "figcaption")

    // 允许的行内标签
    contentPolicy.AllowElements("strong", "em", "del", "mark", "sub", "sup")
    contentPolicy.AllowElements("a", "span")

    // 允许的媒体标签
    contentPolicy.AllowElements("img", "video", "source")

    // 允许的属性
    contentPolicy.AllowAttrs("href").OnElements("a")
    contentPolicy.AllowAttrs("target").Matching(regexp.MustCompile(`^_blank$`)).OnElements("a")
    contentPolicy.AllowAttrs("rel").Matching(regexp.MustCompile(`^noopener noreferrer$`)).OnElements("a")
    contentPolicy.AllowAttrs("src", "alt", "width", "height").OnElements("img")
    contentPolicy.AllowAttrs("src", "controls", "width", "height").OnElements("video")
    contentPolicy.AllowAttrs("src", "type").OnElements("source")
    contentPolicy.AllowAttrs("class").Globally()
    contentPolicy.AllowAttrs("id").Globally()

    // 链接协议白名单
    contentPolicy.AllowURLSchemes("https", "http", "mailto")

    // 禁止所有 JavaScript 事件属性（onclick, onerror 等）
    // bluemonday 默认不允许事件属性，无需额外配置
}

func SanitizeHTML(input string) string {
    return contentPolicy.Sanitize(input)
}

// Refresh Token Cookie 设置
http.SetCookie(w, &http.Cookie{
    Name:     "refresh_token",
    Value:    refreshToken,
    Path:     "/api/v1/auth",    // 仅在 auth 路径下发送
    MaxAge:   7 * 24 * 3600,     // 7 天
    HttpOnly: true,              // JavaScript 不可访问
    Secure:   true,              // 仅 HTTPS
    SameSite: http.SameSiteLaxMode,
})

// router/router.go — 请求体大小限制
func SetupRouter() *gin.Engine {
    r := gin.New()

    // 全局默认：10MB
    r.MaxMultipartMemory = 10 << 20 // 10 MB

    // 文件上传接口：100MB
    media := r.Group("/api/v1/media")
    media.Use(func(c *gin.Context) {
        c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, 100<<20)
        c.Next()
    })

    return r
}

// service/media_service.go — 安全文件名生成
func (s *MediaService) generateStoragePath(mimeType string) string {
    now := time.Now()
    ext := getExtensionFromMIME(mimeType) // 根据 MIME 类型确定扩展名，不信任原始扩展名

    // 路径格式（RustFS 对象 key）：media/{year}/{month}/{uuid}.{ext}
    return fmt.Sprintf("media/%d/%02d/%s%s",
        now.Year(), now.Month(),
        uuid.Must(uuid.NewV7()).String(),
        ext,
    )
    // 示例：media/2026/02/a1b2c3d4-e5f6-7890-abcd-ef1234567890.webp
}

// service/media_service.go — 真实 MIME 检测
func (s *MediaService) validateFile(file multipart.File, header *multipart.FileHeader) error {
    // 1. 读取文件头部 512 字节（http.DetectContentType 需要的最大字节数）
    buf := make([]byte, 512)
    n, err := file.Read(buf)
    if err != nil && err != io.EOF {
        return fmt.Errorf("failed to read file: %w", err)
    }
    buf = buf[:n]

    // 重置读取位置
    if seeker, ok := file.(io.Seeker); ok {
        seeker.Seek(0, io.SeekStart)
    }

    // 2. 检测真实 MIME 类型
    detectedMIME := http.DetectContentType(buf)

    // 3. 校验是否在白名单中
    if !isAllowedMIME(detectedMIME) {
        return fmt.Errorf("不支持的文件类型: %s", detectedMIME)
    }

    // 4. 校验文件大小
    if err := checkFileSize(detectedMIME, header.Size); err != nil {
        return err
    }

    return nil
}

// 提供 SVG 文件时，强制设置 Content-Type，禁止浏览器执行脚本
func serveSVG(c *gin.Context, filePath string) {
    c.Header("Content-Type", "image/svg+xml")
    c.Header("Content-Security-Policy", "script-src 'none'")
    c.Header("X-Content-Type-Options", "nosniff")
    c.File(filePath)
}

// model/audit.go — 审计日志结构
type AuditLog struct {
    ID               uuid.UUID       `db:"id"`
    ActorID          *uuid.UUID      `db:"actor_id"`          // 操作者 ID（可为空，如系统操作）
    ActorEmail       string          `db:"actor_email"`       // 冗余邮箱，防用户删除后丢失
    Action           string          `db:"action"`            // create/update/delete/restore/login/logout/...
    ResourceType     string          `db:"resource_type"`     // post/user/media/category/tag/session/apikey/comment/menu/redirect/preview_token/totp
    ResourceID       string          `db:"resource_id"`       // 资源 UUID
    ResourceSnapshot json.RawMessage `db:"resource_snapshot"` // 操作时的资源快照
    IPAddress        string          `db:"ip_address"`        // 客户端 IP
    UserAgent        string          `db:"user_agent"`        // 请求 User-Agent
    CreatedAt        time.Time       `db:"created_at"`
}