// Package v1 定义DCScaler CRD的v1版本API
package v1

import (
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

// -------------------------- 子结构体：云厂商适配配置 --------------------------
// CloudProviderSpec 定义多云厂商适配层配置，实现阿里云/ AWS/华为云解耦
// 设计核心：抽象统一接口，新增云厂商仅需扩展该结构体，不改动核心逻辑
type CloudProviderSpec struct {
	// 云厂商类型：aliyun/aws/huaweicloud（必填）
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:Enum=aliyun;aws;huaweicloud
	ProviderType string `json:"providerType"`

	// 阿里云专属配置（仅ProviderType=aliyun时生效）
	// +kubebuilder:validation:Optional
	Aliyun *AliyunSpec `json:"aliyun,omitempty"`

	// AWS专属配置（仅ProviderType=aws时生效）
	// +kubebuilder:validation:Optional
	AWS *AWSSpec `json:"aws,omitempty"`

	// 华为云专属配置（仅ProviderType=huaweicloud时生效）
	// +kubebuilder:validation:Optional
	HuaweiCloud *HuaweiCloudSpec `json:"huaweiCloud,omitempty"`

	// 云厂商凭证引用（通用），存储AK/SK的Secret名称
	// +kubebuilder:validation:Required
	CredentialSecretRef SecretRef `json:"credentialSecretRef"`
}

// AliyunSpec 阿里云弹性伸缩（ESS）专属配置
type AliyunSpec struct {
	// 伸缩组ID（必填）
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:Pattern=`^sg-[a-zA-Z0-9]{8,32}$`
	ScalingGroupId string `json:"scalingGroupId"`

	// 地域ID（必填，如cn-hangzhou）
	// +kubebuilder:validation:Required
	RegionId string `json:"regionId"`

	// 伸缩冷却时间（秒），避免频繁伸缩
	// +kubebuilder:validation:Optional
	// +kubebuilder:default=300
	CoolDownSeconds int32 `json:"coolDownSeconds,omitempty"`
}

// AWSSpec AWS Auto Scaling Group专属配置
type AWSSpec struct {
	// ASG名称（必填）
	// +kubebuilder:validation:Required
	AutoScalingGroupName string `json:"autoScalingGroupName"`

	// 区域（必填，如us-west-2）
	// +kubebuilder:validation:Required
	Region string `json:"region"`
}

// HuaweiCloudSpec 华为云Auto Scaling专属配置
type HuaweiCloudSpec struct {
	// 伸缩组ID（必填）
	// +kubebuilder:validation:Required
	ScalingGroupId string `json:"scalingGroupId"`

	// 区域ID（必填，如cn-north-4）
	// +kubebuilder:validation:Required
	Region string `json:"region"`
}

// SecretRef 引用存储云厂商AK/SK的K8s Secret
type SecretRef struct {
	// Secret名称（必填）
	// +kubebuilder:validation:Required
	Name string `json:"name"`

	// AK对应的Secret Key（可选，默认access-key-id）
	// +kubebuilder:default="access-key-id"
	AccessKeyIdKey string `json:"accessKeyIdKey,omitempty"`

	// SK对应的Secret Key（可选，默认access-key-secret）
	// +kubebuilder:default="access-key-secret"
	AccessKeySecretKey string `json:"accessKeySecretKey,omitempty"`
}

// -------------------------- 子结构体：定时伸缩策略 --------------------------
// CronPolicySpec 定时伸缩策略（适配零售/电商潮汐流量：早/午/晚高峰）
type CronPolicySpec struct {
	// 策略名称（必填，唯一标识）
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:Pattern=`^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$`
	Name string `json:"name"`

	// Cron表达式（秒 分 时 日 月 周，必填）
	// 示例："0 0 8 * * *"（早8点扩容）、"0 0 23 * * *"（晚11点缩容）
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:Pattern=`^(\*|([0-5]?\d))\s+(\*|([0-5]?\d))\s+(\*|([01]?\d|2[0-3]))\s+(\*|([1-9]|[12]\d|3[01]))\s+(\*|([1-9]|1[0-2]))\s+(\*|([0-6]))$`
	Schedule string `json:"schedule"`

	// 目标Pod副本数（必填）
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:Minimum=0
	TargetPodReplicas int32 `json:"targetPodReplicas"`

	// 目标节点池实例数（必填，联动云厂商伸缩组）
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:Minimum=0
	TargetNodeCount int32 `json:"targetNodeCount"`

	// 是否仅执行一次（适配临时促销活动）
	// +kubebuilder:default=false
	RunOnce bool `json:"runOnce,omitempty"`

	// 排除日期（节假日/系统割接，可选）
	// 示例：["* * * 1-7 1 *"]（1月1-7日不执行）
	// +kubebuilder:validation:Optional
	ExcludeDates []string `json:"excludeDates,omitempty"`
}

// -------------------------- 子结构体：触发式伸缩策略 --------------------------
// TriggerPolicySpec 触发式伸缩策略（适配突发性流量：QPS/CPU/内存阈值）
type TriggerPolicySpec struct {
	// 策略名称（必填）
	// +kubebuilder:validation:Required
	Name string `json:"name"`

	// 触发类型（必填）
	// +kubebuilder:validation:Enum=CPUUtilization;MemoryUtilization;ALBQPS;CLBQPS
	TriggerType string `json:"triggerType"`

	// 阈值（必填，如80表示CPU利用率80%）
	// +kubebuilder:validation:Required
	Threshold float64 `json:"threshold"`

	// 触发动作（必填）
	// +kubebuilder:validation:Enum=ScaleUp;ScaleDown
	Action string `json:"action"`

	// 伸缩幅度（必填，百分比/固定值）
	// +kubebuilder:validation:Required
	ScaleStep ScaleStepSpec `json:"scaleStep"`

	// 持续时间（秒），指标持续超过阈值才触发（避免抖动）
	// +kubebuilder:default=60
	DurationSeconds int32 `json:"durationSeconds,omitempty"`
}

// ScaleStepSpec 伸缩幅度配置
type ScaleStepSpec struct {
	// 类型（百分比/固定值）
	// +kubebuilder:validation:Enum=Percent;Fixed
	Type string `json:"type"`

	// 数值（如10表示10%/10个副本）
	// +kubebuilder:validation:Minimum=1
	Value int32 `json:"value"`
}

// -------------------------- 子结构体：告警联动策略 --------------------------
// AlertPolicySpec 告警联动策略（适配异常流量：节点故障/Pod异常）
type AlertPolicySpec struct {
	// 策略名称（必填）
	// +kubebuilder:validation:Required
	Name string `json:"name"`

	// 告警源（必填）
	// +kubebuilder:validation:Enum=Prometheus;CloudMonitor;AlertManager
	AlertSource string `json:"alertSource"`

	// 告警规则名称（必填）
	// +kubebuilder:validation:Required
	AlertRule string `json:"alertRule"`

	// 告警级别（必填）
	// +kubebuilder:validation:Enum=Critical;Warning;Info
	Severity string `json:"severity"`

	// 伸缩策略（必填）
	// +kubebuilder:validation:Required
	ScalePolicy ScalePolicySpec `json:"scalePolicy"`

	// 告警恢复后是否缩容
	// +kubebuilder:default=true
	ScaleDownOnRecover bool `json:"scaleDownOnRecover,omitempty"`
}

// ScalePolicySpec 告警触发的伸缩策略
type ScalePolicySpec struct {
	// 目标Pod副本数（优先级高于幅度）
	// +kubebuilder:Optional
	TargetPodReplicas *int32 `json:"targetPodReplicas,omitempty"`

	// 伸缩幅度（可选）
	// +kubebuilder:Optional
	ScaleStep *ScaleStepSpec `json:"scaleStep,omitempty"`
}

// -------------------------- 子结构体：自愈策略 --------------------------
// SelfHealPolicySpec 故障自愈策略（节点NotReady/伸缩操作失败/配置漂移）
type SelfHealPolicySpec struct {
	// 启用自愈（必填）
	// +kubebuilder:default=true
	Enabled bool `json:"enabled,omitempty"`

	// 最大重试次数（必填）
	// +kubebuilder:default=5
	MaxRetryCount int32 `json:"maxRetryCount,omitempty"`

	// 指数退避初始间隔（秒）
	// +kubebuilder:default=1
	InitialRetryIntervalSeconds int32 `json:"initialRetryIntervalSeconds,omitempty"`

	// 配置漂移检测周期（分钟）
	// +kubebuilder:default=10
	ConfigDriftCheckIntervalMinutes int32 `json:"configDriftCheckIntervalMinutes,omitempty"`

	// 节点故障自愈配置
	// +kubebuilder:Optional
	NodeFailure *NodeFailureHealSpec `json:"nodeFailure,omitempty"`
}

// NodeFailureHealSpec 节点故障自愈配置
type NodeFailureHealSpec struct {
	// 节点NotReady阈值（分钟）
	// +kubebuilder:default=5
	NotReadyThresholdMinutes int32 `json:"notReadyThresholdMinutes,omitempty"`

	// 是否自动替换故障节点
	// +kubebuilder:default=true
	AutoReplaceNode bool `json:"autoReplaceNode,omitempty"`
}

// -------------------------- 子结构体：多集群配置 --------------------------
// MultiClusterSpec 多集群统一管控配置
type MultiClusterSpec struct {
	// 集群列表（必填）
	// +kubebuilder:validation:Required
	Clusters []ClusterSpec `json:"clusters"`

	// 灰度策略（可选）
	// +kubebuilder:Optional
	CanaryPolicy *CanaryPolicySpec `json:"canaryPolicy,omitempty"`
}

// ClusterSpec 单个集群配置
type ClusterSpec struct {
	// 集群ID（必填）
	// +kubebuilder:validation:Required
	ClusterId string `json:"clusterId"`

	// 目标资源引用（必填）
	// +kubebuilder:validation:Required
	ScaleTargetRef ScaleTargetRef `json:"scaleTargetRef"`

	// 权重（灰度用）
	// +kubebuilder:default=100
	Weight int32 `json:"weight,omitempty"`
}

// CanaryPolicySpec 多集群灰度策略
type CanaryPolicySpec struct {
	// 灰度集群ID列表
	// +kubebuilder:validation:Required
	CanaryClusterIds []string `json:"canaryClusterIds"`

	// 灰度比例（%）
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:Maximum=100
	Ratio int32 `json:"ratio"`

	// 灰度等待时间（分钟）
	// +kubebuilder:default=10
	WaitMinutes int32 `json:"waitMinutes,omitempty"`
}

// ScaleTargetRef 目标K8s资源引用（Deployment/StatefulSet）
type ScaleTargetRef struct {
	// 资源类型（必填）
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:Enum=Deployment;StatefulSet
	Kind string `json:"kind"`

	// 资源名称（必填）
	// +kubebuilder:validation:Required
	Name string `json:"name"`

	// 命名空间（默认与CR同命名空间）
	// +kubebuilder:Optional
	Namespace string `json:"namespace,omitempty"`
}

// -------------------------- 子结构体：全局伸缩限制 --------------------------
// GlobalScaleLimitsSpec 全局伸缩限制（防止过度扩容/缩容）
type GlobalScaleLimitsSpec struct {
	// 最小Pod副本数（必填）
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:Minimum=0
	MinPodReplicas int32 `json:"minPodReplicas"`

	// 最大Pod副本数（必填）
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:GreaterThanOrEqualToField=MinPodReplicas
	MaxPodReplicas int32 `json:"maxPodReplicas"`

	// 最小节点数（必填）
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:Minimum=0
	MinNodeCount int32 `json:"minNodeCount"`

	// 最大节点数（必填）
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:GreaterThanOrEqualToField=MinNodeCount
	MaxNodeCount int32 `json:"maxNodeCount"`
}

// -------------------------- 子结构体：执行记录 --------------------------
// PolicyExecutionRecord 单个策略的执行记录
type PolicyExecutionRecord struct {
	// 策略名称
	PolicyName string `json:"policyName"`

	// 策略类型（Cron/Trigger/Alert）
	PolicyType string `json:"policyType"`

	// 执行状态（Success/Failed/Pending）
	// +kubebuilder:validation:Enum=Success;Failed;Pending
	State string `json:"state"`

	// 执行时间
	ExecutionTime *metav1.Time `json:"executionTime,omitempty"`

	// 执行详情/错误信息
	Message string `json:"message,omitempty"`

	// 关联集群ID
	ClusterId string `json:"clusterId,omitempty"`
}

// SelfHealRecord 自愈操作记录
type SelfHealRecord struct {
	// 自愈类型（NodeFailure/ConfigDrift/ScaleFailed）
	HealType string `json:"healType"`

	// 状态（Success/Failed/InProgress）
	State string `json:"state"`

	// 触发时间
	TriggerTime *metav1.Time `json:"triggerTime,omitempty"`

	// 自愈详情
	Message string `json:"message,omitempty"`
}

// -------------------------- 核心子结构体：Spec（期望状态） --------------------------
// DCScalerSpec DataCenterScaler的期望状态（全链路弹性策略）
type DCScalerSpec struct {
	// 多集群配置（必填）
	// +kubebuilder:validation:Required
	MultiCluster MultiClusterSpec `json:"multiCluster"`

	// 云厂商配置（必填）
	// +kubebuilder:validation:Required
	CloudProvider CloudProviderSpec `json:"cloudProvider"`

	// 定时伸缩策略列表（可选）
	// +kubebuilder:validation:Optional
	CronPolicies []CronPolicySpec `json:"cronPolicies,omitempty"`

	// 触发式伸缩策略列表（可选）
	// +kubebuilder:validation:Optional
	TriggerPolicies []TriggerPolicySpec `json:"triggerPolicies,omitempty"`

	// 告警联动策略列表（可选）
	// +kubebuilder:validation:Optional
	AlertPolicies []AlertPolicySpec `json:"alertPolicies,omitempty"`

	// 自愈策略（可选）
	// +kubebuilder:validation:Optional
	SelfHealPolicy *SelfHealPolicySpec `json:"selfHealPolicy,omitempty"`

	// 全局伸缩限制（必填）
	// +kubebuilder:validation:Required
	GlobalScaleLimits GlobalScaleLimitsSpec `json:"globalScaleLimits"`
}

// -------------------------- 核心子结构体：Status（实际状态） --------------------------
// DCScalerStatus DataCenterScaler的实际状态（仅Controller回写）
type DCScalerStatus struct {
	// 整体状态（Ready/Error/Processing）
	// +kubebuilder:validation:Enum=Ready;Error;Processing
	Phase string `json:"phase,omitempty"`

	// 最近一次执行时间
	LastExecutionTime *metav1.Time `json:"lastExecutionTime,omitempty"`

	// 下一次定时策略执行时间
	NextCronExecutionTime *metav1.Time `json:"nextCronExecutionTime,omitempty"`

	// 当前Pod副本数（各集群汇总）
	CurrentPodReplicas map[string]int32 `json:"currentPodReplicas,omitempty"`

	// 当前节点数（各集群汇总）
	CurrentNodeCount map[string]int32 `json:"currentNodeCount,omitempty"`

	// 策略执行记录（最近20条）
	PolicyExecutionRecords []PolicyExecutionRecord `json:"policyExecutionRecords,omitempty"`

	// 自愈操作记录（最近10条）
	SelfHealRecords []SelfHealRecord `json:"selfHealRecords,omitempty"`

	// 配置漂移检测结果
	ConfigDriftStatus string `json:"configDriftStatus,omitempty"`

	// 错误信息（整体错误）
	Error string `json:"error,omitempty"`
}

// -------------------------- 顶层结构体：DCScaler --------------------------
// +kubebuilder:object:root=true
// +kubebuilder:subresource:status
// +kubebuilder:resource:shortName=dcscaler;dcscale
// +kubebuilder:printcolumn:name="Phase",type="string",JSONPath=".status.phase"
// +kubebuilder:printcolumn:name="LastExec",type="date",JSONPath=".status.lastExecutionTime"
// +kubebuilder:printcolumn:name="NextExec",type="date",JSONPath=".status.nextCronExecutionTime"
// +kubebuilder:printcolumn:name="Clusters",type="integer",JSONPath=".spec.multiCluster.clusters | length"
// +kubebuilder:printcolumn:name="Age",type="date",JSONPath=".metadata.creationTimestamp"

// DCScaler 是多云多集群数据中心级全链路弹性伸缩的核心CRD
// 覆盖定时/触发/告警/自愈全场景，实现Pod->Node->云厂商伸缩组的协同伸缩
type DCScaler struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   DCScalerSpec   `json:"spec,omitempty"`
	Status DCScalerStatus `json:"status,omitempty"`
}

// +kubebuilder:object:root=true

// DCScalerList DCScaler的列表类型
type DCScalerList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []DCScaler `json:"items"`
}

// SchemeBuilder 用于注册API类型
var (
	SchemeBuilder = metav1.NewSchemeBuilder(addKnownTypes)
	AddToScheme   = SchemeBuilder.AddToScheme
)

// addKnownTypes 注册API类型到Scheme
func addKnownTypes(scheme *runtime.Scheme) error {
	scheme.AddKnownTypes(SchemeGroupVersion,
		&DCScaler{},
		&DCScalerList{},
	)
	metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
	return nil
}

// 注册到Scheme（兼容kubebuilder自动生成逻辑）
func init() {
	SchemeBuilder.Register(&DCScaler{}, &DCScalerList{})
}

// 补充SchemeGroupVersion定义（需与你的Operator API组/版本匹配）
const (
	// Group 定义API组
	Group = "scaler.example.com"
	// Version 定义API版本
	Version = "v1"
)

// SchemeGroupVersion API组版本
var SchemeGroupVersion = schema.GroupVersion{Group: Group, Version: Version}

• • • • 分层清晰，职责明确：严格区分 Spec（用户配置）与 Status（运行状态），Spec 聚焦“用户要什么”，整合多集群、多云厂商、全类型伸缩策略，无需拆分配置；Status 聚焦“实际是什么”，由 Controller 自动回写，用户仅需查看无需修改，符合 k8s 声明式设计理念，同时降低运维复杂度。
      • 校验全面，降低故障：通过 Kubebuilder 注释实现“必填+枚举+数值+正则+依赖”全维度校验，从源头杜绝无效配置（如错写云厂商类型、伸缩组 ID 格式错误、最大副本数小于最小副本数等），减少 Controller 运行时异常，提升 CRD 可靠性，适配生产级部署需求。
      • 场景适配，贴合业务：字段设计深度匹配零售/电商核心场景——定时策略支持排除日期，应对节假日、系统割接；触发策略支持 QPS/CPU 阈值，应对突发促销；告警与自愈策略联动，应对节点故障、配置漂移，真正解决原生方案的场景适配短板。
      • 多云友好，易于扩展：抽象 CloudProviderSpec 适配层，核心逻辑与具体云厂商解耦，新增腾讯云、谷歌云等厂商时，仅需扩展对应子结构体，无需改动核心字段与 Controller 逻辑；多集群配置支持灰度策略，适配企业多云部署的标准化运维诉求。
      • 可观测强，运维便捷：Status 字段全面暴露运行状态、执行记录、自愈日志，配合自定义 kubectl 展示列，运维人员通过简单命令即可掌握全链路弹性伸缩情况，无需深入查看日志，大幅降低运维成本，提升问题排查效率。

package controllers

import (
	"context"
	"fmt"
	"time"

	appsv1 "k8s.io/api/apps/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/util/strings"
	ctrl "sigs.k8s.io/controller-runtime"
	"sigs.k8s.io/controller-runtime/pkg/client"
	"sigs.k8s.io/controller-runtime/pkg/log"

	// 自定义API组（DCScaler CRD）
	dcscalerv1 "github.com/your-org/dcscaler/api/v1"
	// 云厂商客户端适配层（需提前实现）
	"github.com/your-org/dcscaler/cloud"
	// 多集群客户端（如kube-multicluster-client）
	"github.com/your-org/dcscaler/multicluster"
	// 配置管理（如Viper）
	"github.com/your-org/dcscaler/config"
)

// ========== 核心：Reconciler结构体（声明所有需要注入的依赖） ==========
type DCScalerReconciler struct {
	client.Client                     // k8s客户端（由Manager注入）
	Scheme               *runtime.Scheme        // 资源Scheme（由Manager注入）
	log                  ctrl.Logger            // 日志组件（由Manager注入）
	Config               *config.GlobalConfig   // 全局配置（外部注入）
	CloudClientFactory   cloud.ClientFactory    // 云厂商客户端工厂（外部注入）
	MultiClusterClient   multicluster.Client    // 多集群客户端（外部注入）
	// 可选：缓存锁（用于分布式并发控制）
	CacheLock            sync.Map               // 本地缓存锁（替代分布式锁，轻量方案）
}

// ========== 第二步：构造函数（依赖注入入口） ==========
// NewDCScalerReconciler 初始化Reconciler，注入外部依赖
func NewDCScalerReconciler(
	mgr ctrl.Manager,                // Manager（核心容器，提供Client/Scheme）
	globalConfig *config.GlobalConfig, // 全局配置（如多集群配置、云厂商密钥）
	cloudFactory cloud.ClientFactory,  // 云厂商客户端工厂（阿里云/腾讯云/华为云）
	mcClient multicluster.Client) *DCScalerReconciler { // 多集群客户端
	return &DCScalerReconciler{
		Client:             mgr.GetClient(),       // 从Manager注入k8s Client
		Scheme:             mgr.GetScheme(),       // 从Manager注入Scheme
		log:                log.FromContext(context.Background()).WithName("dcscaler-controller"), // 日志注入
		Config:             globalConfig,          // 外部配置注入
		CloudClientFactory: cloudFactory,          // 云厂商客户端工厂注入
		MultiClusterClient: mcClient,              // 多集群客户端注入
		CacheLock:          sync.Map{},            // 初始化缓存锁
	}
}

// ========== 核心：Controller初始化（SetupWithManager） ==========
// SetupWithManager 将Controller注册到Manager，完成初始化
func (r *DCScalerReconciler) SetupWithManager(mgr ctrl.Manager) error {
	// 1. 构建Controller：指定监听的CRD类型、配置调和参数
	return ctrl.NewControllerManagedBy(mgr).
		For(&dcscalerv1.DCScaler{}). // 监听DCScaler CRD
		// 可选：关联监听Deployment（Pod副本变化时触发调和）
		Owns(&appsv1.Deployment{}).
		// 配置Controller参数（适配零售/电商场景）
		WithOptions(ctrl.ControllerOptions{
			MaxConcurrentReconciles: 5, // 最大并发调和数（电商场景建议5-10）
			Reconciler:             r,  // 注入当前Reconciler实例
		}).
		// 配置速率限制（避免频繁调和）
		WithRateLimiter(ctrl.NewMaxOfRateLimiter(
			ctrl.NewItemExponentialFailureRateLimiter(10*time.Second, 5*time.Minute),
			&ctrl.BucketRateLimiter{Limiter: rate.NewLimiter(rate.Limit(10), 100)}, // 10 QPS，桶容量100
		)).
		Complete(r) // 完成Controller初始化并注册到Manager
}

package main

import (
	"flag"
	"os"

	// 导入必要的包
	"k8s.io/apimachinery/pkg/runtime"
	_ "k8s.io/client-go/plugin/pkg/client/auth"
	ctrl "sigs.k8s.io/controller-runtime"
	"sigs.k8s.io/controller-runtime/pkg/log/zap"

	// 自定义包
	dcscalerv1 "github.com/your-org/dcscaler/api/v1"
	"github.com/your-org/dcscaler/controllers"
	"github.com/your-org/dcscaler/cloud"
	"github.com/your-org/dcscaler/multicluster"
	"github.com/your-org/dcscaler/config"
)

var (
	scheme   = runtime.NewScheme()
	setupLog = ctrl.Log.WithName("setup")
)

func init() {
	// 1. 注册CRD到Scheme（初始化必备）
	_ = dcscalerv1.AddToScheme(scheme)
	// 2. 注册k8s内置资源到Scheme（如Deployment）
	_ = appsv1.AddToScheme(scheme)
}

func main() {
	// ========== 步骤1：解析命令行参数（配置文件路径） ==========
	var configFile string
	flag.StringVar(&configFile, "config", "", "The path to the DCScaler config file")
	opts := zap.Options{Development: true}
	opts.BindFlags(flag.CommandLine)
	flag.Parse()

	// ========== 步骤2：初始化全局配置（依赖1） ==========
	globalConfig, err := config.LoadConfig(configFile)
	if err != nil {
		setupLog.Error(err, "Failed to load global config")
		os.Exit(1)
	}

	// ========== 步骤3：初始化云厂商客户端工厂（依赖2） ==========
	cloudFactory, err := cloud.NewClientFactory(globalConfig.Cloud)
	if err != nil {
		setupLog.Error(err, "Failed to create cloud client factory")
		os.Exit(1)
	}

	// ========== 步骤4：初始化多集群客户端（依赖3） ==========
	mcClient, err := multicluster.NewClient(globalConfig.MultiCluster)
	if err != nil {
		setupLog.Error(err, "Failed to create multi-cluster client")
		os.Exit(1)
	}

	// ========== 步骤5：初始化Manager（Controller容器） ==========
	mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{
		Scheme:             scheme,
		MetricsBindAddress: globalConfig.Metrics.Addr, // 监控地址
		LeaderElection:     globalConfig.LeaderElection.Enable, // 选主（多副本部署必备）
		LeaderElectionID:   "dcscaler-operator-lock.your-org.com",
		// 可选：设置Cache域（多集群场景优化）
		Namespace: "", // 空表示监听所有命名空间
	})
	if err != nil {
		setupLog.Error(err, "Failed to create manager")
		os.Exit(1)
	}

	// ========== 步骤6：依赖注入 → 初始化Controller ==========
	// 1. 通过构造函数注入所有依赖，创建Reconciler实例
	reconciler := controllers.NewDCScalerReconciler(mgr, globalConfig, cloudFactory, mcClient)
	// 2. 将Controller注册到Manager（完成初始化）
	if err := reconciler.SetupWithManager(mgr); err != nil {
		setupLog.Error(err, "Failed to create controller")
		os.Exit(1)
	}

	// ========== 步骤7：启动Manager（启动所有Controller） ==========
	setupLog.Info("Starting DCScaler operator (retail/e-commerce multi-cloud scale)")
	if err := mgr.Start(ctrl.SetupSignalHandler()); err != nil {
		setupLog.Error(err, "Manager exited non-zero")
		os.Exit(1)
	}
}

// ========== 扩展：接口化依赖（便于测试替换） ==========
// CloudClient 云厂商客户端接口
type CloudClient interface {
	ScaleNodePool(ctx context.Context, scalingGroupID string, targetNode int32) error
	GetNodeCount(ctx context.Context, scalingGroupID string) (int32, error)
}

// 为Reconciler增加Set方法（动态注入依赖）
func (r *DCScalerReconciler) SetCloudClientFactory(factory cloud.ClientFactory) {
	r.CloudClientFactory = factory
}

func (r *DCScalerReconciler) SetMultiClusterClient(client multicluster.Client) {
	r.MultiClusterClient = client
}

// 测试场景使用示例（替换真实云厂商客户端为Mock）
func TestDCScalerReconciler(t *testing.T) {
	// 1. 创建Mock依赖
	mockCloudFactory := cloud.NewMockClientFactory()
	mockMCClient := multicluster.NewMockClient()
	// 2. 初始化Reconciler并注入Mock依赖
	reconciler := &DCScalerReconciler{
		Client:  fake.NewClientBuilder().Build(), // 假Client
		Scheme:  scheme,
		log:     ctrl.Log.WithName("test"),
	}
	// 3. Set方法注入Mock依赖
	reconciler.SetCloudClientFactory(mockCloudFactory)
	reconciler.SetMultiClusterClient(mockMCClient)
	// 4. 执行测试...
}

        Reconcile 是 Controller 的核心核心组件，本质是一套 持续调谐循环 ——通过不断比对 CR 实例的 期望状态（Spec）与集群 实际状态（Status），若两者存在差异，立即执行对应调谐操作缩小偏差，直至状态完全一致；同时负责处理定时、触发、告警等各类伸缩策略的触发逻辑，联动相关 API 完成全链路伸缩操作，全程适配零售/电商场景诉求。
        整体执行流程严格遵循监听事件 → 获取 CR 实例 → 配置校验 → 策略执行 → 状态回写 → 容错重试 的闭环逻辑，核心代码拆解如下，重点突出零售/电商场景的针对性适配细节步：

• • • 多云多集群适配的核心设计
      • 多集群客户端注入：MultiClusterClient 封装跨集群 k8s API 调用逻辑，支持同时管理阿里云 / AWS / 腾讯云 / 华为云等不同云厂商的集群，无需为每个集群写重复代码；
      • 集群状态快照：collectClusterStatusSnapshot 一次性采集所有集群的 Pod / 节点 / 云厂商状态，作为多集群一致性比对的基准，避免跨集群多次调用 API 导致的延迟；
      • 集群级容错：非核心集群伸缩失败时，代码中仅记录错误但不中断整体流程，通过后续 Reconcile 循环自愈，适配零售 / 电商 核心集群优先、非核心集群容错 的诉求。
    • 零售 / 电商场景的关键适配
      • 秒级 Cron 解析：定时策略支持秒级 Cron 表达式（cron.NewParser(cron.Second | ...)），适配 大促整点秒杀 的秒级扩容诉求；
      • 资源协同校验：Pod 数和节点数按「1 节点≈10 Pod」的零售经验值校验，避免资源错配导致的服务不可用；
      • 幂等性保障：通过 ResourceVersion 乐观锁 + 注解记录执行时间，限制 5 分钟内同一策略仅执行一次，避免大促期间重复扩容导致的资源浪费。