stack

type Application struct {
	Name      string
	Namespace string
	Config    ApplicationConfig
}

type ApplicationConfig interface {
	Generate(*Application) ([]*client.Object, error)
}

type ApplicationMetadata struct {
	Name      string            `yaml:"name" json:"name"`
	Namespace string            `yaml:"namespace,omitempty" json:"namespace,omitempty"`
	Labels    map[string]string `yaml:"labels,omitempty" json:"labels,omitempty"`
}

type ApplicationWrapper struct {
	APIVersion string              `yaml:"apiVersion" json:"apiVersion"`
	Kind       string              `yaml:"kind" json:"kind"`
	Metadata   ApplicationMetadata `yaml:"metadata" json:"metadata"`
	Spec       ApplicationConfig   `yaml:"-" json:"-"`
}

type ApplicationWrappers []ApplicationWrapper

type BootstrapConfig struct {
	// Common fields
	Enabled bool `yaml:"enabled"`

	// Flux-specific
	FluxMode        string   `yaml:"fluxMode,omitempty"` // "flux-operator" (default) or "gotk" (legacy)
	FluxVersion     string   `yaml:"fluxVersion,omitempty"`
	Components      []string `yaml:"components,omitempty"`
	Registry        string   `yaml:"registry,omitempty"`
	ImagePullSecret string   `yaml:"imagePullSecret,omitempty"`

	// Source configuration
	SourceKind string `yaml:"sourceKind,omitempty"` // "GitRepository" or "OCIRepository"
	SourceURL  string `yaml:"sourceURL,omitempty"`  // OCI/Git repository URL
	SourceRef  string `yaml:"sourceRef,omitempty"`  // Tag/branch/ref

	// ArgoCD-specific (mock for now)
	ArgoCDVersion   string `yaml:"argoCDVersion,omitempty"`
	ArgoCDNamespace string `yaml:"argoCDNamespace,omitempty"`
}

type Bundle struct {
	// Name identifies the application set.
	Name string
	// ParentPath is the hierarchical path to the parent bundle (e.g., "cluster/infrastructure")
	// Empty for root bundles. This avoids circular references while maintaining hierarchy.
	ParentPath string
	// DependsOn lists other bundles this bundle depends on
	DependsOn []*Bundle
	// Children holds bundles whose Flux Kustomization CRs are rendered into
	// this bundle's tar path and whose readiness is aggregated into this
	// bundle's HealthChecks. When non-empty, this bundle acts as an umbrella:
	// it is Ready only when all Children are Ready. Children bundles must be
	// standalone — they cannot simultaneously be the Bundle of a stack.Node.
	// Setting Wait=false on a bundle with Children is a validation error.
	Children []*Bundle
	// Interval controls how often Flux reconciles the bundle.
	Interval string
	// SourceRef specifies the source for the bundle.
	SourceRef *SourceRef
	// Applications holds the Kubernetes objects that belong to the application.
	Applications []*Application
	// Labels are common labels that should be applied to each resource.
	Labels map[string]string
	// Annotations are common annotations propagated to all generated resources and
	// the generated Kustomization resource. Application-specific annotations take precedence.
	Annotations map[string]string
	// Description provides a human-readable description of the bundle.
	Description string
	// Prune enables garbage collection of resources removed from the bundle.
	Prune *bool
	// Wait causes the Kustomization to wait for resources to become ready.
	Wait *bool
	// Timeout is the maximum duration to wait for resources to be ready (e.g. "5m").
	Timeout string
	// RetryInterval is the interval between retry attempts for failed reconciliations (e.g. "2m").
	RetryInterval string
	// Force causes Flux to re-apply resources even if there are no detected changes.
	Force *bool
	// Suspend disables reconciliation when true. Set to false to resume.
	Suspend *bool
	// HealthChecks lists resources whose health is monitored during reconciliation.
	// When specified, the Kustomization waits for these resources to become ready.
	HealthChecks []HealthCheck
	// Patches lists strategic merge or JSON patches to apply to resources after
	// kustomize build. Each patch targets resources matching its selector.
	Patches []Patch
	// PostBuild configures variable substitution performed after kustomize build.
	PostBuild *PostBuild
	// contains filtered or unexported fields
}

type BundleBuilder interface {
	WithApplication(name string, appConfig ApplicationConfig) BundleBuilder
	WithDependency(bundle *Bundle) BundleBuilder
	WithSourceRef(sourceRef *SourceRef) BundleBuilder
	End() NodeBuilder
	Build() (*Cluster, error)
}

type Cluster struct {
	Name   string        `yaml:"name"`
	Node   *Node         `yaml:"node,omitempty"`
	GitOps *GitOpsConfig `yaml:"gitops,omitempty"`
}

type ClusterBuilder interface {
	WithNode(name string) NodeBuilder
	WithGitOps(gitops *GitOpsConfig) ClusterBuilder
	Build() (*Cluster, error)
}

type GitOpsConfig struct {
	Type      string           `yaml:"type"` // "flux" or "argocd"
	Bootstrap *BootstrapConfig `yaml:"bootstrap,omitempty"`
}

type HealthCheck struct {
	// APIVersion of the resource (e.g. "apps/v1", "helm.toolkit.fluxcd.io/v2").
	APIVersion string
	// Kind of the resource (e.g. "Deployment", "HelmRelease").
	Kind string
	// Name of the resource.
	Name string
	// Namespace of the resource. When empty, defaults to the Kustomization namespace.
	Namespace string
}

type LayoutRulesProvider interface {
	Validate() error
}

type ManifestLayoutResult interface {
	WriteToDisk(basePath string) error
	FullRepoPath() string
}

type Node struct {
	// Name identifies the application set.
	Name string `yaml:"name"`
	// ParentPath is the hierarchical path to the parent node (e.g., "cluster/infrastructure")
	// Empty for root nodes. This avoids circular references while maintaining hierarchy.
	ParentPath string `yaml:"parentPath,omitempty"`
	// Children list child bundles
	Children []*Node `yaml:"children,omitempty"`
	// PackageRef identifies in which package the tree of resources get bundled together
	// If undefined, the PackageRef of the parent is inherited
	PackageRef *schema.GroupVersionKind `yaml:"packageref,omitempty"`
	// Bundle holds the applications that get deployed on this level
	Bundle *Bundle `yaml:"bundle,omitempty"`
	// contains filtered or unexported fields
}

type NodeBuilder interface {
	WithChild(name string) NodeBuilder
	WithBundle(name string) BundleBuilder
	WithPackageRef(ref *schema.GroupVersionKind) NodeBuilder
	End() ClusterBuilder
	Build() (*Cluster, error)
}

type Patch struct {
	// Patch is the patch content in strategic merge patch or JSON patch format.
	Patch string
	// Target selects which resources the patch applies to.
	// When nil the patch applies to all resources.
	Target *PatchSelector
}

type PatchSelector struct {
	// Group of the target resource (e.g. "apps").
	Group string
	// Version of the target resource (e.g. "v1").
	Version string
	// Kind of the target resource (e.g. "Deployment").
	Kind string
	// Name of the target resource.
	Name string
	// Namespace of the target resource.
	Namespace string
	// LabelSelector is a label selector expression.
	LabelSelector string
	// AnnotationSelector is an annotation selector expression.
	AnnotationSelector string
}

type PostBuild struct {
	// Substitute contains inline key-value substitution variables.
	// Values are substituted for ${VAR} occurrences in manifests.
	Substitute map[string]string
	// SubstituteFrom lists ConfigMaps and Secrets whose data is merged into
	// the substitution variables.
	SubstituteFrom []SubstituteRef
}

type SourceRef struct {
	Kind      string
	Name      string
	Namespace string
	// URL is the repository URL (OCI or Git). When set, the resource generator
	// creates the source CRD in addition to referencing it.
	URL string
	// Tag is the tag or semver reference for OCI sources.
	Tag string
	// Branch is the branch reference for Git sources.
	Branch string
}

type SubstituteRef struct {
	// Kind is ConfigMap or Secret.
	Kind string
	// Name of the ConfigMap or Secret.
	Name string
	// Optional allows the reference to be absent without causing an error.
	Optional bool
}

type Validator interface {
	Validate() error
}

type Workflow interface {
	// GenerateFromCluster creates GitOps resources from a cluster definition.
	// This is the primary entry point for resource generation.
	GenerateFromCluster(*Cluster) ([]client.Object, error)

	// CreateLayoutWithResources creates a new manifest layout that includes
	// both the application manifests and the GitOps resources needed to
	// deploy them. This combines manifest generation with GitOps resource
	// generation in a single operation.
	// The rules parameter must be a layout.LayoutRules value.
	// The returned ManifestLayoutResult is a *layout.ManifestLayout.
	CreateLayoutWithResources(*Cluster, LayoutRulesProvider) (ManifestLayoutResult, error)

	// GenerateBootstrap creates bootstrap resources for initializing the
	// GitOps system itself. This is used to set up the GitOps controller
	// (Flux, ArgoCD, etc.) in the cluster.
	GenerateBootstrap(*BootstrapConfig, *Node) ([]client.Object, error)
}