package repository

import (
	"context"

	"carrot_bbs/internal/model"

	"gorm.io/gorm"
)

// DataChangeLogRepository 数据变更日志仓储
type DataChangeLogRepository struct {
	db *gorm.DB
}

// NewDataChangeLogRepository 创建数据变更日志仓储
func NewDataChangeLogRepository(db *gorm.DB) *DataChangeLogRepository {
	return &DataChangeLogRepository{db: db}
}

// CreateDataChangeLog 创建单条数据变更日志
func (r *DataChangeLogRepository) CreateDataChangeLog(ctx context.Context, log *model.DataChangeLog) error {
	return r.db.WithContext(ctx).Create(log).Error
}

// BatchCreateDataChangeLogs 批量创建数据变更日志
func (r *DataChangeLogRepository) BatchCreateDataChangeLogs(ctx context.Context, logs []*model.DataChangeLog) error {
	if len(logs) == 0 {
		return nil
	}
	return r.db.WithContext(ctx).Create(logs).Error
}

// GetDataChangeLogs 获取数据变更日志列表（分页）
func (r *DataChangeLogRepository) GetDataChangeLogs(ctx context.Context, filters DataChangeFilter, page, pageSize int) ([]*model.DataChangeLog, int64, error) {
	query := r.db.WithContext(ctx).Model(&model.DataChangeLog{})

	if filters.UserID != "" {
		query = query.Where("user_id = ?", filters.UserID)
	}
	if filters.OperatorID != "" {
		query = query.Where("operator_id = ?", filters.OperatorID)
	}
	if filters.ChangeType != "" {
		query = query.Where("change_type = ?", filters.ChangeType)
	}
	if filters.TargetType != "" {
		query = query.Where("target_type = ?", filters.TargetType)
	}
	if filters.OperatorType != "" {
		query = query.Where("operator_type = ?", filters.OperatorType)
	}
	if filters.StartTime != "" {
		query = query.Where("created_at >= ?", filters.StartTime)
	}
	if filters.EndTime != "" {
		query = query.Where("created_at <= ?", filters.EndTime)
	}
	if filters.IP != "" {
		query = query.Where("ip = ?", filters.IP)
	}

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

	var logs []*model.DataChangeLog
	offset := (page - 1) * pageSize
	if err := query.Order("created_at DESC").Offset(offset).Limit(pageSize).Find(&logs).Error; err != nil {
		return nil, 0, err
	}

	return logs, total, nil
}

// GetDataChangeLogsByUser 获取指定用户的数据变更日志
func (r *DataChangeLogRepository) GetDataChangeLogsByUser(ctx context.Context, userID string, page, pageSize int) ([]*model.DataChangeLog, int64, error) {
	return r.GetDataChangeLogs(ctx, DataChangeFilter{UserID: userID}, page, pageSize)
}

// GetDataChangeLogsByOperator 获取指定操作人的日志
func (r *DataChangeLogRepository) GetDataChangeLogsByOperator(ctx context.Context, operatorID string, page, pageSize int) ([]*model.DataChangeLog, int64, error) {
	return r.GetDataChangeLogs(ctx, DataChangeFilter{OperatorID: operatorID}, page, pageSize)
}

// DeleteOldLogs 删除旧的数据变更日志（用于定时清理）
func (r *DataChangeLogRepository) DeleteOldLogs(ctx context.Context, beforeDate string) error {
	return r.db.WithContext(ctx).Where("created_at < ?", beforeDate).Delete(&model.DataChangeLog{}).Error
}

// GetStatistics 获取数据变更日志统计
func (r *DataChangeLogRepository) GetStatistics(ctx context.Context, startTime, endTime string) (*DataChangeLogStatistics, error) {
	stats := &DataChangeLogStatistics{}

	query := r.db.WithContext(ctx).Model(&model.DataChangeLog{})
	if startTime != "" {
		query = query.Where("created_at >= ?", startTime)
	}
	if endTime != "" {
		query = query.Where("created_at <= ?", endTime)
	}

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

	if err := query.Where("operator_type = ?", string(model.OperatorTypeAdmin)).Count(&stats.AdminCount).Error; err != nil {
		return nil, err
	}

	if err := query.Where("operator_type = ?", string(model.OperatorTypeSelf)).Count(&stats.UserCount).Error; err != nil {
		return nil, err
	}

	return stats, nil
}

// DataChangeFilter 数据变更日志过滤条件
type DataChangeFilter struct {
	UserID       string
	OperatorID   string
	ChangeType   string
	TargetType   string
	OperatorType string
	IP           string
	StartTime    string
	EndTime      string
}

// DataChangeLogStatistics 数据变更日志统计
type DataChangeLogStatistics struct {
	TotalCount int64
	AdminCount int64
	UserCount  int64
}