// Code generated by Wire. DO NOT EDIT.

//go:generate go run -mod=mod github.com/google/wire/cmd/wire
//go:build !wireinject
// +build !wireinject

package internal

import (
	"github.com/pika-monitor/pika/internal/config"
	"github.com/pika-monitor/pika/internal/handler"
	"github.com/pika-monitor/pika/internal/service"
	"github.com/pika-monitor/pika/internal/vmclient"
	"github.com/pika-monitor/pika/internal/websocket"
	"go.uber.org/zap"
	"gorm.io/gorm"
	"time"
)

// Injectors from wire.go:

// InitializeApp 初始化应用
func InitializeApp(logger *zap.Logger, db *gorm.DB, cfg *config.AppConfig) (*AppComponents, error) {
	userService := service.NewUserService(logger, cfg)
	oidcService := service.NewOIDCService(logger, cfg)
	gitHubOAuthService := service.NewGitHubOAuthService(logger, cfg)
	accountService := service.NewAccountService(logger, userService, oidcService, gitHubOAuthService, cfg)
	accountHandler := handler.NewAccountHandler(accountService)
	apiKeyService := service.NewApiKeyService(logger, db)
	propertyService := service.NewPropertyService(logger, db)
	alertRuleService := service.NewAlertRuleService(logger, db, propertyService)
	notifier := service.NewNotifier(logger)
	notificationService := service.NewNotificationService(logger, db, propertyService, alertRuleService, notifier)
	trafficService := service.NewTrafficService(logger, db, notificationService)
	vmClient := provideVMClient(cfg, logger)
	metricService := service.NewMetricService(logger, db, propertyService, trafficService, vmClient)
	geoIPService, err := service.NewGeoIPService(logger, cfg)
	if err != nil {
		return nil, err
	}
	agentService := service.NewAgentService(logger, db, apiKeyService, metricService, geoIPService)
	manager := websocket.NewManager(logger)
	monitorService := service.NewMonitorService(logger, db, metricService, manager)
	tamperService := service.NewTamperService(logger, db, manager, notificationService)
	ddnsService := service.NewDDNSService(logger, db, propertyService, manager)
	sshLoginService := service.NewSSHLoginService(logger, db, manager, geoIPService, notificationService)
	agentHandler := handler.NewAgentHandler(logger, agentService, trafficService, metricService, monitorService, tamperService, ddnsService, sshLoginService, apiKeyService, propertyService, manager)
	apiKeyHandler := handler.NewApiKeyHandler(logger, apiKeyService)
	alertService := service.NewAlertService(logger, db, propertyService, alertRuleService, monitorService, notifier)
	alertHandler := handler.NewAlertHandler(logger, alertService)
	alertRuleHandler := handler.NewAlertRuleHandler(logger, alertRuleService, agentService)
	propertyHandler := handler.NewPropertyHandler(logger, propertyService, notifier)
	monitorHandler := handler.NewMonitorHandler(logger, monitorService, metricService, agentService)
	tamperHandler := handler.NewTamperHandler(logger, tamperService)
	dnsProviderHandler := handler.NewDNSProviderHandler(logger, propertyService)
	ddnsHandler := handler.NewDDNSHandler(logger, ddnsService)
	sshLoginHandler := handler.NewSSHLoginHandler(logger, sshLoginService)
	themeService, err := service.NewThemeService(logger, propertyService, cfg)
	if err != nil {
		return nil, err
	}
	themeHandler := handler.NewThemeHandler(logger, themeService)
	webHandler := handler.NewWebHandler(themeService, propertyService)
	publicIPService := service.NewPublicIPService(logger, db, propertyService, manager)
	appComponents := &AppComponents{
		AccountHandler:     accountHandler,
		AgentHandler:       agentHandler,
		ApiKeyHandler:      apiKeyHandler,
		AlertHandler:       alertHandler,
		AlertRuleHandler:   alertRuleHandler,
		PropertyHandler:    propertyHandler,
		MonitorHandler:     monitorHandler,
		TamperHandler:      tamperHandler,
		DNSProviderHandler: dnsProviderHandler,
		DDNSHandler:        ddnsHandler,
		SSHLoginHandler:    sshLoginHandler,
		ThemeHandler:       themeHandler,
		WebHandler:         webHandler,
		AgentService:       agentService,
		TrafficService:     trafficService,
		MetricService:      metricService,
		AlertService:       alertService,
		AlertRuleService:   alertRuleService,
		PropertyService:    propertyService,
		MonitorService:     monitorService,
		ApiKeyService:      apiKeyService,
		TamperService:      tamperService,
		DDNSService:        ddnsService,
		SSHLoginService:    sshLoginService,
		PublicIPService:    publicIPService,
		ThemeService:       themeService,
		WSManager:          manager,
		VMClient:           vmClient,
	}
	return appComponents, nil
}

// wire.go:

// AppComponents 应用组件
type AppComponents struct {
	AccountHandler     *handler.AccountHandler
	AgentHandler       *handler.AgentHandler
	ApiKeyHandler      *handler.ApiKeyHandler
	AlertHandler       *handler.AlertHandler
	AlertRuleHandler   *handler.AlertRuleHandler
	PropertyHandler    *handler.PropertyHandler
	MonitorHandler     *handler.MonitorHandler
	TamperHandler      *handler.TamperHandler
	DNSProviderHandler *handler.DNSProviderHandler
	DDNSHandler        *handler.DDNSHandler
	SSHLoginHandler    *handler.SSHLoginHandler
	ThemeHandler       *handler.ThemeHandler
	WebHandler         *handler.WebHandler

	AgentService     *service.AgentService
	TrafficService   *service.TrafficService
	MetricService    *service.MetricService
	AlertService     *service.AlertService
	AlertRuleService *service.AlertRuleService
	PropertyService  *service.PropertyService
	MonitorService   *service.MonitorService
	ApiKeyService    *service.ApiKeyService
	TamperService    *service.TamperService
	DDNSService      *service.DDNSService
	SSHLoginService  *service.SSHLoginService
	PublicIPService  *service.PublicIPService
	ThemeService     *service.ThemeService

	WSManager *websocket.Manager
	VMClient  *vmclient.VMClient
}

// provideVMClient 提供 VictoriaMetrics 客户端
func provideVMClient(cfg *config.AppConfig, logger *zap.Logger) *vmclient.VMClient {
	// 写入超时默认 10s：VM 抖动时快速失败，未确认消息由探针重放
	// 机制兜底，避免 30s 级别的停滞阻塞探针消息的串行处理
	const defaultWriteTimeout = 10 * time.Second

	if cfg.VictoriaMetrics == nil || !cfg.VictoriaMetrics.Enabled {
		logger.Info("VictoriaMetrics is not enabled, using default configuration")

		return vmclient.NewVMClient("http://localhost:8428", defaultWriteTimeout, 60*time.Second)
	}

	writeTimeout := time.Duration(cfg.VictoriaMetrics.WriteTimeout) * time.Second
	if writeTimeout == 0 {
		writeTimeout = defaultWriteTimeout
	}

	queryTimeout := time.Duration(cfg.VictoriaMetrics.QueryTimeout) * time.Second
	if queryTimeout == 0 {
		queryTimeout = 60 * time.Second
	}

	logger.Info("VictoriaMetrics client initialized", zap.String("url", cfg.VictoriaMetrics.URL), zap.Duration("writeTimeout", writeTimeout), zap.Duration("queryTimeout", queryTimeout))

	return vmclient.NewVMClient(cfg.VictoriaMetrics.URL, writeTimeout, queryTimeout)
}