go_gameshield/internal/repository/admin/waflog.go

package admin

import (
	"context"
	"fmt"
	"math"
	"strings"
	"time"

	v1 "github.com/go-nunu/nunu-layout-advanced/api/v1"
	adminApi "github.com/go-nunu/nunu-layout-advanced/api/v1/admin"
	"github.com/go-nunu/nunu-layout-advanced/internal/model"
	"github.com/go-nunu/nunu-layout-advanced/internal/repository"
	"gorm.io/gorm"
)

type WafLogRepository interface {
	GetWafLog(ctx context.Context, id int64) (*model.WafLog, error)
	GetWafLogList(ctx context.Context, req adminApi.SearchWafLogParams) (*v1.PaginatedResponse[model.WafLog], error)
	AddWafLog(ctx context.Context, log *model.WafLog) error
	BatchAddWafLog(ctx context.Context, logs []*model.WafLog) error
	ExportWafLog(ctx context.Context, req adminApi.ExportWafLog) ([]model.WafLogWithGatewayIP, error)
	ExportWafLogWithPagination(ctx context.Context, req adminApi.ExportWafLog, page, pageSize int) ([]model.WafLogWithGatewayIP, error)
	GetWafLogExportCount(ctx context.Context, req adminApi.ExportWafLog) (int, error)
}

func NewWafLogRepository(
	repository *repository.Repository,
) WafLogRepository {
	return &wafLogRepository{
		Repository: repository,
	}
}

type wafLogRepository struct {
	*repository.Repository
}

// buildExportQuery 是一个辅助函数，用于构建导出日志的公共查询条件（支持分表）
func (r *wafLogRepository) buildExportQuery(ctx context.Context, req adminApi.ExportWafLog, tableName string) *gorm.DB {
	// 使用传入的表名，给表起一个别名，方便子查询中引用
	query := r.DBWithName(ctx, "admin").Model(&model.WafLog{}).Table(tableName + " as wl")

	if req.RequestIp != "" {
		query = query.Where("wl.request_ip = ?", strings.TrimSpace(req.RequestIp))
	}
	if req.Uid != 0 {
		query = query.Where("wl.uid = ?", req.Uid)
	}
	if req.Api != "" {
		query = query.Where("wl.api = ?", strings.TrimSpace(req.Api))
	}
	if req.Name != "" {
		query = query.Where("wl.name = ?", strings.TrimSpace(req.Name))
	}
	if req.RuleId != 0 {
		query = query.Where("wl.rule_id = ?", req.RuleId)
	}
	if len(req.HostIds) > 0 {
		query = query.Where("wl.host_id IN ?", req.HostIds)
	}
	if req.UserAgent != "" {
		query = query.Where("wl.user_agent = ?", strings.TrimSpace(req.UserAgent))
	}
	if len(req.ApiNames) > 0 {
		query = query.Where("wl.api_name IN ?", req.ApiNames)
	}
	if len(req.ApiTypes) > 0 {
		query = query.Where("wl.api_type IN ?", req.ApiTypes)
	}
	if req.StartTime != "" {
		query = query.Where("wl.created_at > ?", strings.TrimSpace(req.StartTime))
	}
	if req.EndTime != "" {
		query = query.Where("wl.created_at < ?", strings.TrimSpace(req.EndTime))
	}

	return query
}

// getExportTimeRange 根据请求参数解析时间范围，用于确定需要查询的分表
func (r *wafLogRepository) getExportTimeRange(req adminApi.ExportWafLog) (*time.Time, *time.Time) {
	var startTime, endTime *time.Time
	
	if req.StartTime != "" {
		if t, err := time.Parse("2006-01-02 15:04:05", strings.TrimSpace(req.StartTime)); err == nil {
			startTime = &t
		} else if t, err := time.Parse("2006-01-02", strings.TrimSpace(req.StartTime)); err == nil {
			startTime = &t
		}
	}
	
	if req.EndTime != "" {
		if t, err := time.Parse("2006-01-02 15:04:05", strings.TrimSpace(req.EndTime)); err == nil {
			endTime = &t
		} else if t, err := time.Parse("2006-01-02", strings.TrimSpace(req.EndTime)); err == nil {
			endTime = &t
		}
	}
	
	return startTime, endTime
}

// buildSubQueryForTable 为指定的表构建子查询
func (r *wafLogRepository) buildSubQueryForTable(ctx context.Context, tableName string) *gorm.DB {
	// 需要在所有可能包含"分配网关组"数据的表中查找
	// 这里简化处理，先在当前表中查找，如果需要跨表查找可以进一步优化
	return r.DBWithName(ctx, "admin").Table(tableName).
		Select("extra_data").
		Where("api_name = ?", "分配网关组").
		Where("host_id = wl.host_id").
		Where("uid = wl.uid").
		Where("created_at <= wl.created_at").
		Order("created_at DESC").
		Limit(1)
}


func (r *wafLogRepository) GetWafLog(ctx context.Context, id int64) (*model.WafLog, error) {
	var res model.WafLog

	// 获取存在的分表
	existingTables := r.Manager.GetTableNamesWithExistenceCheck(r.DBWithName(ctx, "admin"), "waf_log", nil, nil)
	
	// 在各个分表中查找
	for _, tableName := range existingTables {
		err := r.DBWithName(ctx, "admin").Table(tableName).Where("id = ?", id).First(&res).Error
		if err == nil {
			res.SetTableName(tableName)
			return &res, nil
		}
	}
	
	return nil, fmt.Errorf("未找到ID为 %d 的WAF日志记录", id)
}

func (r *wafLogRepository) GetWafLogList(ctx context.Context, req adminApi.SearchWafLogParams) (*v1.PaginatedResponse[model.WafLog], error) {

	
	//// 解析时间范围(如果有的话)
	//var startTime, endTime *time.Time
	//// TODO: 这里可以根据req中的时间字段来确定查询范围
	//// 暂时查询最近3个月的数据
	
	// 获取需要查询的表
	existingTables := r.Manager.GetTableNamesWithExistenceCheck(r.DBWithName(ctx, "admin"), "waf_log", nil, nil)
	
	if len(existingTables) == 0 {
		// 没有分表，返回空结果
		return &v1.PaginatedResponse[model.WafLog]{
			Records:    []model.WafLog{},
			Page:       1,
			PageSize:   10,
			Total:      0,
			TotalPages: 0,
		}, nil
	}
	
	if len(existingTables) == 1 {
		// 只有一个表，直接查询
		return r.queryWafLogFromSingleTable(ctx, req, existingTables[0])
	}
	
	// 跨表分页查询
	return r.queryWafLogFromMultipleTables(ctx, req, existingTables)
}

// queryWafLogFromSingleTable 单表查询
func (r *wafLogRepository) queryWafLogFromSingleTable(ctx context.Context, req adminApi.SearchWafLogParams, tableName string) (*v1.PaginatedResponse[model.WafLog], error) {
	var res []model.WafLog
	var total int64

	query := r.DBWithName(ctx, "admin").Table(tableName)
	query = r.applyWafLogFilters(query, req)

	if err := query.Count(&total).Error; err != nil {
		return nil, err
	}

	page := req.Current
	pageSize := req.PageSize

	if page <= 0 {
		page = 1
	}

	if pageSize <= 0 {
		pageSize = 10
	} else if pageSize > 100 {
		pageSize = 100
	}

	offset := (page - 1) * pageSize
	
	if req.Column != "" {
		query = query.Order(req.Column + " " + req.Order)
	}
	
	result := query.Offset(offset).Limit(pageSize).Find(&res)
	if result.Error != nil {
		return nil, result.Error
	}

	return &v1.PaginatedResponse[model.WafLog]{
		Records:    res,
		Page:       page,
		PageSize:   pageSize,
		Total:      total,
		TotalPages: int(math.Ceil(float64(total) / float64(pageSize))),
	}, nil
}

// queryWafLogFromMultipleTables 多表联合查询
func (r *wafLogRepository) queryWafLogFromMultipleTables(ctx context.Context, req adminApi.SearchWafLogParams, tableNames []string) (*v1.PaginatedResponse[model.WafLog], error) {
	var allResults []model.WafLog
	var totalCount int64

	// 先计算总数
	for _, tableName := range tableNames {
		var count int64
		query := r.DBWithName(ctx, "admin").Table(tableName)
		query = r.applyWafLogFilters(query, req)
		
		if err := query.Count(&count).Error; err != nil {
			return nil, err
		}
		totalCount += count
	}

	page := req.Current
	pageSize := req.PageSize

	if page <= 0 {
		page = 1
	}

	if pageSize <= 0 {
		pageSize = 10
	} else if pageSize > 100 {
		pageSize = 100
	}

	// 计算需要跳过的记录数
	offset := (page - 1) * pageSize
	limit := pageSize
	currentOffset := 0

	// 逐表查询直到获取足够的记录
	for _, tableName := range tableNames {
		if limit <= 0 {
			break
		}

		var tableCount int64
		countQuery := r.DBWithName(ctx, "admin").Table(tableName)
		countQuery = r.applyWafLogFilters(countQuery, req)
		if err := countQuery.Count(&tableCount).Error; err != nil {
			return nil, err
		}

		// 如果当前表的记录数不足以满足offset要求，跳过这个表
		if currentOffset+int(tableCount) <= offset {
			currentOffset += int(tableCount)
			continue
		}

		// 计算在当前表中的offset
		tableOffset := offset - currentOffset
		if tableOffset < 0 {
			tableOffset = 0
		}

		var tableResults []model.WafLog
		query := r.DBWithName(ctx, "admin").Table(tableName)
		query = r.applyWafLogFilters(query, req)
		
		if req.Column != "" {
			query = query.Order(req.Column + " " + req.Order)
		}

		err := query.Offset(tableOffset).Limit(limit).Find(&tableResults).Error
		if err != nil {
			return nil, err
		}

		// 设置表名
		for i := range tableResults {
			tableResults[i].SetTableName(tableName)
		}

		allResults = append(allResults, tableResults...)
		limit -= len(tableResults)
		currentOffset += int(tableCount)
	}

	return &v1.PaginatedResponse[model.WafLog]{
		Records:    allResults,
		Page:       page,
		PageSize:   pageSize,
		Total:      totalCount,
		TotalPages: int(math.Ceil(float64(totalCount) / float64(pageSize))),
	}, nil
}

func (r *wafLogRepository) AddWafLog(ctx context.Context, log *model.WafLog) error {
	// 设置创建时间
	if log.CreatedAt.IsZero() {
		log.CreatedAt = time.Now()
	}

	
	// 获取最优的写入表(自动根据表名获取阈值)
	tableName, err := r.Manager.GetOptimalWriteTable(ctx, r.DBWithName(ctx, "admin"), log)
	if err != nil {
		return fmt.Errorf("获取写入表失败: %v", err)
	}
	
	log.SetTableName(tableName)
	
	// 确保表存在
	err = r.Manager.EnsureTableExists(ctx, r.DBWithName(ctx, "admin"), tableName, &model.WafLog{})
	if err != nil {
		return err
	}
	
	// 写入数据
	return r.DBWithName(ctx, "admin").Table(tableName).Create(log).Error
}

func (r *wafLogRepository) BatchAddWafLog(ctx context.Context, logs []*model.WafLog) error {
	if len(logs) == 0 {
		return nil
	}

	// 按表名分组
	tableGroups := make(map[string][]*model.WafLog)
	
	for _, log := range logs {
		// 设置创建时间
		if log.CreatedAt.IsZero() {
			log.CreatedAt = time.Now()
		}
		
		// 获取最优的写入表(自动根据表名获取阈值)
		tableName, err := r.Manager.GetOptimalWriteTable(ctx, r.DBWithName(ctx, "admin"), log)
		if err != nil {
			return fmt.Errorf("获取写入表失败: %v", err)
		}
		
		log.SetTableName(tableName)
		
		// 按表名分组
		tableGroups[tableName] = append(tableGroups[tableName], log)
	}
	
	// 为每个表批量插入
	for tableName, tableLogs := range tableGroups {
		// 确保表存在
		err := r.Manager.EnsureTableExists(ctx, r.DBWithName(ctx, "admin"), tableName, &model.WafLog{})
		if err != nil {
			return err
		}
		
		// 批量插入
		err = r.DBWithName(ctx, "admin").Table(tableName).CreateInBatches(tableLogs, len(tableLogs)).Error
		if err != nil {
			return err
		}
	}
	
	return nil
}

func (r *wafLogRepository) ExportWafLog(ctx context.Context, req adminApi.ExportWafLog) ([]model.WafLogWithGatewayIP, error) {
	return r.ExportWafLogWithPagination(ctx, req, 0, 0)
}

// ExportWafLogWithPagination 使用子查询获取每条日志在当时时间点的正确网关组IP（支持分表）
func (r *wafLogRepository) ExportWafLogWithPagination(ctx context.Context, req adminApi.ExportWafLog, page, pageSize int) ([]model.WafLogWithGatewayIP, error) {
	// 1. 解析时间范围
	startTime, endTime := r.getExportTimeRange(req)
	
	// 2. 获取需要查询的分表
	existingTables := r.Manager.GetTableNamesWithExistenceCheck(r.DBWithName(ctx, "admin"), "waf_log", startTime, endTime)
	
	if len(existingTables) == 0 {
		return []model.WafLogWithGatewayIP{}, nil
	}
	
	if len(existingTables) == 1 {
		// 单表查询
		return r.exportFromSingleTable(ctx, req, existingTables[0], page, pageSize)
	}
	
	// 多表查询（不分页，获取所有数据）
	if page > 0 && pageSize > 0 {
		return r.exportFromMultipleTablesWithPagination(ctx, req, existingTables, page, pageSize)
	} else {
		return r.exportFromMultipleTables(ctx, req, existingTables)
	}
}

// exportFromSingleTable 从单个表导出数据
func (r *wafLogRepository) exportFromSingleTable(ctx context.Context, req adminApi.ExportWafLog, tableName string, page, pageSize int) ([]model.WafLogWithGatewayIP, error) {
	var res []model.WafLogWithGatewayIP
	
	// 1. 构建基础查询
	query := r.buildExportQuery(ctx, req, tableName)
	
	// 2. 构建子查询
	subQuery := r.buildSubQueryForTable(ctx, tableName)
	
	// 3. 添加 Select
	query = query.Select("wl.*, (?) as gateway_ip_data", subQuery)
	
	// 4. 添加分页
	if page > 0 && pageSize > 0 {
		offset := (page - 1) * pageSize
		query = query.Offset(offset).Limit(pageSize)
	}
	
	// 5. 执行查询
	if err := query.Find(&res).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			return []model.WafLogWithGatewayIP{}, nil
		}
		return nil, err
	}
	
	return res, nil
}

// exportFromMultipleTables 从多个表导出所有数据（不分页）
func (r *wafLogRepository) exportFromMultipleTables(ctx context.Context, req adminApi.ExportWafLog, tableNames []string) ([]model.WafLogWithGatewayIP, error) {
	var allResults []model.WafLogWithGatewayIP
	
	for _, tableName := range tableNames {
		tableResults, err := r.exportFromSingleTable(ctx, req, tableName, 0, 0)
		if err != nil {
			return nil, fmt.Errorf("查询表 %s 失败: %v", tableName, err)
		}
		
		allResults = append(allResults, tableResults...)
	}
	
	return allResults, nil
}

// exportFromMultipleTablesWithPagination 从多个表导出数据（支持分页）
func (r *wafLogRepository) exportFromMultipleTablesWithPagination(ctx context.Context, req adminApi.ExportWafLog, tableNames []string, page, pageSize int) ([]model.WafLogWithGatewayIP, error) {
	var allResults []model.WafLogWithGatewayIP
	currentOffset := (page - 1) * pageSize
	remaining := pageSize
	
	for _, tableName := range tableNames {
		if remaining <= 0 {
			break
		}
		
		// 先获取表的总记录数
		countQuery := r.buildExportQuery(ctx, req, tableName)
		var tableCount int64
		if err := countQuery.Count(&tableCount).Error; err != nil {
			return nil, fmt.Errorf("统计表 %s 记录数失败: %v", tableName, err)
		}
		
		// 如果当前偏移量大于等于表记录数，跳过这个表
		if currentOffset >= int(tableCount) {
			currentOffset -= int(tableCount)
			continue
		}
		
		// 计算在当前表中需要查询的数据
		tablePageSize := remaining
		if int(tableCount) - currentOffset < tablePageSize {
			tablePageSize = int(tableCount) - currentOffset
		}
		
		tablePage := (currentOffset / pageSize) + 1
		tableOffset := currentOffset % pageSize
		
		// 查询当前表数据
		tableResults, err := r.exportFromSingleTable(ctx, req, tableName, tablePage, tablePageSize)
		if err != nil {
			return nil, fmt.Errorf("查询表 %s 失败: %v", tableName, err)
		}
		
		// 如果有偏移量，跳过前面的记录
		if tableOffset > 0 && len(tableResults) > tableOffset {
			tableResults = tableResults[tableOffset:]
		}
		
		allResults = append(allResults, tableResults...)
		remaining -= len(tableResults)
		currentOffset = 0 // 后续表从0开始
	}
	
	return allResults, nil
}


// GetWafLogExportCount 获取导出数据总数（支持分表）
func (r *wafLogRepository) GetWafLogExportCount(ctx context.Context, req adminApi.ExportWafLog) (int, error) {
	// 1. 解析时间范围
	startTime, endTime := r.getExportTimeRange(req)
	
	// 2. 获取需要查询的分表
	existingTables := r.Manager.GetTableNamesWithExistenceCheck(r.DBWithName(ctx, "admin"), "waf_log", startTime, endTime)
	
	if len(existingTables) == 0 {
		return 0, nil
	}
	
	var totalCount int64
	
	// 3. 逐表统计
	for _, tableName := range existingTables {
		var tableCount int64
		
		// 使用更新后的 buildExportQuery 方法
		query := r.buildExportQuery(ctx, req, tableName)
		
		if err := query.Count(&tableCount).Error; err != nil {
			return 0, fmt.Errorf("统计表 %s 记录数失败: %v", tableName, err)
		}
		
		totalCount += tableCount
	}
	
	return int(totalCount), nil
}



// applyWafLogFilters 应用WafLog查询过滤条件
func (r *wafLogRepository) applyWafLogFilters(query *gorm.DB, req adminApi.SearchWafLogParams) *gorm.DB {
	if req.RequestIp != "" {
		trimmedName := strings.TrimSpace(req.RequestIp)
		query = query.Where("request_ip LIKE CONCAT('%', ?, '%')", trimmedName)
	}

	if req.Uid != 0 {
		query = query.Where("uid = ?", req.Uid)
	}

	if req.Api != "" {
		trimmedName := strings.TrimSpace(req.Api)
		query = query.Where("api LIKE CONCAT('%', ?, '%')", trimmedName)
	}

	if req.Name != "" {
		trimmedName := strings.TrimSpace(req.Name)
		query = query.Where("name LIKE CONCAT('%', ?, '%')", trimmedName)
	}

	if req.RuleId != 0 {
		query = query.Where("rule_id = ?", req.RuleId)
	}

	if req.HostId != 0 {
		query = query.Where("host_id = ?", req.HostId)
	}

	if req.UserAgent != "" {
		trimmedName := strings.TrimSpace(req.UserAgent)
		query = query.Where("user_agent LIKE CONCAT('%', ?, '%')", trimmedName)
	}

	if req.ApiName != "" {
		trimmedName := strings.TrimSpace(req.ApiName)
		query = query.Where("api_name LIKE CONCAT('%', ?, '%')", trimmedName)
	}

	if req.ApiType != "" {
		query = query.Where("api_type = ?", req.ApiType)
	}

	return query
}