package dns

import (
	"context"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"math"
	"math/rand"
	"net"
	"os"
	"path/filepath"
	"runtime"
	"sort"
	"strings"
	"sync"
	"sync/atomic"
	"time"

	"dns-server/config"
	"dns-server/gfw"
	"dns-server/logger"
	"dns-server/shield"

	"github.com/miekg/dns"
)

// 确保DNS服务器地址包含端口号，默认添加53端口
func normalizeDNSServerAddress(address string) string {
	// 检查地址是否已经包含端口号
	if _, _, err := net.SplitHostPort(address); err != nil {
		// 如果没有端口号，添加默认的53端口
		return net.JoinHostPort(address, "53")
	}
	// 已经有端口号，直接返回
	return address
}

// BlockedDomain 屏蔽域名统计
type BlockedDomain struct {
	Domain   string
	Count    int64
	LastSeen int64
	DNSSEC   bool // 是否使用了DNSSEC
}

// ClientStats 客户端统计

type ClientStats struct {
	IP       string
	Count    int64
	LastSeen int64
}

// DNSAnswer DNS解析记录
type DNSAnswer struct {
	Type  string `json:"type"`  // 记录类型
	Value string `json:"value"` // 记录值
	TTL   uint32 `json:"ttl"`   // 生存时间
}

// QueryLog 查询日志记录
type QueryLog struct {
	Timestamp    time.Time   `json:"timestamp"`    // 查询时间
	ClientIP     string      `json:"clientIP"`     // 客户端IP
	Location     string      `json:"location"`     // IP地理位置（国家 城市）
	Domain       string      `json:"domain"`       // 查询域名
	QueryType    string      `json:"queryType"`    // 查询类型
	ResponseTime int64       `json:"responseTime"` // 响应时间(ms)
	Result       string      `json:"result"`       // 查询结果（allowed, blocked, error）
	BlockRule    string      `json:"blockRule"`    // 屏蔽规则（如果被屏蔽）
	BlockType    string      `json:"blockType"`    // 屏蔽类型（如果被屏蔽）
	FromCache    bool        `json:"fromCache"`    // 是否来自缓存
	DNSSEC       bool        `json:"dnssec"`       // 是否使用了DNSSEC
	EDNS         bool        `json:"edns"`         // 是否使用了EDNS
	DNSServer    string      `json:"dnsServer"`    // 使用的DNS服务器
	DNSSECServer string      `json:"dnssecServer"` // 使用的DNSSEC专用服务器
	Answers      []DNSAnswer `json:"answers"`      // 解析记录
	ResponseCode int         `json:"responseCode"` // DNS响应代码
}

// StatsData 用于持久化的统计数据结构
type StatsData struct {
	Stats           *Stats                    `json:"stats"`
	BlockedDomains  map[string]*BlockedDomain `json:"blockedDomains"`
	ResolvedDomains map[string]*BlockedDomain `json:"resolvedDomains"`
	ClientStats     map[string]*ClientStats   `json:"clientStats"`
	HourlyStats     map[string]int64          `json:"hourlyStats"`
	DailyStats      map[string]int64          `json:"dailyStats"`
	MonthlyStats    map[string]int64          `json:"monthlyStats"`
	LastSaved       time.Time                 `json:"lastSaved"`
}

// ServerStats 服务器统计信息
type ServerStats struct {
	SuccessCount    int64         // 成功查询次数
	FailureCount    int64         // 失败查询次数
	LastResponse    time.Time     // 最后响应时间
	ResponseTime    time.Duration // 平均响应时间
	ConnectionSpeed time.Duration // TCP连接速度
}

// Server DNS服务器
type Server struct {
	config               *config.DNSConfig
	shieldConfig         *config.ShieldConfig
	shieldManager        *shield.ShieldManager
	gfwConfig            *config.GFWListConfig
	gfwManager           *gfw.GFWListManager
	server               *dns.Server
	tcpServer            *dns.Server
	resolver             *dns.Client
	ctx                  context.Context
	cancel               context.CancelFunc
	statsMutex           sync.Mutex
	stats                *Stats
	blockedDomainsMutex  sync.RWMutex
	blockedDomains       map[string]*BlockedDomain
	resolvedDomainsMutex sync.RWMutex
	resolvedDomains      map[string]*BlockedDomain // 用于记录解析的域名
	clientStatsMutex     sync.RWMutex
	clientStats          map[string]*ClientStats // 用于记录客户端统计
	hourlyStatsMutex     sync.RWMutex
	hourlyStats          map[string]int64 // 按小时统计屏蔽数量
	dailyStatsMutex      sync.RWMutex
	dailyStats           map[string]int64 // 按天统计屏蔽数量
	monthlyStatsMutex    sync.RWMutex
	monthlyStats         map[string]int64 // 按月统计屏蔽数量
	queryLogsMutex       sync.RWMutex
	queryLogs            []QueryLog    // 查询日志列表
	maxQueryLogs         int           // 最大保存日志数量
	logChannel           chan QueryLog // 日志处理通道
	saveTicker           *time.Ticker  // 用于定时保存数据
	startTime            time.Time     // 服务器启动时间
	saveDone             chan struct{} // 用于通知保存协程停止
	stopped              bool          // 服务器是否已经停止
	stoppedMutex         sync.Mutex    // 保护stopped标志的互斥锁

	// DNS查询缓存
	DnsCache *DNSCache // DNS响应缓存

	// 域名DNSSEC状态映射表
	domainDNSSECStatus      map[string]bool // 域名到DNSSEC状态的映射
	domainDNSSECStatusMutex sync.RWMutex    // 保护域名DNSSEC状态映射的互斥锁

	// 上游服务器状态跟踪
	serverStats      map[string]*ServerStats // 服务器地址到状态的映射
	serverStatsMutex sync.RWMutex            // 保护服务器状态的互斥锁

	// DNSSEC专用服务器映射，用于快速查找
	dnssecServerMap map[string]bool // DNSSEC专用服务器地址到布尔值的映射

	// DNS客户端实例池，用于并行查询
	clientPool sync.Pool // 存储*dns.Client实例
}

// Stats DNS服务器统计信息
type Stats struct {
	Queries           int64
	Blocked           int64
	Allowed           int64
	Errors            int64
	LastQuery         time.Time
	AvgResponseTime   float64          // 平均响应时间(ms)
	TotalResponseTime int64            // 总响应时间
	QueryTypes        map[string]int64 // 查询类型统计
	SourceIPs         map[string]bool  // 活跃来源IP
	CpuUsage          float64          // CPU使用率(%)
	DNSSECQueries     int64            // DNSSEC查询总数
	DNSSECSuccess     int64            // DNSSEC验证成功数
	DNSSECFailed      int64            // DNSSEC验证失败数
	DNSSECEnabled     bool             // 是否启用了DNSSEC
}

// NewServer 创建DNS服务器实例
func NewServer(config *config.DNSConfig, shieldConfig *config.ShieldConfig, shieldManager *shield.ShieldManager, gfwConfig *config.GFWListConfig, gfwManager *gfw.GFWListManager) *Server {
	ctx, cancel := context.WithCancel(context.Background())

	// 从配置中读取DNS缓存TTL值（分钟）
	cacheTTL := time.Duration(config.CacheTTL) * time.Minute

	server := &Server{
		config:        config,
		shieldConfig:  shieldConfig,
		shieldManager: shieldManager,
		gfwConfig:     gfwConfig,
		gfwManager:    gfwManager,
		resolver: &dns.Client{
			Net:     "udp",
			UDPSize: 4096, // 增加UDP缓冲区大小，支持更大的DNSSEC响应
		},
		ctx:       ctx,
		cancel:    cancel,
		startTime: time.Now(), // 记录服务器启动时间
		stats: &Stats{
			Queries:           0,
			Blocked:           0,
			Allowed:           0,
			Errors:            0,
			AvgResponseTime:   0,
			TotalResponseTime: 0,
			QueryTypes:        make(map[string]int64),
			SourceIPs:         make(map[string]bool),
			CpuUsage:          0,
			DNSSECQueries:     0,
			DNSSECSuccess:     0,
			DNSSECFailed:      0,
			DNSSECEnabled:     config.EnableDNSSEC,
		},
		blockedDomains:  make(map[string]*BlockedDomain),
		resolvedDomains: make(map[string]*BlockedDomain),
		clientStats:     make(map[string]*ClientStats),
		hourlyStats:     make(map[string]int64),
		dailyStats:      make(map[string]int64),
		monthlyStats:    make(map[string]int64),
		queryLogs:       make([]QueryLog, 0, 1000), // 初始化查询日志切片，容量1000
		maxQueryLogs:    10000,                     // 最大保存10000条日志
		logChannel:      make(chan QueryLog, 1000), // 日志处理通道，缓冲区大小1000
		saveDone:        make(chan struct{}),
		stopped:         false, // 初始化为未停止状态

		// DNS查询缓存初始化
		DnsCache: NewDNSCache(cacheTTL),
		// 初始化域名DNSSEC状态映射表
		domainDNSSECStatus: make(map[string]bool),
		// 初始化服务器状态跟踪
		serverStats: make(map[string]*ServerStats),
		// 初始化DNSSEC专用服务器映射
		dnssecServerMap: make(map[string]bool),
		// 初始化DNS客户端实例池
		clientPool: sync.Pool{
			New: func() interface{} {
				return &dns.Client{
					Net:     "udp",
					UDPSize: 4096,
					Timeout: 5 * time.Second, // 默认超时时间，会在使用时覆盖
				}
			},
		},
	}

	// 加载已保存的统计数据
	server.loadStatsData()

	return server

}

// Start 启动DNS服务器
func (s *Server) Start() error {
	// 重新初始化上下文和取消函数
	ctx, cancel := context.WithCancel(context.Background())
	s.ctx = ctx
	s.cancel = cancel

	// 重新初始化saveDone通道
	s.saveDone = make(chan struct{})

	// 重置stopped标志
	s.stoppedMutex.Lock()
	s.stopped = false
	s.stoppedMutex.Unlock()

	// 更新服务器启动时间
	s.startTime = time.Now()

	s.server = &dns.Server{
		Addr:    fmt.Sprintf("0.0.0.0:%d", s.config.Port),
		Net:     "udp",
		Handler: dns.HandlerFunc(s.handleDNSRequest),
	}

	// 保存TCP服务器实例，以便在Stop方法中关闭
	s.tcpServer = &dns.Server{
		Addr:    fmt.Sprintf("0.0.0.0:%d", s.config.Port),
		Net:     "tcp",
		Handler: dns.HandlerFunc(s.handleDNSRequest),
	}

	// 启动CPU使用率监控
	go s.startCpuUsageMonitor()

	// 启动自动保存功能
	go s.startAutoSave()

	// 更新DNSSEC专用服务器映射
	s.updateDNSSECServerMap()

	// 启动日志处理协程
	go s.processLogs()

	// 启动统计数据定期重置功能（每24小时）
	go func() {
		ticker := time.NewTicker(24 * time.Hour)
		defer ticker.Stop()
		for {
			select {
			case <-ticker.C:
				s.resetStats()
			case <-s.ctx.Done():
				return
			}
		}
	}()

	// 启动UDP服务
	go func() {
		logger.Info(fmt.Sprintf("DNS UDP服务器启动，监听端口: %d", s.config.Port))
		if err := s.server.ListenAndServe(); err != nil {
			logger.Error("DNS UDP服务器启动失败", "error", err)
			s.cancel()
		}
	}()

	// 启动TCP服务
	go func() {
		logger.Info(fmt.Sprintf("DNS TCP服务器启动，监听端口: %d", s.config.Port))
		if err := s.tcpServer.ListenAndServe(); err != nil {
			logger.Error("DNS TCP服务器启动失败", "error", err)
			s.cancel()
		}
	}()

	// 等待停止信号
	<-s.ctx.Done()
	return nil
}

// resetStats 重置统计数据
func (s *Server) resetStats() {
	s.statsMutex.Lock()
	defer s.statsMutex.Unlock()

	// 只重置累计值，保留配置相关值
	s.stats.TotalResponseTime = 0
	s.stats.AvgResponseTime = 0
	s.stats.Queries = 0
	s.stats.Blocked = 0
	s.stats.Allowed = 0
	s.stats.Errors = 0
	s.stats.DNSSECQueries = 0
	s.stats.DNSSECSuccess = 0
	s.stats.DNSSECFailed = 0
	s.stats.QueryTypes = make(map[string]int64)
	s.stats.SourceIPs = make(map[string]bool)

	logger.Info("统计数据已重置")
}

// Stop 停止DNS服务器
func (s *Server) Stop() {
	// 检查服务器是否已经停止
	s.stoppedMutex.Lock()
	if s.stopped {
		s.stoppedMutex.Unlock()
		return // 服务器已经停止，直接返回
	}
	// 标记服务器为已停止状态
	s.stopped = true
	s.stoppedMutex.Unlock()

	// 发送停止信号给保存协程
	close(s.saveDone)

	// 最后保存一次数据
	s.saveStatsData()

	// 停止服务器
	s.cancel()
	if s.server != nil {
		s.server.Shutdown()
	}
	if s.tcpServer != nil {
		s.tcpServer.Shutdown()
	}
	logger.Info("DNS服务器已停止")
}

// handleDNSRequest 处理DNS请求
func (s *Server) handleDNSRequest(w dns.ResponseWriter, r *dns.Msg) {
	startTime := time.Now()

	// 获取来源IP
	sourceIP := w.RemoteAddr().String()
	// 提取IP地址部分，去掉端口
	if strings.HasPrefix(sourceIP, "[") {
		// IPv6地址格式: [::1]:53
		if idx := strings.Index(sourceIP, "]"); idx >= 0 {
			sourceIP = sourceIP[1:idx] // 去掉方括号
		}
	} else {
		// IPv4地址格式: 127.0.0.1:53
		if idx := strings.LastIndex(sourceIP, ":"); idx >= 0 {
			sourceIP = sourceIP[:idx]
		}
	}

	// 更新来源IP统计和Queries计数器
	s.updateStats(func(stats *Stats) {
		stats.Queries++
		stats.LastQuery = time.Now()
		stats.SourceIPs[sourceIP] = true
	})

	// 更新客户端统计
	s.updateClientStats(sourceIP)

	// 获取查询域名和类型
	var domain string
	var queryType string
	var qType uint16
	if len(r.Question) > 0 {
		domain = r.Question[0].Name
		// 移除末尾的点
		if len(domain) > 0 && domain[len(domain)-1] == '.' {
			domain = domain[:len(domain)-1]
		}
		// 获取查询类型
		queryType = dns.TypeToString[r.Question[0].Qtype]
		qType = r.Question[0].Qtype
		// 更新查询类型统计
		s.updateStats(func(stats *Stats) {
			stats.QueryTypes[queryType]++
		})

		// 检查是否是AAAA记录查询且IPv6解析已禁用
		if qType == dns.TypeAAAA && !s.config.EnableIPv6 {
			// 返回NXDOMAIN响应（域名不存在）
			response := new(dns.Msg)
			response.SetReply(r)
			response.SetRcode(r, dns.RcodeNameError)
			w.WriteMsg(response)

			// 更新统计信息
			responseTime := time.Since(startTime).Milliseconds()
			s.updateStats(func(stats *Stats) {
				stats.TotalResponseTime += responseTime
				// 添加防御性编程，确保Queries大于0
				if stats.Queries > 0 {
					// 平均响应时间 = 总响应时间 / 总解析数量，四舍五入取整
					avg := float64(stats.TotalResponseTime) / float64(stats.Queries)
					stats.AvgResponseTime = float64(math.Round(avg))
					// 限制平均响应时间的范围，避免显示异常大的值
					if stats.AvgResponseTime > 60000 {
						stats.AvgResponseTime = 60000
					}
				}
			})

			// 添加查询日志
			s.addQueryLog(sourceIP, domain, queryType, responseTime, "error", "", "", false, false, true, "", "", nil, dns.RcodeNameError)
			logger.Debug("IPv6解析已禁用，拒绝AAAA记录查询", "domain", domain)
			return
		}
	}

	logger.Debug("接收到DNS查询", "domain", domain, "type", queryType, "client", w.RemoteAddr())

	// 只处理递归查询
	if r.RecursionDesired == false {
		response := new(dns.Msg)
		response.SetReply(r)
		// 不再硬编码RecursionAvailable，使用默认值或上游返回的值
		response.SetRcode(r, dns.RcodeRefused)
		w.WriteMsg(response)

		// 计算实际响应时间
		responseTime := time.Since(startTime).Milliseconds()
		s.updateStats(func(stats *Stats) {
			stats.TotalResponseTime += responseTime
			if stats.Queries > 0 {
				// 平均响应时间 = 总响应时间 / 总解析数量，四舍五入取整
				avg := float64(stats.TotalResponseTime) / float64(stats.Queries)
				stats.AvgResponseTime = float64(math.Round(avg))
			}
		})

		// 添加查询日志
		s.addQueryLog(sourceIP, domain, queryType, responseTime, "error", "", "", false, false, true, "", "", nil, dns.RcodeRefused)
		return
	}

	// 检查hosts文件是否有匹配
	if ip, exists := s.shieldManager.GetHostsIP(domain); exists {
		s.handleHostsResponse(w, r, ip)
		// 计算实际响应时间
		responseTime := time.Since(startTime).Milliseconds()
		s.updateStats(func(stats *Stats) {
			stats.TotalResponseTime += responseTime
			if stats.Queries > 0 {
				// 平均响应时间 = 总响应时间 / 总解析数量，四舍五入取整
				avg := float64(stats.TotalResponseTime) / float64(stats.Queries)
				stats.AvgResponseTime = float64(math.Round(avg))
			}
		})

		// 该方法内部未直接调用addQueryLog，而是在handleDNSRequest中处理
		return
	}

	// 检查是否为GFWList域名（仅当GFWList功能启用时）
	if s.gfwConfig.Enabled && s.gfwManager != nil && s.gfwManager.IsMatch(domain) {
		s.handleGFWListResponse(w, r, domain)
		// 计算响应时间
		responseTime := time.Since(startTime).Milliseconds()
		s.updateStats(func(stats *Stats) {
			stats.TotalResponseTime += responseTime
			if stats.Queries > 0 {
				// 平均响应时间 = 总响应时间 / 总解析数量，四舍五入取整
				avg := float64(stats.TotalResponseTime) / float64(stats.Queries)
				stats.AvgResponseTime = float64(math.Round(avg))
			}
		})

		// 添加查询日志 - GFWList域名
		gfwAnswers := []DNSAnswer{}
		s.addQueryLog(sourceIP, domain, queryType, responseTime, "gfwlist", "", "", false, false, true, "GFWList", "无", gfwAnswers, dns.RcodeSuccess)
		return
	}

	// 检查是否被屏蔽
	if s.shieldManager.IsBlocked(domain) {
		// 获取屏蔽详情
		blockDetails := s.shieldManager.CheckDomainBlockDetails(domain)
		blockRule, _ := blockDetails["blockRule"].(string)
		blockType, _ := blockDetails["blockRuleType"].(string)

		s.handleBlockedResponse(w, r, domain)
		// 计算响应时间
		responseTime := time.Since(startTime).Milliseconds()
		s.updateStats(func(stats *Stats) {
			stats.TotalResponseTime += responseTime
			if stats.Queries > 0 {
				// 平均响应时间 = 总响应时间 / 总解析数量，四舍五入取整
				avg := float64(stats.TotalResponseTime) / float64(stats.Queries)
				stats.AvgResponseTime = float64(math.Round(avg))
			}
		})

		// 添加查询日志 - 被屏蔽域名
		blockedAnswers := []DNSAnswer{}
		// 根据屏蔽方法确定响应代码
		blockedRcode := dns.RcodeNameError // 默认NXDOMAIN
		if blockMethod := s.shieldConfig.BlockMethod; blockMethod == "refused" {
			blockedRcode = dns.RcodeRefused
		} else if blockMethod == "emptyIP" || blockMethod == "customIP" {
			blockedRcode = dns.RcodeSuccess
		}
		s.addQueryLog(sourceIP, domain, queryType, responseTime, "blocked", blockRule, blockType, false, false, true, "无", "无", blockedAnswers, blockedRcode)
		return
	}

	// 检查缓存中是否有响应（优先查找带DNSSEC的缓存项）
	var cachedResponse *dns.Msg
	var found bool
	var cachedDNSSEC bool

	// 1. 首先检查是否有普通缓存项
	if tempResponse, tempFound := s.DnsCache.Get(r.Question[0].Name, qType); tempFound {
		cachedResponse = tempResponse
		found = tempFound
		cachedDNSSEC = s.hasDNSSECRecords(tempResponse)
	}

	// 2. 如果启用了DNSSEC且没有找到带DNSSEC的缓存项，
	// 尝试从所有缓存中查找是否有其他响应包含DNSSEC记录
	// （这里可以进一步优化，比如在缓存中标记DNSSEC状态，快速查找）
	if s.config.EnableDNSSEC && !cachedDNSSEC {
		// 目前的缓存实现不支持按DNSSEC状态查找，所以这里暂时跳过
		// 后续可以考虑改进缓存实现，添加DNSSEC状态标记
	}

	if found {
		// 缓存命中，直接返回缓存的响应
		cachedResponseCopy := cachedResponse.Copy() // 创建响应副本避免并发修改问题
		cachedResponseCopy.Id = r.Id                // 更新ID以匹配请求
		cachedResponseCopy.Compress = true

		// 如果客户端请求包含EDNS记录，确保响应也包含EDNS
		if opt := r.IsEdns0(); opt != nil {
			// 检查响应是否已经包含EDNS记录
			if respOpt := cachedResponseCopy.IsEdns0(); respOpt == nil {
				// 添加EDNS记录，使用客户端的UDP缓冲区大小
				cachedResponseCopy.SetEdns0(opt.UDPSize(), s.config.EnableDNSSEC)
			} else {
				// 确保响应的UDP缓冲区大小不超过客户端请求的大小
				if respOpt.UDPSize() > opt.UDPSize() {
					// 移除现有的EDNS记录
					for i := range cachedResponseCopy.Extra {
						if cachedResponseCopy.Extra[i] == respOpt {
							cachedResponseCopy.Extra = append(cachedResponseCopy.Extra[:i], cachedResponseCopy.Extra[i+1:]...)
							break
						}
					}
					// 添加新的EDNS记录，使用客户端的UDP缓冲区大小
					cachedResponseCopy.SetEdns0(opt.UDPSize(), s.config.EnableDNSSEC)
				}
			}
		}

		w.WriteMsg(cachedResponseCopy)

		// 计算响应时间
		responseTime := time.Since(startTime).Milliseconds()
		s.updateStats(func(stats *Stats) {
			stats.TotalResponseTime += responseTime
			if stats.Queries > 0 {
				// 平均响应时间 = 总响应时间 / 总解析数量，四舍五入取整
				avg := float64(stats.TotalResponseTime) / float64(stats.Queries)
				stats.AvgResponseTime = float64(math.Round(avg))
			}
		})

		// 如果缓存响应包含DNSSEC记录，更新DNSSEC查询计数
		if cachedDNSSEC {
			s.updateStats(func(stats *Stats) {
				stats.DNSSECQueries++
				// 缓存响应视为DNSSEC成功
				stats.DNSSECSuccess++
			})
		}

		// 从缓存响应中提取解析记录
		cachedAnswers := []DNSAnswer{}
		if cachedResponse != nil {
			for _, rr := range cachedResponse.Answer {
				cachedAnswers = append(cachedAnswers, DNSAnswer{
					Type:  dns.TypeToString[rr.Header().Rrtype],
					Value: rr.String(),
					TTL:   rr.Header().Ttl,
				})
			}
		}

		// 添加查询日志 - 标记为缓存
		// 从缓存响应中获取响应代码
		cacheRcode := dns.RcodeSuccess // 默认成功
		if cachedResponse != nil {
			cacheRcode = cachedResponse.Rcode
		}
		s.addQueryLog(sourceIP, domain, queryType, responseTime, "allowed", "", "", true, cachedDNSSEC, true, "缓存", "无", cachedAnswers, cacheRcode)
		logger.Debug("从缓存返回DNS响应", "domain", domain, "type", queryType, "dnssec", cachedDNSSEC)
		return
	}

	// 缓存未命中，处理DNS请求
	var response *dns.Msg
	var rtt time.Duration
	var queryAttempts []string
	var dnsServer string
	var dnssecServer string

	// 直接查询原始域名
	queryAttempts = append(queryAttempts, domain)
	response, rtt, dnsServer, dnssecServer = s.forwardDNSRequestWithCache(r, domain)

	if response != nil {
		// 如果客户端请求包含EDNS记录，确保响应也包含EDNS
		if opt := r.IsEdns0(); opt != nil {
			// 检查响应是否已经包含EDNS记录
			if respOpt := response.IsEdns0(); respOpt == nil {
				// 添加EDNS记录，使用客户端的UDP缓冲区大小
				response.SetEdns0(opt.UDPSize(), s.config.EnableDNSSEC)
			} else {
				// 确保响应的UDP缓冲区大小不超过客户端请求的大小
				if respOpt.UDPSize() > opt.UDPSize() {
					// 移除现有的EDNS记录
					for i := range response.Extra {
						if response.Extra[i] == respOpt {
							response.Extra = append(response.Extra[:i], response.Extra[i+1:]...)
							break
						}
					}
					// 添加新的EDNS记录，使用客户端的UDP缓冲区大小
					response.SetEdns0(opt.UDPSize(), s.config.EnableDNSSEC)
				}
			}
		}

		// 写入响应给客户端
		w.WriteMsg(response)
	}

	// 使用上游服务器的实际响应时间（转换为毫秒）
	responseTime := int64(rtt.Milliseconds())
	// 如果rtt为0（查询失败），则使用本地计算的时间
	if responseTime == 0 {
		responseTime = time.Since(startTime).Milliseconds()
	}

	// 添加合理性检查，避免异常大的响应时间影响统计
	if responseTime > 60000 { // 超过60秒的响应时间视为异常
		responseTime = 60000
	}

	s.updateStats(func(stats *Stats) {
		stats.TotalResponseTime += responseTime
		// 添加防御性编程，确保Queries大于0
		if stats.Queries > 0 {
			// 平均响应时间 = 总响应时间 / 总解析数量，四舍五入取整
			avg := float64(stats.TotalResponseTime) / float64(stats.Queries)
			stats.AvgResponseTime = float64(math.Round(avg))
			// 限制平均响应时间的范围，避免显示异常大的值
			if stats.AvgResponseTime > 60000 {
				stats.AvgResponseTime = 60000
			}
		}
	})

	// 检查响应是否包含DNSSEC记录并验证结果
	responseDNSSEC := false
	if response != nil {
		// 使用hasDNSSECRecords函数检查是否包含DNSSEC记录
		responseDNSSEC = s.hasDNSSECRecords(response)

		// 检查AD标志，确认DNSSEC验证是否成功
		if response.AuthenticatedData {
			responseDNSSEC = true
		}

		// 更新域名的DNSSEC状态
		if responseDNSSEC {
			s.updateDomainDNSSECStatus(domain, true)
		}
	}

	// 如果响应成功，缓存结果（增强版缓存存储）
	if response != nil && response.Rcode == dns.RcodeSuccess {
		// 创建响应副本以避免后续修改影响缓存
		responseCopy := response.Copy()
		// 设置合理的TTL，不超过默认的30分钟
		defaultCacheTTL := 30 * time.Minute
		s.DnsCache.Set(r.Question[0].Name, qType, responseCopy, defaultCacheTTL)
		logger.Debug("DNS响应已缓存", "domain", domain, "type", queryType, "ttl", defaultCacheTTL, "dnssec", responseDNSSEC)
	}

	// 从响应中提取解析记录
	responseAnswers := []DNSAnswer{}
	if response != nil {
		for _, rr := range response.Answer {
			responseAnswers = append(responseAnswers, DNSAnswer{
				Type:  dns.TypeToString[rr.Header().Rrtype],
				Value: rr.String(),
				TTL:   rr.Header().Ttl,
			})
		}
	}

	// 添加查询日志 - 标记为实时
	// 从响应中获取响应代码
	realRcode := dns.RcodeSuccess // 默认成功
	if response != nil {
		realRcode = response.Rcode
	}
	s.addQueryLog(sourceIP, domain, queryType, responseTime, "allowed", "", "", false, responseDNSSEC, true, dnsServer, dnssecServer, responseAnswers, realRcode)
}

// handleHostsResponse 处理hosts文件匹配的响应
func (s *Server) handleHostsResponse(w dns.ResponseWriter, r *dns.Msg, ip string) {
	response := new(dns.Msg)
	response.SetReply(r)
	// 不再硬编码RecursionAvailable，使用默认值或上游返回的值

	if len(r.Question) > 0 {
		q := r.Question[0]
		answer := new(dns.A)
		answer.Hdr = dns.RR_Header{
			Name:   q.Name,
			Rrtype: dns.TypeA,
			Class:  dns.ClassINET,
			Ttl:    300,
		}
		answer.A = net.ParseIP(ip)
		response.Answer = append(response.Answer, answer)
	}

	// 记录解析域名统计
	domain := ""
	if len(r.Question) > 0 {
		domain = r.Question[0].Name
		if len(domain) > 0 && domain[len(domain)-1] == '.' {
			domain = domain[:len(domain)-1]
		}
		s.updateResolvedDomainStats(domain)
	}

	w.WriteMsg(response)
	s.updateStats(func(stats *Stats) {
		stats.Allowed++
	})
}

// handleGFWListResponse 处理GFWList域名响应
func (s *Server) handleGFWListResponse(w dns.ResponseWriter, r *dns.Msg, domain string) {
	logger.Info("GFWList域名解析", "domain", domain, "client", w.RemoteAddr(), "ip", s.gfwConfig.IP)

	// 更新解析域名统计
	s.updateResolvedDomainStats(domain)

	response := new(dns.Msg)
	response.SetReply(r)

	if len(r.Question) > 0 {
		q := r.Question[0]
		answer := new(dns.A)
		answer.Hdr = dns.RR_Header{
			Name:   q.Name,
			Rrtype: dns.TypeA,
			Class:  dns.ClassINET,
			Ttl:    300,
		}
		answer.A = net.ParseIP(s.gfwConfig.IP)
		response.Answer = append(response.Answer, answer)
	}

	w.WriteMsg(response)
	s.updateStats(func(stats *Stats) {
		stats.Allowed++
	})
}

// handleBlockedResponse 处理被屏蔽的域名响应
func (s *Server) handleBlockedResponse(w dns.ResponseWriter, r *dns.Msg, domain string) {
	logger.Info("域名被屏蔽", "domain", domain, "client", w.RemoteAddr())

	// 更新被屏蔽域名统计
	s.updateBlockedDomainStats(domain)

	response := new(dns.Msg)
	response.SetReply(r)
	// 不再硬编码RecursionAvailable，使用默认值或上游返回的值

	// 获取屏蔽方法配置
	blockMethod := "NXDOMAIN" // 默认值
	customBlockIP := ""       // 默认值

	// 从Server结构体的shieldConfig字段获取配置
	if s.shieldConfig != nil {
		blockMethod = s.shieldConfig.BlockMethod
		customBlockIP = s.shieldConfig.CustomBlockIP
	}

	// 根据屏蔽方法返回不同的响应
	switch blockMethod {
	case "refused":
		// 返回拒绝查询响应
		response.SetRcode(r, dns.RcodeRefused)
	case "emptyIP":
		// 返回空IP响应
		if len(r.Question) > 0 && r.Question[0].Qtype == dns.TypeA {
			answer := new(dns.A)
			answer.Hdr = dns.RR_Header{
				Name:   r.Question[0].Name,
				Rrtype: dns.TypeA,
				Class:  dns.ClassINET,
				Ttl:    300,
			}
			answer.A = net.ParseIP("0.0.0.0") // 空IP
			response.Answer = append(response.Answer, answer)
		}
	case "customIP":
		// 返回自定义IP响应
		if len(r.Question) > 0 && r.Question[0].Qtype == dns.TypeA {
			answer := new(dns.A)
			answer.Hdr = dns.RR_Header{
				Name:   r.Question[0].Name,
				Rrtype: dns.TypeA,
				Class:  dns.ClassINET,
				Ttl:    300,
			}
			// 使用自定义屏蔽IP
			if customBlockIP != "" {
				answer.A = net.ParseIP(customBlockIP)
			} else {
				// 如果没有配置，使用0.0.0.0
				answer.A = net.ParseIP("0.0.0.0")
			}
			response.Answer = append(response.Answer, answer)
		}
	case "NXDOMAIN", "":
		fallthrough // 默认使用NXDOMAIN
	default:
		// 返回NXDOMAIN响应（域名不存在）
		response.SetRcode(r, dns.RcodeNameError)
	}

	w.WriteMsg(response)
	s.updateStats(func(stats *Stats) {
		stats.Blocked++
	})
}

// forwardDNSRequest 转发DNS请求到上游服务器
// serverResponse 用于存储服务器响应的结构体
type serverResponse struct {
	response *dns.Msg
	rtt      time.Duration
	server   string
	error    error
}

// recordKey 用于唯一标识DNS记录的结构体
type recordKey struct {
	name  string
	rtype uint16
	class uint16
	data  string
}

// getRecordKey 获取DNS记录的唯一标识
func getRecordKey(rr dns.RR) recordKey {
	// 对于同一域名的同一类型记录，只保留一个，选择最长TTL
	// 所以对于A、AAAA、CNAME等记录，只使用name、rtype、class作为键
	// 对于MX记录，还需要考虑Preference字段
	// 对于TXT记录，需要考虑实际文本内容
	// 对于NS记录，需要考虑目标服务器

	switch rr.Header().Rrtype {
	case dns.TypeA, dns.TypeAAAA, dns.TypeCNAME, dns.TypePTR:
		// 对于A、AAAA、CNAME、PTR记录，同一域名只保留一个
		return recordKey{
			name:  rr.Header().Name,
			rtype: rr.Header().Rrtype,
			class: rr.Header().Class,
			data:  "",
		}
	case dns.TypeMX:
		// 对于MX记录，同一域名的同一Preference只保留一个
		if mx, ok := rr.(*dns.MX); ok {
			return recordKey{
				name:  rr.Header().Name,
				rtype: rr.Header().Rrtype,
				class: rr.Header().Class,
				data:  fmt.Sprintf("%d", mx.Preference),
			}
		}
	case dns.TypeTXT:
		// 对于TXT记录，需要考虑实际文本内容
		if txt, ok := rr.(*dns.TXT); ok {
			return recordKey{
				name:  rr.Header().Name,
				rtype: rr.Header().Rrtype,
				class: rr.Header().Class,
				data:  strings.Join(txt.Txt, " "),
			}
		}
	case dns.TypeNS:
		// 对于NS记录，需要考虑目标服务器
		if ns, ok := rr.(*dns.NS); ok {
			return recordKey{
				name:  rr.Header().Name,
				rtype: rr.Header().Rrtype,
				class: rr.Header().Class,
				data:  ns.Ns,
			}
		}
	case dns.TypeSOA:
		// 对于SOA记录，同一域名只保留一个
		return recordKey{
			name:  rr.Header().Name,
			rtype: rr.Header().Rrtype,
			class: rr.Header().Class,
			data:  "",
		}
	}

	// 对于其他类型，使用原始rr.String()，但移除TTL部分
	parts := strings.Split(rr.String(), " ")
	if len(parts) >= 5 {
		// 跳过TTL字段（第3个字段）
		data := strings.Join(append(parts[:2], parts[3:]...), " ")
		return recordKey{
			name:  rr.Header().Name,
			rtype: rr.Header().Rrtype,
			class: rr.Header().Class,
			data:  data,
		}
	}

	return recordKey{
		name:  rr.Header().Name,
		rtype: rr.Header().Rrtype,
		class: rr.Header().Class,
		data:  rr.String(),
	}
}

// mergeResponses 合并多个DNS响应
func mergeResponses(responses []*dns.Msg) *dns.Msg {
	if len(responses) == 0 {
		return nil
	}

	// 如果只有一个响应，直接返回，避免不必要的合并操作
	if len(responses) == 1 {
		return responses[0].Copy()
	}

	// 使用第一个响应作为基础
	mergedResponse := responses[0].Copy()
	mergedResponse.Answer = []dns.RR{}
	mergedResponse.Ns = []dns.RR{}
	mergedResponse.Extra = []dns.RR{}

	// 重置Rcode为成功，除非所有响应都是NXDOMAIN
	mergedResponse.Rcode = dns.RcodeSuccess

	// 检查是否所有响应都是NXDOMAIN
	allNXDOMAIN := true

	// 收集所有成功响应的记录
	for _, resp := range responses {
		if resp == nil {
			continue
		}

		// 如果有任何响应是成功的，就不是allNXDOMAIN
		if resp.Rcode == dns.RcodeSuccess {
			allNXDOMAIN = false
		}
	}

	// 如果所有响应都是NXDOMAIN，设置合并响应为NXDOMAIN
	if allNXDOMAIN {
		mergedResponse.Rcode = dns.RcodeNameError
	}

	// 使用map存储唯一记录，选择最长TTL
	// 预分配map容量，减少扩容开销
	answerMap := make(map[recordKey]dns.RR, len(responses[0].Answer)*len(responses))
	nsMap := make(map[recordKey]dns.RR, len(responses[0].Ns)*len(responses))
	extraMap := make(map[recordKey]dns.RR, len(responses[0].Extra)*len(responses))

	for _, resp := range responses {
		if resp == nil {
			continue
		}

		// 只合并与最终Rcode匹配的响应记录
		if (mergedResponse.Rcode == dns.RcodeSuccess && resp.Rcode == dns.RcodeSuccess) ||
			(mergedResponse.Rcode == dns.RcodeNameError && resp.Rcode == dns.RcodeNameError) {

			// 合并Answer部分
			for _, rr := range resp.Answer {
				key := getRecordKey(rr)
				if existing, exists := answerMap[key]; exists {
					// 如果存在相同记录，选择TTL更长的
					if rr.Header().Ttl > existing.Header().Ttl {
						answerMap[key] = rr
					}
				} else {
					answerMap[key] = rr
				}
			}

			// 合并Ns部分
			for _, rr := range resp.Ns {
				key := getRecordKey(rr)
				if existing, exists := nsMap[key]; exists {
					// 如果存在相同记录，选择TTL更长的
					if rr.Header().Ttl > existing.Header().Ttl {
						nsMap[key] = rr
					}
				} else {
					nsMap[key] = rr
				}
			}

			// 合并Extra部分
			for _, rr := range resp.Extra {
				// 跳过OPT记录，避免重复
				if rr.Header().Rrtype == dns.TypeOPT {
					continue
				}
				key := getRecordKey(rr)
				if existing, exists := extraMap[key]; exists {
					// 如果存在相同记录，选择TTL更长的
					if rr.Header().Ttl > existing.Header().Ttl {
						extraMap[key] = rr
					}
				} else {
					extraMap[key] = rr
				}
			}
		}
	}

	// 预分配切片容量，减少扩容开销
	mergedResponse.Answer = make([]dns.RR, 0, len(answerMap))
	mergedResponse.Ns = make([]dns.RR, 0, len(nsMap))
	mergedResponse.Extra = make([]dns.RR, 0, len(extraMap))

	// 将map转换回切片
	for _, rr := range answerMap {
		mergedResponse.Answer = append(mergedResponse.Answer, rr)
	}

	for _, rr := range nsMap {
		mergedResponse.Ns = append(mergedResponse.Ns, rr)
	}

	for _, rr := range extraMap {
		mergedResponse.Extra = append(mergedResponse.Extra, rr)
	}

	return mergedResponse
}

// updateDNSSECServerMap 更新DNSSEC专用服务器映射，用于快速查找
func (s *Server) updateDNSSECServerMap() {
	// 清空现有映射
	for k := range s.dnssecServerMap {
		delete(s.dnssecServerMap, k)
	}

	// 添加所有DNSSEC专用服务器到映射
	for _, server := range s.config.DNSSECUpstreamDNS {
		s.dnssecServerMap[server] = true
	}
}

// forwardDNSRequestWithCache 转发DNS请求到上游服务器并返回响应
func (s *Server) forwardDNSRequestWithCache(r *dns.Msg, domain string) (*dns.Msg, time.Duration, string, string) {
	// 始终支持EDNS
	var udpSize uint16 = 4096
	var doFlag bool = s.config.EnableDNSSEC

	// 检查域名是否匹配不验证DNSSEC的模式
	noDNSSEC := false
	for _, pattern := range s.config.NoDNSSECDomains {
		if strings.Contains(domain, pattern) {
			noDNSSEC = true
			doFlag = false
			logger.Debug("域名匹配到不验证DNSSEC的模式", "domain", domain, "pattern", pattern)
			break
		}
	}

	// 检查客户端请求是否包含EDNS记录
	if opt := r.IsEdns0(); opt != nil {
		// 保留客户端的UDP缓冲区大小
		udpSize = opt.UDPSize()
		// 移除现有的EDNS记录，以便重新添加
		for i := range r.Extra {
			if r.Extra[i] == opt {
				r.Extra = append(r.Extra[:i], r.Extra[i+1:]...)
				break
			}
		}
	}

	// 添加EDNS记录，设置适当的UDPSize和DO标志
	r.SetEdns0(udpSize, doFlag)

	// DNSSEC专用服务器列表，从配置中获取
	dnssecServers := s.config.DNSSECUpstreamDNS

	// 选择合适的上游DNS服务器列表
	// 1. 首先检查是否有域名特定的DNS服务器配置
	var selectedUpstreamDNS []string
	var domainMatched bool

	for matchStr, dnsServers := range s.config.DomainSpecificDNS {
		if strings.Contains(domain, matchStr) {
			selectedUpstreamDNS = dnsServers
			domainMatched = true
			logger.Debug("域名匹配到特定DNS服务器配置", "domain", domain, "matchStr", matchStr, "dnsServers", dnsServers)
			break
		}
	}

	// 2. 如果没有匹配的域名特定配置
	if !domainMatched {
		// 创建一个新的切片来存储最终的上游服务器列表
		var finalUpstreamDNS []string

		// 首先添加用户配置的上游DNS服务器
		finalUpstreamDNS = append(finalUpstreamDNS, s.config.UpstreamDNS...)
		logger.Debug("使用用户配置的上游DNS服务器", "servers", finalUpstreamDNS)

		// 如果启用了DNSSEC且有配置DNSSEC专用服务器，并且域名不匹配NoDNSSECDomains，则将DNSSEC专用服务器添加到列表中
		if s.config.EnableDNSSEC && len(s.config.DNSSECUpstreamDNS) > 0 && !noDNSSEC {
			// 合并DNSSEC专用服务器到上游服务器列表，避免重复，并确保包含端口号
			for _, dnssecServer := range s.config.DNSSECUpstreamDNS {
				hasDuplicate := false
				// 确保DNSSEC服务器地址包含端口号
				normalizedDnssecServer := normalizeDNSServerAddress(dnssecServer)
				for _, upstream := range finalUpstreamDNS {
					if upstream == normalizedDnssecServer {
						hasDuplicate = true
						break
					}
				}
				if !hasDuplicate {
					finalUpstreamDNS = append(finalUpstreamDNS, normalizedDnssecServer)
				}
			}
			logger.Debug("合并DNSSEC专用服务器到上游服务器列表", "servers", finalUpstreamDNS)
		}

		// 使用最终合并后的服务器列表
		selectedUpstreamDNS = finalUpstreamDNS
	}

	// 1. 首先尝试所有配置的上游DNS服务器
	var bestResponse *dns.Msg
	var bestRtt time.Duration
	var hasBestResponse bool
	var hasDNSSECResponse bool
	var backupResponse *dns.Msg
	var backupRtt time.Duration
	var hasBackup bool
	var usedDNSServer string
	var usedDNSSECServer string

	// 使用配置中的超时时间
	defaultTimeout := time.Duration(s.config.QueryTimeout) * time.Millisecond

	// 根据查询模式处理请求
	switch s.config.QueryMode {
	case "parallel":
		// 并行请求模式 - 收集所有响应并合并
		responses := make(chan serverResponse, len(selectedUpstreamDNS))
		var wg sync.WaitGroup

		// 向所有上游服务器并行发送请求，每个请求带有超时
		for _, upstream := range selectedUpstreamDNS {
			wg.Add(1)
			go func(server string) {
				defer wg.Done()

				// 从池中获取客户端实例
				client := s.clientPool.Get().(*dns.Client)
				// 设置客户端参数
				client.Net = s.resolver.Net
				client.UDPSize = s.resolver.UDPSize
				client.Timeout = defaultTimeout

				// 发送请求并获取响应，确保服务器地址包含端口号
				response, rtt, err := client.Exchange(r, normalizeDNSServerAddress(server))
				responses <- serverResponse{response, rtt, server, err}

				// 将客户端实例放回池中
				s.clientPool.Put(client)
			}(upstream)
		}

		// 等待所有请求完成或超时
		go func() {
			wg.Wait()
			close(responses)
		}()

		// 收集成功响应和NXDOMAIN响应分开
		var successResponses []*dns.Msg
		var nxdomainResponses []*dns.Msg
		var totalRtt time.Duration
		var responseCount int

		// 处理所有响应
		for resp := range responses {
			if resp.error == nil && resp.response != nil {
				// 更新服务器统计信息
				s.updateServerStats(resp.server, true, resp.rtt)

				// 检查是否包含DNSSEC记录
				containsDNSSEC := s.hasDNSSECRecords(resp.response)

				// 对于不验证DNSSEC的域名，始终设置AD标志为false
				if noDNSSEC {
					resp.response.AuthenticatedData = false
				}

				// 只对将要返回的响应进行DNSSEC验证，减少开销
				// 这里只设置containsDNSSEC标志，实际验证在确定返回响应后进行
				if containsDNSSEC && s.config.EnableDNSSEC && !noDNSSEC {
					// 暂时不验证，只标记
				}

				// 检查当前服务器是否是DNSSEC专用服务器（O(1)查找）
				if _, isDNSSECServer := s.dnssecServerMap[resp.server]; isDNSSECServer {
					usedDNSSECServer = resp.server
				}

				// 收集响应，按Rcode分类
				if resp.response.Rcode == dns.RcodeSuccess {
					successResponses = append(successResponses, resp.response)
					totalRtt += resp.rtt
					responseCount++

					// 记录使用的服务器
					if usedDNSServer == "" {
						usedDNSServer = resp.server
					}
				} else if resp.response.Rcode == dns.RcodeNameError {
					nxdomainResponses = append(nxdomainResponses, resp.response)
				} else {
					// 更新备选响应，确保总有一个可用的响应
					if resp.response != nil {
						if !hasBackup {
							// 第一次保存备选响应
							backupResponse = resp.response
							backupRtt = resp.rtt
							hasBackup = true
						}
					}
				}
			} else {
				// 更新服务器统计信息（失败）
				s.updateServerStats(resp.server, false, 0)
			}
		}

		// 合并响应：优先使用成功响应，只有当没有成功响应时才使用NXDOMAIN响应
		var validResponses []*dns.Msg
		if len(successResponses) > 0 {
			validResponses = successResponses
		} else {
			validResponses = nxdomainResponses
		}

		// 合并所有有效响应
		if len(validResponses) > 0 {
			bestResponse = mergeResponses(validResponses)
			if responseCount > 0 {
				bestRtt = totalRtt / time.Duration(responseCount)
			}
			hasBestResponse = true
			// 设置日志的type字段
			logType := "success"
			if len(successResponses) == 0 {
				logType = "nxdomain"
			}
			logger.Debug("合并所有响应返回", "domain", domain, "responseCount", len(validResponses), "type", logType)
		}

	case "fastest-ip":
		// 最快的IP地址模式 - 使用TCP连接速度测量选择最快服务器
		// 1. 选择最快的服务器
		fastestServer := s.selectFastestServer(selectedUpstreamDNS)
		if fastestServer != "" {
			// 使用带超时的方式执行Exchange
			resultChan := make(chan struct {
				response *dns.Msg
				rtt      time.Duration
				err      error
			}, 1)

			go func() {
				resp, r, e := s.resolver.Exchange(r, normalizeDNSServerAddress(fastestServer))
				resultChan <- struct {
					response *dns.Msg
					rtt      time.Duration
					err      error
				}{resp, r, e}
			}()

			var response *dns.Msg
			var rtt time.Duration
			var err error

			// 直接获取结果，不使用上下文超时
			result := <-resultChan
			response, rtt, err = result.response, result.rtt, result.err
			if err == nil && response != nil {
				// 更新服务器统计信息
				s.updateServerStats(fastestServer, true, rtt)

				// 检查是否包含DNSSEC记录
				containsDNSSEC := s.hasDNSSECRecords(response)

				// 如果启用了DNSSEC且响应包含DNSSEC记录，验证DNSSEC签名
				// 但如果域名匹配不验证DNSSEC的模式，则跳过验证
				if s.config.EnableDNSSEC && containsDNSSEC && !noDNSSEC {
					// 验证DNSSEC记录
					signatureValid := s.verifyDNSSEC(response)

					// 设置AD标志（Authenticated Data）
					response.AuthenticatedData = signatureValid

					if signatureValid {
						// 更新DNSSEC验证成功计数
						s.updateStats(func(stats *Stats) {
							stats.DNSSECQueries++
							stats.DNSSECSuccess++
						})
					} else {
						// 更新DNSSEC验证失败计数
						s.updateStats(func(stats *Stats) {
							stats.DNSSECQueries++
							stats.DNSSECFailed++
						})
					}
				} else if noDNSSEC {
					// 对于不验证DNSSEC的域名，始终设置AD标志为false
					response.AuthenticatedData = false
				}

				// 如果响应成功或为NXDOMAIN，根据DNSSEC状态选择最佳响应
				if response.Rcode == dns.RcodeSuccess || response.Rcode == dns.RcodeNameError {
					if response.Rcode == dns.RcodeSuccess {
						// 优先选择带有DNSSEC记录的响应
						if containsDNSSEC {
							bestResponse = response
							bestRtt = rtt
							hasBestResponse = true
							hasDNSSECResponse = true
							usedDNSServer = fastestServer
							if _, isDNSSECServer := s.dnssecServerMap[normalizeDNSServerAddress(fastestServer)]; isDNSSECServer {
								usedDNSSECServer = fastestServer
							}
							logger.Debug("找到带DNSSEC的最佳响应", "domain", domain, "server", fastestServer, "rtt", rtt)
						} else {
							// 没有带DNSSEC的响应时，保存成功响应
							bestResponse = response
							bestRtt = rtt
							hasBestResponse = true
							usedDNSServer = fastestServer
							if _, isDNSSECServer := s.dnssecServerMap[normalizeDNSServerAddress(fastestServer)]; isDNSSECServer {
								usedDNSSECServer = fastestServer
							}
							logger.Debug("找到最佳响应", "domain", domain, "server", fastestServer, "rtt", rtt)
						}
					} else if response.Rcode == dns.RcodeNameError {
						// 处理NXDOMAIN响应
						bestResponse = response
						bestRtt = rtt
						hasBestResponse = true
						usedDNSServer = fastestServer
						logger.Debug("找到NXDOMAIN响应", "domain", domain, "server", fastestServer, "rtt", rtt)
					}
					// 保存为备选响应
					if !hasBackup {
						backupResponse = response
						backupRtt = rtt
						hasBackup = true
					}
				}
			} else {
				// 更新服务器统计信息（失败）
				s.updateServerStats(fastestServer, false, 0)
			}
		}

	default:
		// 默认使用并行请求模式 - 实现快速返回和超时机制
		responses := make(chan serverResponse, len(selectedUpstreamDNS))
		resultChan := make(chan struct {
			response         *dns.Msg
			rtt              time.Duration
			usedServer       string
			usedDnssecServer string
		}, 1)
		var wg sync.WaitGroup

		// 向所有上游服务器并行发送请求
		for _, upstream := range selectedUpstreamDNS {
			wg.Add(1)
			go func(server string) {
				defer wg.Done()

				// 创建带有超时的resolver
				client := &dns.Client{
					Net:     s.resolver.Net,
					UDPSize: s.resolver.UDPSize,
					Timeout: defaultTimeout,
				}

				// 发送请求并获取响应，确保服务器地址包含端口号
				response, rtt, err := client.Exchange(r, normalizeDNSServerAddress(server))
				responses <- serverResponse{response, rtt, server, err}
			}(upstream)
		}

		// 处理响应的协程
		go func() {
			var fastestResponse *dns.Msg
			var fastestRtt time.Duration = defaultTimeout
			var fastestServer string
			var fastestDnssecServer string
			var fastestHasDnssec bool
			var successResponses []*dns.Msg
			var nxdomainResponses []*dns.Msg

			// 等待所有请求完成或超时
			timer := time.NewTimer(defaultTimeout)
			defer timer.Stop()

			// 处理所有响应
			for {
				select {
				case resp, ok := <-responses:
					if !ok {
						// 所有响应都已处理
						goto doneProcessing
					}

					if resp.error == nil && resp.response != nil {
						// 更新服务器统计信息
						s.updateServerStats(resp.server, true, resp.rtt)

						// 检查是否包含DNSSEC记录
						containsDNSSEC := s.hasDNSSECRecords(resp.response)

						// 对于不验证DNSSEC的域名，始终设置AD标志为false
						if noDNSSEC {
							resp.response.AuthenticatedData = false
						}

						dnssecServerForResponse := ""
						if _, isDNSSECServer := s.dnssecServerMap[normalizeDNSServerAddress(resp.server)]; isDNSSECServer {
							dnssecServerForResponse = resp.server
						}

						// 如果响应成功或为NXDOMAIN
						if resp.response.Rcode == dns.RcodeSuccess || resp.response.Rcode == dns.RcodeNameError {
							// 按Rcode分类添加到不同列表
							if resp.response.Rcode == dns.RcodeSuccess {
								successResponses = append(successResponses, resp.response)
							} else {
								nxdomainResponses = append(nxdomainResponses, resp.response)
							}

							// 快速返回逻辑：找到第一个有效响应或更快的响应
							if resp.response.Rcode == dns.RcodeSuccess {
								// 优先选择带有DNSSEC的响应
								if containsDNSSEC {
									// 如果这是第一个DNSSEC响应，或者比当前最快的DNSSEC响应更快
									if !fastestHasDnssec || resp.rtt < fastestRtt {
										fastestResponse = resp.response
										fastestRtt = resp.rtt
										fastestServer = resp.server
										fastestDnssecServer = dnssecServerForResponse
										fastestHasDnssec = true

										// 只对将要返回的响应进行DNSSEC验证
										if s.config.EnableDNSSEC && containsDNSSEC && !noDNSSEC {
											// 验证DNSSEC记录
											signatureValid := s.verifyDNSSEC(fastestResponse)

											// 设置AD标志（Authenticated Data）
											fastestResponse.AuthenticatedData = signatureValid

											if signatureValid {
												// 更新DNSSEC验证成功计数
												s.updateStats(func(stats *Stats) {
													stats.DNSSECQueries++
													stats.DNSSECSuccess++
												})
											} else {
												// 更新DNSSEC验证失败计数
												s.updateStats(func(stats *Stats) {
													stats.DNSSECQueries++
													stats.DNSSECFailed++
												})
											}
										}

										// 发送结果，快速返回
										resultChan <- struct {
											response         *dns.Msg
											rtt              time.Duration
											usedServer       string
											usedDnssecServer string
										}{fastestResponse, fastestRtt, fastestServer, fastestDnssecServer}
									}
								} else {
									// 非DNSSEC响应，只有在还没有找到DNSSEC响应且当前响应更快时才更新
									if !fastestHasDnssec && resp.rtt < fastestRtt {
										fastestResponse = resp.response
										fastestRtt = resp.rtt
										fastestServer = resp.server
										fastestDnssecServer = dnssecServerForResponse

										// 检查是否包含DNSSEC记录
										respContainsDNSSEC := s.hasDNSSECRecords(fastestResponse)

										// 只对将要返回的响应进行DNSSEC验证
										if s.config.EnableDNSSEC && respContainsDNSSEC && !noDNSSEC {
											// 验证DNSSEC记录
											signatureValid := s.verifyDNSSEC(fastestResponse)

											// 设置AD标志（Authenticated Data）
											fastestResponse.AuthenticatedData = signatureValid

											if signatureValid {
												// 更新DNSSEC验证成功计数
												s.updateStats(func(stats *Stats) {
													stats.DNSSECQueries++
													stats.DNSSECSuccess++
												})
											} else {
												// 更新DNSSEC验证失败计数
												s.updateStats(func(stats *Stats) {
													stats.DNSSECQueries++
													stats.DNSSECFailed++
												})
											}
										}

										// 发送结果，快速返回
										resultChan <- struct {
											response         *dns.Msg
											rtt              time.Duration
											usedServer       string
											usedDnssecServer string
										}{fastestResponse, fastestRtt, fastestServer, fastestDnssecServer}
									}
								}
							} else if resp.response.Rcode == dns.RcodeNameError {
								// NXDOMAIN响应，只有在还没有找到响应或当前响应更快时才更新
								if !fastestHasDnssec && resp.rtt < fastestRtt {
									fastestResponse = resp.response
									fastestRtt = resp.rtt
									fastestServer = resp.server
									fastestDnssecServer = dnssecServerForResponse

									// 检查是否包含DNSSEC记录
									respContainsDNSSEC := s.hasDNSSECRecords(fastestResponse)

									// 只对将要返回的响应进行DNSSEC验证
									if s.config.EnableDNSSEC && respContainsDNSSEC && !noDNSSEC {
										// 验证DNSSEC记录
										signatureValid := s.verifyDNSSEC(fastestResponse)

										// 设置AD标志（Authenticated Data）
										fastestResponse.AuthenticatedData = signatureValid

										if signatureValid {
											// 更新DNSSEC验证成功计数
											s.updateStats(func(stats *Stats) {
												stats.DNSSECQueries++
												stats.DNSSECSuccess++
											})
										} else {
											// 更新DNSSEC验证失败计数
											s.updateStats(func(stats *Stats) {
												stats.DNSSECQueries++
												stats.DNSSECFailed++
											})
										}
									}

									// 发送结果，快速返回
									resultChan <- struct {
										response         *dns.Msg
										rtt              time.Duration
										usedServer       string
										usedDnssecServer string
									}{fastestResponse, fastestRtt, fastestServer, fastestDnssecServer}
								}
							}
						} else {
							// 更新备选响应，确保总有一个可用的响应
							if resp.response != nil {
								if !hasBackup {
									// 第一次保存备选响应
									backupResponse = resp.response
									backupRtt = resp.rtt
									hasBackup = true
								}
							}
						}
					} else {
						// 更新服务器统计信息（失败）
						s.updateServerStats(resp.server, false, 0)
					}
				case <-timer.C:
					// 超时，停止等待更多响应
					goto doneProcessing
				}
			}

		doneProcessing:
			// 合并响应，优先使用成功响应，只有当没有成功响应时才使用NXDOMAIN响应
			var validResponses []*dns.Msg
			if len(successResponses) > 0 {
				validResponses = successResponses
			} else {
				validResponses = nxdomainResponses
			}

			// 合并所有有效响应，用于缓存
			if len(validResponses) > 1 {
				mergedResponse := mergeResponses(validResponses)
				if mergedResponse != nil {
					// 只在合并后的响应比最快响应更好时才使用
					mergedHasDnssec := s.hasDNSSECRecords(mergedResponse)
					if mergedHasDnssec && !fastestHasDnssec {
						// 合并后的响应有DNSSEC，而最快响应没有，使用合并后的响应
						fastestResponse = mergedResponse
						// 使用最快的Rtt作为合并响应的Rtt
						fastestHasDnssec = true
					}
				}
			}

			// 如果还没有发送结果，发送最快的响应
			if fastestResponse != nil {
				resultChan <- struct {
					response         *dns.Msg
					rtt              time.Duration
					usedServer       string
					usedDnssecServer string
				}{fastestResponse, fastestRtt, fastestServer, fastestDnssecServer}
			}
			close(resultChan)
		}()

		// 等待所有请求完成（不阻塞主流程）
		go func() {
			wg.Wait()
			close(responses)
		}()

		// 等待结果或超时
		select {
		case result := <-resultChan:
			// 快速返回结果
			bestResponse = result.response
			bestRtt = result.rtt
			usedDNSServer = result.usedServer
			usedDNSSECServer = result.usedDnssecServer
			hasBestResponse = true
			hasDNSSECResponse = s.hasDNSSECRecords(result.response)
			logger.Debug("快速返回DNS响应", "domain", domain, "server", result.usedServer, "rtt", result.rtt, "dnssec", hasDNSSECResponse)
		case <-time.After(defaultTimeout):
			// 超时，使用备选响应
			logger.Debug("并行请求超时", "domain", domain, "timeout", defaultTimeout)
		}
	}

	// 2. 当启用DNSSEC且没有找到带DNSSEC的响应时，向DNSSEC专用服务器发送请求
	// 但如果域名匹配了domainSpecificDNS配置或NoDNSSECDomains，则不使用DNSSEC专用服务器，只使用指定的DNS服务器
	if s.config.EnableDNSSEC && !hasDNSSECResponse && !domainMatched && !noDNSSEC {
		logger.Debug("向DNSSEC专用服务器发送请求", "domain", domain)

		// 增加DNSSEC查询计数
		s.updateStats(func(stats *Stats) {
			stats.DNSSECQueries++
		})

		// 无论查询模式是什么，DNSSEC验证都只使用加权随机选择一个服务器
		selectedDnssecServer := s.selectWeightedRandomServer(dnssecServers)
		if selectedDnssecServer != "" {
			// 使用带超时的方式执行Exchange
			resultChan := make(chan struct {
				response *dns.Msg
				rtt      time.Duration
				err      error
			}, 1)

			go func() {
				// 创建带有超时的resolver
				client := &dns.Client{
					Net:     s.resolver.Net,
					UDPSize: s.resolver.UDPSize,
					Timeout: defaultTimeout,
				}
				response, rtt, err := client.Exchange(r, normalizeDNSServerAddress(selectedDnssecServer))
				resultChan <- struct {
					response *dns.Msg
					rtt      time.Duration
					err      error
				}{response, rtt, err}
			}()

			var response *dns.Msg
			var rtt time.Duration
			var err error

			// 使用超时获取结果
			select {
			case result := <-resultChan:
				response, rtt, err = result.response, result.rtt, result.err
			case <-time.After(defaultTimeout):
				// 超时，不再等待
				logger.Debug("DNSSEC专用服务器请求超时", "domain", domain, "server", selectedDnssecServer, "timeout", defaultTimeout)
				return bestResponse, bestRtt, usedDNSServer, usedDNSSECServer
			}

			if err == nil && response != nil {
				// 更新服务器统计信息
				s.updateServerStats(selectedDnssecServer, true, rtt)

				// 检查是否包含DNSSEC记录
				containsDNSSEC := s.hasDNSSECRecords(response)

				if response.Rcode == dns.RcodeSuccess {
					// 无论响应是否包含DNSSEC记录，只要使用了DNSSEC专用服务器，就设置usedDNSSECServer
					usedDNSSECServer = selectedDnssecServer

					// 验证DNSSEC记录
					signatureValid := s.verifyDNSSEC(response)

					// 设置AD标志（Authenticated Data）
					response.AuthenticatedData = signatureValid

					if signatureValid {
						// 更新DNSSEC验证成功计数
						s.updateStats(func(stats *Stats) {
							stats.DNSSECSuccess++
						})
					} else {
						// 更新DNSSEC验证失败计数
						s.updateStats(func(stats *Stats) {
							stats.DNSSECFailed++
						})
					}

					// 优先使用DNSSEC专用服务器的响应，尤其是带有DNSSEC记录的
					if containsDNSSEC {
						bestResponse = response
						bestRtt = rtt
						hasBestResponse = true
						hasDNSSECResponse = true
						logger.Debug("DNSSEC专用服务器返回带DNSSEC的响应，优先使用", "domain", domain, "server", selectedDnssecServer, "rtt", rtt)
					}
					// 注意：如果DNSSEC专用服务器返回的响应不包含DNSSEC记录，
					// 我们不会覆盖之前从upstreamDNS获取的响应，
					// 这符合"本地解析指的是直接使用上游服务器upstreamDNS进行解析, 而不是dnssecUpstreamDNS"的要求

					// 更新备选响应
					if !hasBackup {
						backupResponse = response
						backupRtt = rtt
						hasBackup = true
					}
				}
			} else {
				// 更新服务器统计信息（失败）
				s.updateServerStats(selectedDnssecServer, false, 0)
			}
		}
	}

	// 3. 返回最佳响应
	if hasBestResponse {
		// 检查最佳响应是否包含DNSSEC记录
		bestHasDNSSEC := s.hasDNSSECRecords(bestResponse)

		// 如果启用了DNSSEC且最佳响应不包含DNSSEC记录，尝试使用本地解析（使用upstreamDNS服务器）
		// 但如果域名匹配了domainSpecificDNS配置，则不执行此逻辑，只使用指定的DNS服务器
		if s.config.EnableDNSSEC && !bestHasDNSSEC && !domainMatched {
			logger.Debug("最佳响应不包含DNSSEC记录，尝试使用本地解析（upstreamDNS）", "domain", domain)
			// 选择一个upstreamDNS服务器进行解析（使用加权随机算法）
			localServer := s.selectWeightedRandomServer(s.config.UpstreamDNS)
			if localServer != "" {
				// 使用带超时的方式执行Exchange
				resultChan := make(chan struct {
					response *dns.Msg
					rtt      time.Duration
					err      error
				}, 1)

				go func() {
					resp, r, e := s.resolver.Exchange(r, normalizeDNSServerAddress(localServer))
					resultChan <- struct {
						response *dns.Msg
						rtt      time.Duration
						err      error
					}{resp, r, e}
				}()

				var localResponse *dns.Msg
				var rtt time.Duration
				var err error

				// 直接获取结果，不使用上下文超时
				result := <-resultChan
				localResponse, rtt, err = result.response, result.rtt, result.err

				if err == nil && localResponse != nil {
					// 更新服务器统计信息
					s.updateServerStats(localServer, true, rtt)

					// 检查是否包含DNSSEC记录
					localHasDNSSEC := s.hasDNSSECRecords(localResponse)

					// 验证DNSSEC记录（如果存在），但不影响最终响应
					if localHasDNSSEC {
						signatureValid := s.verifyDNSSEC(localResponse)
						localResponse.AuthenticatedData = signatureValid

						if signatureValid {
							s.updateStats(func(stats *Stats) {
								stats.DNSSECQueries++
								stats.DNSSECSuccess++
							})
						} else {
							s.updateStats(func(stats *Stats) {
								stats.DNSSECQueries++
								stats.DNSSECFailed++
							})
						}
					}

					// 记录解析域名统计
					s.updateResolvedDomainStats(domain)

					// 更新域名的DNSSEC状态
					s.updateDomainDNSSECStatus(domain, localHasDNSSEC)

					s.updateStats(func(stats *Stats) {
						stats.Allowed++
					})

					logger.Debug("使用本地解析结果（upstreamDNS）", "domain", domain, "server", localServer, "rtt", rtt)
					return localResponse, rtt, localServer, ""
				} else {
					// 更新服务器统计信息（失败）
					s.updateServerStats(localServer, false, 0)
				}
			}
		}

		// 记录解析域名统计
		s.updateResolvedDomainStats(domain)

		// 更新域名的DNSSEC状态
		if bestHasDNSSEC {
			s.updateDomainDNSSECStatus(domain, true)
		} else {
			s.updateDomainDNSSECStatus(domain, false)
		}

		s.updateStats(func(stats *Stats) {
			stats.Allowed++
		})
		return bestResponse, bestRtt, usedDNSServer, usedDNSSECServer
	}

	// 如果有备选响应，返回该响应
	if hasBackup {
		logger.Debug("使用备选响应，没有找到更好的结果", "domain", domain)
		// 记录解析域名统计
		s.updateResolvedDomainStats(domain)
		// 更新统计信息
		s.updateStats(func(stats *Stats) {
			stats.Allowed++
		})
		return backupResponse, backupRtt, "", ""
	}

	// 所有上游服务器都失败，返回服务器失败错误
	response := new(dns.Msg)
	response.SetReply(r)

	response.SetRcode(r, dns.RcodeServerFailure)

	logger.Error("DNS查询失败", "domain", domain)
	s.updateStats(func(stats *Stats) {
		stats.Errors++
	})
	return response, 0, "", ""
}

// forwardDNSRequest 转发DNS请求到上游服务器
func (s *Server) forwardDNSRequest(w dns.ResponseWriter, r *dns.Msg, domain string) {
	response, _, _, _ := s.forwardDNSRequestWithCache(r, domain)
	w.WriteMsg(response)
}

// updateBlockedDomainStats 更新被屏蔽域名统计
func (s *Server) updateBlockedDomainStats(domain string) {
	// 先尝试读锁，检查条目是否存在
	s.blockedDomainsMutex.RLock()
	entry, exists := s.blockedDomains[domain]
	s.blockedDomainsMutex.RUnlock()

	if exists {
		// 使用原子操作更新计数和时间戳
		atomic.AddInt64(&entry.Count, 1)
		atomic.StoreInt64(&entry.LastSeen, time.Now().UnixNano())
	} else {
		// 获取写锁，创建新条目
		s.blockedDomainsMutex.Lock()
		// 再次检查，避免竞态条件
		if entry, exists := s.blockedDomains[domain]; exists {
			atomic.AddInt64(&entry.Count, 1)
			atomic.StoreInt64(&entry.LastSeen, time.Now().UnixNano())
		} else {
			s.blockedDomains[domain] = &BlockedDomain{
				Domain:   domain,
				Count:    1,
				LastSeen: time.Now().UnixNano(),
				DNSSEC:   false,
			}
		}
		s.blockedDomainsMutex.Unlock()
	}

	// 更新统计数据
	now := time.Now()

	// 更新小时统计
	hourKey := now.Format("2006-01-02-15")
	s.hourlyStatsMutex.Lock()
	s.hourlyStats[hourKey]++
	s.hourlyStatsMutex.Unlock()

	// 更新每日统计
	dayKey := now.Format("2006-01-02")
	s.dailyStatsMutex.Lock()
	s.dailyStats[dayKey]++
	s.dailyStatsMutex.Unlock()

	// 更新每月统计
	monthKey := now.Format("2006-01")
	s.monthlyStatsMutex.Lock()
	s.monthlyStats[monthKey]++
	s.monthlyStatsMutex.Unlock()
}

// updateClientStats 更新客户端统计
func (s *Server) updateClientStats(ip string) {
	// 先尝试读锁，检查条目是否存在
	s.clientStatsMutex.RLock()
	entry, exists := s.clientStats[ip]
	s.clientStatsMutex.RUnlock()

	if exists {
		// 使用原子操作更新计数和时间戳
		atomic.AddInt64(&entry.Count, 1)
		atomic.StoreInt64(&entry.LastSeen, time.Now().UnixNano())
	} else {
		// 获取写锁，创建新条目
		s.clientStatsMutex.Lock()
		// 再次检查，避免竞态条件
		if entry, exists := s.clientStats[ip]; exists {
			atomic.AddInt64(&entry.Count, 1)
			atomic.StoreInt64(&entry.LastSeen, time.Now().UnixNano())
		} else {
			s.clientStats[ip] = &ClientStats{
				IP:       ip,
				Count:    1,
				LastSeen: time.Now().UnixNano(),
			}
		}
		s.clientStatsMutex.Unlock()
	}
}

// hasDNSSECRecords 检查响应是否包含DNSSEC记录
func (s *Server) hasDNSSECRecords(response *dns.Msg) bool {
	// 直接调用包内的hasDNSSECRecords函数，避免重复代码
	return hasDNSSECRecords(response)
}

// verifyDNSSEC 验证DNSSEC签名
func (s *Server) verifyDNSSEC(response *dns.Msg) bool {
	// 提取DNSKEY和RRSIG记录，并按类型和名称组织记录
	dnskeys := make(map[uint16]*dns.DNSKEY) // KeyTag -> DNSKEY
	rrsigs := make([]*dns.RRSIG, 0)
	// 按 (名称, 类型) 组织记录集，用于快速查找
	rrSets := make(map[string]map[uint16][]dns.RR) // name -> type -> records

	// 定义处理单个记录的函数
	processRecord := func(rr dns.RR) {
		num := rr.Header().Rrtype
		name := rr.Header().Name

		// 组织记录集
		if _, exists := rrSets[name]; !exists {
			rrSets[name] = make(map[uint16][]dns.RR)
		}
		if _, exists := rrSets[name][num]; !exists {
			rrSets[name][num] = make([]dns.RR, 0)
		}
		rrSets[name][num] = append(rrSets[name][num], rr)

		// 特别处理DNSKEY和RRSIG
		if dnskey, ok := rr.(*dns.DNSKEY); ok {
			tag := dnskey.KeyTag()
			dnskeys[tag] = dnskey
		} else if rrsig, ok := rr.(*dns.RRSIG); ok {
			rrsigs = append(rrsigs, rrsig)
		}
	}

	// 一次遍历所有响应部分，同时完成记录收集和组织
	for _, rr := range response.Answer {
		processRecord(rr)
	}
	for _, rr := range response.Ns {
		processRecord(rr)
	}
	for _, rr := range response.Extra {
		processRecord(rr)
	}

	// 如果没有RRSIG记录，验证失败
	if len(rrsigs) == 0 {
		return false
	}

	// 验证所有RRSIG记录
	signatureValid := true
	// 用于记录已经警告过的DNSKEY tag，避免重复警告
	warnedKeyTags := make(map[uint16]bool)
	for _, rrsig := range rrsigs {
		// 查找对应的DNSKEY
		dnskey, exists := dnskeys[rrsig.KeyTag]
		if !exists {
			// 仅当该key_tag尚未警告过时才记录警告
			if !warnedKeyTags[rrsig.KeyTag] {
				logger.Warn("DNSSEC验证失败：找不到对应的DNSKEY", "key_tag", rrsig.KeyTag)
				warnedKeyTags[rrsig.KeyTag] = true
			}
			signatureValid = false
			continue
		}

		// 快速查找需要验证的记录集
		name := rrsig.Header().Name
		typeCovered := rrsig.TypeCovered
		rrset := rrSets[name][typeCovered]

		// 验证签名
		if len(rrset) > 0 {
			err := rrsig.Verify(dnskey, rrset)
			if err != nil {
				logger.Warn("DNSSEC签名验证失败", "error", err, "key_tag", rrsig.KeyTag)
				signatureValid = false
			} else {
				logger.Debug("DNSSEC签名验证成功", "key_tag", rrsig.KeyTag)
			}
		}
	}

	return signatureValid
}

// updateDomainDNSSECStatus 更新域名的DNSSEC状态
func (s *Server) updateDomainDNSSECStatus(domain string, dnssec bool) {
	// 确保域名是小写
	domain = strings.ToLower(domain)

	// 更新域名的DNSSEC状态
	s.resolvedDomainsMutex.Lock()
	defer s.resolvedDomainsMutex.Unlock()

	// 更新resolvedDomains中的DNSSEC状态
	if entry, exists := s.resolvedDomains[domain]; exists {
		entry.DNSSEC = dnssec
	} else {
		s.resolvedDomains[domain] = &BlockedDomain{
			Domain:   domain,
			Count:    1,
			LastSeen: time.Now().UnixNano(),
			DNSSEC:   dnssec,
		}
	}

	// 更新domainDNSSECStatus映射（使用单独的锁）
	s.domainDNSSECStatusMutex.Lock()
	s.domainDNSSECStatus[domain] = dnssec
	s.domainDNSSECStatusMutex.Unlock()
}

// updateResolvedDomainStats 更新解析域名统计
func (s *Server) updateResolvedDomainStats(domain string) {
	// 先尝试读锁，检查条目是否存在
	s.resolvedDomainsMutex.RLock()
	entry, exists := s.resolvedDomains[domain]
	s.resolvedDomainsMutex.RUnlock()

	if exists {
		// 使用原子操作更新计数和时间戳
		atomic.AddInt64(&entry.Count, 1)
		atomic.StoreInt64(&entry.LastSeen, time.Now().UnixNano())
	} else {
		// 获取写锁，创建新条目
		s.resolvedDomainsMutex.Lock()
		// 再次检查，避免竞态条件
		if entry, exists := s.resolvedDomains[domain]; exists {
			atomic.AddInt64(&entry.Count, 1)
			atomic.StoreInt64(&entry.LastSeen, time.Now().UnixNano())
		} else {
			s.resolvedDomains[domain] = &BlockedDomain{
				Domain:   domain,
				Count:    1,
				LastSeen: time.Now().UnixNano(),
				DNSSEC:   false,
			}
		}
		s.resolvedDomainsMutex.Unlock()
	}
}

// getServerStats 获取服务器统计信息，如果不存在则创建
func (s *Server) getServerStats(server string) *ServerStats {
	s.serverStatsMutex.RLock()
	stats, exists := s.serverStats[server]
	s.serverStatsMutex.RUnlock()

	if exists {
		return stats
	}

	s.serverStatsMutex.Lock()
	defer s.serverStatsMutex.Unlock()

	if stats, exists := s.serverStats[server]; exists {
		return stats
	}

	stats = &ServerStats{
		SuccessCount:    0,
		FailureCount:    0,
		LastResponse:    time.Now(),
		ResponseTime:    0,
		ConnectionSpeed: 0,
	}

	s.serverStats[server] = stats
	return stats
}

// updateServerStats 更新服务器统计信息
func (s *Server) updateServerStats(server string, success bool, rtt time.Duration) {
	stats := s.getServerStats(server)

	// 使用原子操作更新成功和失败计数
	if success {
		successCount := atomic.AddInt64(&stats.SuccessCount, 1)

		// 只在需要更新平均响应时间时获取锁
		s.serverStatsMutex.Lock()
		stats.LastResponse = time.Now()

		// 更新平均响应时间（简单移动平均）
		if successCount == 1 {
			// 第一次成功，直接使用当前响应时间
			stats.ResponseTime = rtt
		} else {
			// 使用纳秒进行计算以避免类型不匹配
			prevTotal := stats.ResponseTime.Nanoseconds() * (successCount - 1)
			newTotal := prevTotal + rtt.Nanoseconds()
			stats.ResponseTime = time.Duration(newTotal / successCount)
		}
		s.serverStatsMutex.Unlock()
	} else {
		atomic.AddInt64(&stats.FailureCount, 1)

		// 只更新LastResponse时获取锁
		s.serverStatsMutex.Lock()
		stats.LastResponse = time.Now()
		s.serverStatsMutex.Unlock()
	}
}

// selectWeightedRandomServer 加权随机选择服务器
func (s *Server) selectWeightedRandomServer(servers []string) string {
	if len(servers) == 0 {
		return ""
	}

	if len(servers) == 1 {
		return servers[0]
	}

	type serverWeight struct {
		server       string
		weight       int64
		responseTime time.Duration
		successCount int64
		failureCount int64
	}

	var totalWeight int64
	var totalResponseTime time.Duration
	var validServers int
	var currentWeight int64

	serversInfo := make([]serverWeight, len(servers))

	for i, server := range servers {
		stats := s.getServerStats(server)

		serversInfo[i] = serverWeight{
			server:       server,
			responseTime: stats.ResponseTime,
			successCount: atomic.LoadInt64(&stats.SuccessCount),
			failureCount: atomic.LoadInt64(&stats.FailureCount),
		}

		if stats.ResponseTime > 0 {
			totalResponseTime += stats.ResponseTime
			validServers++
		}
	}

	var avgResponseTime time.Duration
	if validServers > 0 {
		avgResponseTime = totalResponseTime / time.Duration(validServers)
	} else {
		avgResponseTime = 1 * time.Second
	}

	var randomGen = rand.New(rand.NewSource(time.Now().UnixNano()))

	for i := range serversInfo {
		baseWeight := serversInfo[i].successCount - serversInfo[i].failureCount*2
		if baseWeight < 1 {
			baseWeight = 1
		}

		var responseFactor int64 = 100
		if serversInfo[i].responseTime > 0 {
			if serversInfo[i].responseTime < avgResponseTime {
				factor := (avgResponseTime.Nanoseconds() * 200) / serversInfo[i].responseTime.Nanoseconds()
				if factor > 200 {
					factor = 200
				}
				responseFactor = factor
			} else {
				factor := (avgResponseTime.Nanoseconds() * 200) / serversInfo[i].responseTime.Nanoseconds()
				if factor < 50 {
					factor = 50
				}
				responseFactor = factor
			}
		}

		finalWeight := (baseWeight * responseFactor) / 100
		if finalWeight < 1 {
			finalWeight = 1
		}

		serversInfo[i].weight = finalWeight
		totalWeight += finalWeight
	}

	random := randomGen.Int63n(totalWeight)

	for _, sw := range serversInfo {
		currentWeight += sw.weight
		if random < currentWeight {
			return sw.server
		}
	}

	// 兜底返回第一个服务器
	return servers[0]
}

// measureServerSpeed 测量服务器TCP连接速度
func (s *Server) measureServerSpeed(server string) time.Duration {
	addr := server
	if !strings.Contains(server, ":") {
		addr = server + ":53"
	}

	startTime := time.Now()
	conn, err := net.DialTimeout("tcp", addr, 2*time.Second)
	if err != nil {
		return 2 * time.Second
	}
	defer conn.Close()

	connTime := time.Since(startTime)

	stats := s.getServerStats(server)
	s.serverStatsMutex.Lock()
	stats.ConnectionSpeed = (stats.ConnectionSpeed*3 + connTime) / 4
	s.serverStatsMutex.Unlock()

	return connTime
}

// selectFastestServer 选择连接速度最快的服务器
func (s *Server) selectFastestServer(servers []string) string {
	if len(servers) == 0 {
		return ""
	}

	if len(servers) == 1 {
		return servers[0]
	}

	// 并行测量所有服务器的速度
	type speedResult struct {
		server string
		speed  time.Duration
	}

	results := make(chan speedResult, len(servers))
	var wg sync.WaitGroup

	for _, server := range servers {
		wg.Add(1)
		go func(srv string) {
			defer wg.Done()
			speed := s.measureServerSpeed(srv)
			results <- speedResult{srv, speed}
		}(server)
	}

	// 等待所有测量完成
	go func() {
		wg.Wait()
		close(results)
	}()

	// 找出最快的服务器
	var fastestServer string
	var fastestSpeed time.Duration = 2 * time.Second

	for result := range results {
		if result.speed < fastestSpeed {
			fastestSpeed = result.speed
			fastestServer = result.server
		}
	}

	// 如果没有找到最快服务器（理论上不会发生），返回第一个服务器
	if fastestServer == "" {
		fastestServer = servers[0]
	}

	return fastestServer
}

// updateStats 更新统计信息
func (s *Server) updateStats(update func(*Stats)) {
	s.statsMutex.Lock()
	defer s.statsMutex.Unlock()
	update(s.stats)
}

// addQueryLog 添加查询日志
func (s *Server) addQueryLog(clientIP, domain, queryType string, responseTime int64, result, blockRule, blockType string, fromCache, dnssec, edns bool, dnsServer, dnssecServer string, answers []DNSAnswer, responseCode int) {
	// 创建日志记录
	log := QueryLog{
		Timestamp:    time.Now(),
		ClientIP:     clientIP,
		Domain:       domain,
		QueryType:    queryType,
		ResponseTime: responseTime,
		Result:       result,
		BlockRule:    blockRule,
		BlockType:    blockType,
		FromCache:    fromCache,
		DNSSEC:       dnssec,
		EDNS:         edns,
		DNSServer:    dnsServer,
		DNSSECServer: dnssecServer,
		Answers:      answers,
		ResponseCode: responseCode,
	}

	// 发送到日志处理通道（非阻塞）
	select {
	case s.logChannel <- log:
		// 日志发送成功
	default:
		// 通道已满，丢弃日志以避免阻塞请求处理
		logger.Warn("日志通道已满，丢弃一条日志记录")
	}
}

// GetStartTime 获取服务器启动时间
func (s *Server) GetStartTime() time.Time {
	return s.startTime
}

// GetStats 获取DNS服务器统计信息
func (s *Server) GetStats() *Stats {
	s.statsMutex.Lock()
	defer s.statsMutex.Unlock()

	// 复制查询类型统计
	queryTypesCopy := make(map[string]int64)
	for k, v := range s.stats.QueryTypes {
		queryTypesCopy[k] = v
	}

	// 复制来源IP统计
	sourceIPsCopy := make(map[string]bool)
	for ip := range s.stats.SourceIPs {
		sourceIPsCopy[ip] = true
	}

	// 返回统计信息的副本
	return &Stats{
		Queries:           s.stats.Queries,
		Blocked:           s.stats.Blocked,
		Allowed:           s.stats.Allowed,
		Errors:            s.stats.Errors,
		LastQuery:         s.stats.LastQuery,
		AvgResponseTime:   s.stats.AvgResponseTime,
		TotalResponseTime: s.stats.TotalResponseTime,
		QueryTypes:        queryTypesCopy,
		SourceIPs:         sourceIPsCopy,
		CpuUsage:          s.stats.CpuUsage,
		DNSSECQueries:     s.stats.DNSSECQueries,
		DNSSECSuccess:     s.stats.DNSSECSuccess,
		DNSSECFailed:      s.stats.DNSSECFailed,
		DNSSECEnabled:     s.stats.DNSSECEnabled,
	}
}

// GetQueryLogs 获取查询日志
func (s *Server) GetQueryLogs(limit, offset int, sortField, sortDirection, resultFilter, searchTerm string) []QueryLog {
	s.queryLogsMutex.RLock()
	defer s.queryLogsMutex.RUnlock()

	// 确保偏移量和限制值合理
	if offset < 0 {
		offset = 0
	}
	if limit <= 0 {
		limit = 100 // 默认返回100条日志
	}

	// 创建日志副本用于过滤和排序
	var logsCopy []QueryLog

	// 先过滤日志
	for _, log := range s.queryLogs {
		// 应用结果过滤
		if resultFilter != "" && log.Result != resultFilter {
			continue
		}

		// 应用搜索过滤
		if searchTerm != "" {
			// 搜索域名或客户端IP
			if !strings.Contains(log.Domain, searchTerm) && !strings.Contains(log.ClientIP, searchTerm) {
				continue
			}
		}

		logsCopy = append(logsCopy, log)
	}

	// 排序日志
	if sortField != "" {
		sort.Slice(logsCopy, func(i, j int) bool {
			var a, b interface{}
			switch sortField {
			case "time":
				a = logsCopy[i].Timestamp
				b = logsCopy[j].Timestamp
			case "clientIp":
				a = logsCopy[i].ClientIP
				b = logsCopy[j].ClientIP
			case "domain":
				a = logsCopy[i].Domain
				b = logsCopy[j].Domain
			case "responseTime":
				a = logsCopy[i].ResponseTime
				b = logsCopy[j].ResponseTime
			case "blockRule":
				a = logsCopy[i].BlockRule
				b = logsCopy[j].BlockRule
			default:
				// 默认按时间排序
				a = logsCopy[i].Timestamp
				b = logsCopy[j].Timestamp
			}

			// 根据排序方向比较
			if sortDirection == "asc" {
				return compareValues(a, b) < 0
			}
			return compareValues(a, b) > 0
		})
	}

	// 计算返回范围
	start := offset
	end := offset + limit
	if end > len(logsCopy) {
		end = len(logsCopy)
	}
	if start >= len(logsCopy) {
		return []QueryLog{} // 没有数据，返回空切片
	}

	return logsCopy[start:end]
}

// compareValues 比较两个值
func compareValues(a, b interface{}) int {
	switch v1 := a.(type) {
	case time.Time:
		v2 := b.(time.Time)
		if v1.Before(v2) {
			return -1
		}
		if v1.After(v2) {
			return 1
		}
		return 0
	case string:
		v2 := b.(string)
		if v1 < v2 {
			return -1
		}
		if v1 > v2 {
			return 1
		}
		return 0
	case int64:
		v2 := b.(int64)
		if v1 < v2 {
			return -1
		}
		if v1 > v2 {
			return 1
		}
		return 0
	default:
		return 0
	}
}

// GetQueryLogsCount 获取查询日志总数
func (s *Server) GetQueryLogsCount() int {
	s.queryLogsMutex.RLock()
	defer s.queryLogsMutex.RUnlock()
	return len(s.queryLogs)
}

// GetQueryStats 获取查询统计信息
func (s *Server) GetQueryStats() map[string]interface{} {
	s.statsMutex.Lock()
	defer s.statsMutex.Unlock()

	// 计算统计数据
	return map[string]interface{}{
		"totalQueries":    s.stats.Queries,
		"blockedQueries":  s.stats.Blocked,
		"allowedQueries":  s.stats.Allowed,
		"errorQueries":    s.stats.Errors,
		"avgResponseTime": s.stats.AvgResponseTime,
		"activeIPs":       len(s.stats.SourceIPs),
	}
}

// GetTopBlockedDomains 获取TOP屏蔽域名列表
func (s *Server) GetTopBlockedDomains(limit int) []BlockedDomain {
	s.blockedDomainsMutex.RLock()
	defer s.blockedDomainsMutex.RUnlock()

	// 计算30天前的时间戳
	thirtyDaysAgo := time.Now().Add(-30 * 24 * time.Hour).Unix()

	// 转换为切片并过滤最近30天的数据
	domains := make([]BlockedDomain, 0, len(s.blockedDomains))
	for _, entry := range s.blockedDomains {
		// 只包含最近30天的数据
		if entry.LastSeen >= thirtyDaysAgo {
			domains = append(domains, *entry)
		}
	}

	// 按计数排序
	sort.Slice(domains, func(i, j int) bool {
		return domains[i].Count > domains[j].Count
	})

	// 返回限制数量
	if len(domains) > limit {
		return domains[:limit]
	}
	return domains
}

// GetTopResolvedDomains 获取TOP解析域名
func (s *Server) GetTopResolvedDomains(limit int) []BlockedDomain {
	s.resolvedDomainsMutex.RLock()
	defer s.resolvedDomainsMutex.RUnlock()

	// 计算30天前的时间戳
	thirtyDaysAgo := time.Now().Add(-30 * 24 * time.Hour).Unix()

	// 转换为切片并过滤最近30天的数据
	domains := make([]BlockedDomain, 0, len(s.resolvedDomains))
	for _, entry := range s.resolvedDomains {
		// 只包含最近30天的数据
		if entry.LastSeen >= thirtyDaysAgo {
			domains = append(domains, *entry)
		}
	}

	// 按数量排序
	sort.Slice(domains, func(i, j int) bool {
		return domains[i].Count > domains[j].Count
	})

	// 返回限制数量
	if len(domains) > limit {
		return domains[:limit]
	}
	return domains
}

// GetRecentBlockedDomains 获取最近屏蔽的域名列表
func (s *Server) GetRecentBlockedDomains(limit int) []BlockedDomain {
	s.blockedDomainsMutex.RLock()
	defer s.blockedDomainsMutex.RUnlock()

	// 转换为切片
	domains := make([]BlockedDomain, 0, len(s.blockedDomains))
	for _, entry := range s.blockedDomains {
		domains = append(domains, *entry)
	}

	// 按时间排序
	sort.Slice(domains, func(i, j int) bool {
		return domains[i].LastSeen > domains[j].LastSeen
	})

	// 返回限制数量
	if len(domains) > limit {
		return domains[:limit]
	}
	return domains
}

// GetTopClients 获取TOP客户端列表
func (s *Server) GetTopClients(limit int) []ClientStats {
	s.clientStatsMutex.RLock()
	defer s.clientStatsMutex.RUnlock()

	// 转换为切片
	clients := make([]ClientStats, 0, len(s.clientStats))
	for _, entry := range s.clientStats {
		clients = append(clients, *entry)
	}

	// 按请求次数排序
	sort.Slice(clients, func(i, j int) bool {
		return clients[i].Count > clients[j].Count
	})

	// 返回限制数量
	if len(clients) > limit {
		return clients[:limit]
	}
	return clients
}

// GetHourlyStats 获取每小时统计数据
func (s *Server) GetHourlyStats() map[string]int64 {
	s.hourlyStatsMutex.RLock()
	defer s.hourlyStatsMutex.RUnlock()

	// 返回副本
	result := make(map[string]int64)
	for k, v := range s.hourlyStats {
		result[k] = v
	}
	return result
}

// GetDailyStats 获取每日统计数据
func (s *Server) GetDailyStats() map[string]int64 {
	s.dailyStatsMutex.RLock()
	defer s.dailyStatsMutex.RUnlock()

	// 返回副本
	result := make(map[string]int64)
	for k, v := range s.dailyStats {
		result[k] = v
	}
	return result
}

// GetMonthlyStats 获取每月统计数据
func (s *Server) GetMonthlyStats() map[string]int64 {
	s.monthlyStatsMutex.RLock()
	defer s.monthlyStatsMutex.RUnlock()

	// 返回副本
	result := make(map[string]int64)
	for k, v := range s.monthlyStats {
		result[k] = v
	}
	return result
}

// isPrivateIP 检测IP地址是否为内网IP
func isPrivateIP(ip string) bool {
	// 解析IP地址
	parsedIP := net.ParseIP(ip)
	if parsedIP == nil {
		return false
	}

	// 检查IPv4内网地址
	if ipv4 := parsedIP.To4(); ipv4 != nil {
		// 10.0.0.0/8
		if ipv4[0] == 10 {
			return true
		}
		// 172.16.0.0/12
		if ipv4[0] == 172 && (ipv4[1] >= 16 && ipv4[1] <= 31) {
			return true
		}
		// 192.168.0.0/16
		if ipv4[0] == 192 && ipv4[1] == 168 {
			return true
		}
		// 127.0.0.0/8 (localhost)
		if ipv4[0] == 127 {
			return true
		}
		// 169.254.0.0/16 (链路本地地址)
		if ipv4[0] == 169 && ipv4[1] == 254 {
			return true
		}
		return false
	}

	// 检查IPv6内网地址
	// ::1/128 (localhost)
	if parsedIP.IsLoopback() {
		return true
	}
	// fc00::/7 (唯一本地地址)
	if parsedIP[0]&0xfc == 0xfc {
		return true
	}
	// fe80::/10 (链路本地地址)
	if parsedIP[0]&0xfe == 0xfe && parsedIP[1]&0xc0 == 0x80 {
		return true
	}
	return false
}

// loadStatsData 从文件加载统计数据
func (s *Server) loadStatsData() {
	// 检查文件是否存在
	data, err := ioutil.ReadFile("data/stats.json")
	if err != nil {
		if !os.IsNotExist(err) {
			logger.Error("读取统计数据文件失败", "error", err)
		}
		return
	}

	var statsData StatsData
	err = json.Unmarshal(data, &statsData)
	if err != nil {
		logger.Error("解析统计数据失败", "error", err)
		return
	}

	// 恢复统计数据
	s.statsMutex.Lock()
	if statsData.Stats != nil {
		// 只恢复有效数据，避免破坏统计关系
		s.stats.Queries += statsData.Stats.Queries
		s.stats.Blocked += statsData.Stats.Blocked
		s.stats.Allowed += statsData.Stats.Allowed
		s.stats.Errors += statsData.Stats.Errors
		s.stats.TotalResponseTime += statsData.Stats.TotalResponseTime
		s.stats.DNSSECQueries += statsData.Stats.DNSSECQueries
		s.stats.DNSSECSuccess += statsData.Stats.DNSSECSuccess
		s.stats.DNSSECFailed += statsData.Stats.DNSSECFailed

		// 重新计算平均响应时间，确保一致性
		if s.stats.Queries > 0 {
			s.stats.AvgResponseTime = float64(s.stats.TotalResponseTime) / float64(s.stats.Queries)
			// 限制平均响应时间的范围，避免显示异常大的值
			if s.stats.AvgResponseTime > 60000 {
				s.stats.AvgResponseTime = 60000
			}
		}

		// 合并查询类型统计
		for k, v := range statsData.Stats.QueryTypes {
			s.stats.QueryTypes[k] += v
		}

		// 合并来源IP统计
		for ip := range statsData.Stats.SourceIPs {
			s.stats.SourceIPs[ip] = true
		}

		// 确保使用当前配置中的EnableDNSSEC值
		s.stats.DNSSECEnabled = s.config.EnableDNSSEC
	}
	s.statsMutex.Unlock()

	s.blockedDomainsMutex.Lock()
	if statsData.BlockedDomains != nil {
		s.blockedDomains = statsData.BlockedDomains
	}
	s.blockedDomainsMutex.Unlock()

	s.resolvedDomainsMutex.Lock()
	if statsData.ResolvedDomains != nil {
		s.resolvedDomains = statsData.ResolvedDomains
	}
	s.resolvedDomainsMutex.Unlock()

	s.hourlyStatsMutex.Lock()
	if statsData.HourlyStats != nil {
		s.hourlyStats = statsData.HourlyStats
	}
	s.hourlyStatsMutex.Unlock()

	s.dailyStatsMutex.Lock()
	if statsData.DailyStats != nil {
		s.dailyStats = statsData.DailyStats
	}
	s.dailyStatsMutex.Unlock()

	s.monthlyStatsMutex.Lock()
	if statsData.MonthlyStats != nil {
		s.monthlyStats = statsData.MonthlyStats
	}
	s.monthlyStatsMutex.Unlock()

	// 加载客户端统计数据
	s.clientStatsMutex.Lock()
	if statsData.ClientStats != nil {
		s.clientStats = statsData.ClientStats
	}
	s.clientStatsMutex.Unlock()

	logger.Info("统计数据加载成功")

	// 加载查询日志
	s.loadQueryLogs()
}

// loadQueryLogs 从文件加载查询日志
func (s *Server) loadQueryLogs() {
	// 获取绝对路径
	statsFilePath, err := filepath.Abs("data/stats.json")
	if err != nil {
		logger.Error("获取统计文件绝对路径失败", "path", "data/stats.json", "error", err)
		return
	}

	// 构建查询日志文件路径
	queryLogPath := filepath.Join(filepath.Dir(statsFilePath), "querylog.json")

	// 检查文件是否存在
	if _, err := os.Stat(queryLogPath); os.IsNotExist(err) {
		logger.Info("查询日志文件不存在，将使用空列表", "file", queryLogPath)
		return
	}

	// 读取文件内容
	data, err := ioutil.ReadFile(queryLogPath)
	if err != nil {
		logger.Error("读取查询日志文件失败", "error", err)
		return
	}

	// 解析数据
	var logs []QueryLog
	err = json.Unmarshal(data, &logs)
	if err != nil {
		logger.Error("解析查询日志失败", "error", err)
		return
	}

	// 更新查询日志
	s.queryLogsMutex.Lock()
	s.queryLogs = logs
	// 确保日志数量不超过限制
	if len(s.queryLogs) > s.maxQueryLogs {
		s.queryLogs = s.queryLogs[:s.maxQueryLogs]
	}
	s.queryLogsMutex.Unlock()

	logger.Info("查询日志加载成功", "count", len(logs))
}

// processLogs 异步处理日志记录
func (s *Server) processLogs() {
	for {
		select {
		case logEntry, ok := <-s.logChannel:
			if !ok {
				// 通道关闭，退出循环
				return
			}

			// 加锁保护queryLogs
			s.queryLogsMutex.Lock()

			// 如果日志数量超过最大限制，删除最旧的日志
			if len(s.queryLogs) >= s.maxQueryLogs {
				// 保留最新的s.maxQueryLogs条日志
				newLogs := make([]QueryLog, 0, s.maxQueryLogs)
				// 复制最新的日志到新切片
				for i := len(s.queryLogs) - s.maxQueryLogs + 1; i < len(s.queryLogs); i++ {
					newLogs = append(newLogs, s.queryLogs[i])
				}
				// 添加新日志
				newLogs = append(newLogs, logEntry)
				// 替换原有日志
				s.queryLogs = newLogs
			} else {
				// 直接添加新日志
				s.queryLogs = append(s.queryLogs, logEntry)
			}

			// 解锁
			s.queryLogsMutex.Unlock()

		case <-s.ctx.Done():
			// 上下文取消，退出循环
			return
		}
	}
}

// saveStatsData 保存统计数据到文件
func (s *Server) saveStatsData() {
	// 获取绝对路径以避免工作目录问题
	statsFilePath, err := filepath.Abs("data/stats.json")
	if err != nil {
		logger.Error("获取统计文件绝对路径失败", "path", "data/stats.json", "error", err)
		return
	}

	// 创建数据目录
	statsDir := filepath.Dir(statsFilePath)
	err = os.MkdirAll(statsDir, 0755)
	if err != nil {
		logger.Error("创建统计数据目录失败", "dir", statsDir, "error", err)
		return
	}

	// 收集所有统计数据
	statsData := &StatsData{
		Stats:     s.GetStats(),
		LastSaved: time.Now(),
	}

	// 复制域名数据
	s.blockedDomainsMutex.RLock()
	statsData.BlockedDomains = make(map[string]*BlockedDomain)
	for k, v := range s.blockedDomains {
		statsData.BlockedDomains[k] = v
	}
	s.blockedDomainsMutex.RUnlock()

	s.resolvedDomainsMutex.RLock()
	statsData.ResolvedDomains = make(map[string]*BlockedDomain)
	for k, v := range s.resolvedDomains {
		statsData.ResolvedDomains[k] = v
	}
	s.resolvedDomainsMutex.RUnlock()

	s.hourlyStatsMutex.RLock()
	statsData.HourlyStats = make(map[string]int64)
	for k, v := range s.hourlyStats {
		statsData.HourlyStats[k] = v
	}
	s.hourlyStatsMutex.RUnlock()

	s.dailyStatsMutex.RLock()
	statsData.DailyStats = make(map[string]int64)
	for k, v := range s.dailyStats {
		statsData.DailyStats[k] = v
	}
	s.dailyStatsMutex.RUnlock()

	s.monthlyStatsMutex.RLock()
	statsData.MonthlyStats = make(map[string]int64)
	for k, v := range s.monthlyStats {
		statsData.MonthlyStats[k] = v
	}
	s.monthlyStatsMutex.RUnlock()

	// 复制客户端统计数据
	s.clientStatsMutex.RLock()
	statsData.ClientStats = make(map[string]*ClientStats)
	for k, v := range s.clientStats {
		statsData.ClientStats[k] = v
	}
	s.clientStatsMutex.RUnlock()

	// 序列化数据
	jsonData, err := json.MarshalIndent(statsData, "", "  ")
	if err != nil {
		logger.Error("序列化统计数据失败", "error", err)
		return
	}

	// 写入文件
	err = os.WriteFile(statsFilePath, jsonData, 0644)
	if err != nil {
		logger.Error("保存统计数据到文件失败", "file", statsFilePath, "error", err)
		return
	}

	logger.Info("统计数据保存成功", "file", statsFilePath)

	// 保存查询日志到文件
	s.saveQueryLogs(statsDir)
}

// saveQueryLogs 保存查询日志到文件
func (s *Server) saveQueryLogs(dataDir string) {
	// 构建查询日志文件路径
	queryLogPath := filepath.Join(dataDir, "querylog.json")

	// 获取查询日志数据
	s.queryLogsMutex.RLock()
	logsCopy := make([]QueryLog, len(s.queryLogs))
	copy(logsCopy, s.queryLogs)
	s.queryLogsMutex.RUnlock()

	// 序列化数据
	jsonData, err := json.MarshalIndent(logsCopy, "", "  ")
	if err != nil {
		logger.Error("序列化查询日志失败", "error", err)
		return
	}

	// 写入文件
	err = os.WriteFile(queryLogPath, jsonData, 0644)
	if err != nil {
		logger.Error("保存查询日志到文件失败", "file", queryLogPath, "error", err)
		return
	}

	logger.Info("查询日志保存成功", "file", queryLogPath)
}

// startCpuUsageMonitor 启动CPU使用率监控
func (s *Server) startCpuUsageMonitor() {
	ticker := time.NewTicker(time.Second * 5) // 每5秒更新一次CPU使用率
	defer ticker.Stop()

	// 初始化
	var memStats runtime.MemStats
	runtime.ReadMemStats(&memStats)

	// 存储上一次的CPU时间统计
	var prevIdle, prevTotal uint64

	for {
		select {
		case <-ticker.C:
			// 获取真实的系统级CPU使用率
			cpuUsage, err := getSystemCpuUsage(&prevIdle, &prevTotal)
			if err != nil {
				// 如果获取失败，使用默认值
				cpuUsage = 0.0
				logger.Error("获取系统CPU使用率失败", "error", err)
			}

			s.updateStats(func(stats *Stats) {
				stats.CpuUsage = cpuUsage
			})
		case <-s.ctx.Done():
			return
		}
	}
}

// getSystemCpuUsage 获取系统CPU使用率
func getSystemCpuUsage(prevIdle, prevTotal *uint64) (float64, error) {
	// 读取/proc/stat文件获取CPU统计信息
	file, err := os.Open("/proc/stat")
	if err != nil {
		return 0, err
	}
	defer file.Close()

	var cpuUser, cpuNice, cpuSystem, cpuIdle, cpuIowait, cpuIrq, cpuSoftirq, cpuSteal uint64
	_, err = fmt.Fscanf(file, "cpu %d %d %d %d %d %d %d %d",
		&cpuUser, &cpuNice, &cpuSystem, &cpuIdle, &cpuIowait, &cpuIrq, &cpuSoftirq, &cpuSteal)
	if err != nil {
		return 0, err
	}

	// 计算总的CPU时间
	total := cpuUser + cpuNice + cpuSystem + cpuIdle + cpuIowait + cpuIrq + cpuSoftirq + cpuSteal
	idle := cpuIdle + cpuIowait

	// 第一次调用时，只初始化值，不计算使用率
	if *prevTotal == 0 || *prevIdle == 0 {
		*prevIdle = idle
		*prevTotal = total
		return 0, nil
	}

	// 计算CPU使用率
	idleDelta := idle - *prevIdle
	totalDelta := total - *prevTotal
	utilization := float64(totalDelta-idleDelta) / float64(totalDelta) * 100

	// 更新上一次的值
	*prevIdle = idle
	*prevTotal = total

	return utilization, nil
}

// startAutoSave 启动自动保存功能
func (s *Server) startAutoSave() {
	if s.config.SaveInterval <= 0 {
		return
	}

	// 初始化定时器
	s.saveTicker = time.NewTicker(time.Duration(s.config.SaveInterval) * time.Second)
	defer s.saveTicker.Stop()

	logger.Info("启动统计数据自动保存功能", "interval", s.config.SaveInterval, "file", "data/stats.json")

	// 定期保存数据
	for {
		select {
		case <-s.saveTicker.C:
			s.saveStatsData()
		case <-s.saveDone:
			return
		}
	}
}
