// api/v1/webapp_types.go
package v1

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

// WebAppSpec defines the desired state of WebApp.
type WebAppSpec struct {
    // Replicas is the desired number of nginx Pods.
    // +kubebuilder:validation:Minimum=1
    // +kubebuilder:validation:Maximum=10
    // +kubebuilder:default=1
    Replicas int32 `json:"replicas,omitempty"`

    // Image is the nginx container image (repository:tag).
    // +kubebuilder:default="nginx:1.25.3"
    // +kubebuilder:validation:MinLength=1
    Image string `json:"image,omitempty"`

    // Message is the HTML body text served by nginx.
    // +kubebuilder:validation:MinLength=1
    // +kubebuilder:validation:MaxLength=500
    Message string `json:"message"`

    // Port is the container port nginx listens on.
    // +kubebuilder:validation:Minimum=1
    // +kubebuilder:validation:Maximum=65535
    // +kubebuilder:default=80
    Port int32 `json:"port,omitempty"`

    // ServiceType controls how the Service is exposed.
    // +kubebuilder:validation:Enum=ClusterIP;NodePort;LoadBalancer
    // +kubebuilder:default=ClusterIP
    ServiceType string `json:"serviceType,omitempty"`
}

// WebAppPhase is a simple enum for the overall lifecycle state.
// +kubebuilder:validation:Enum=Pending;Running;Degraded;Failed
type WebAppPhase string

const (
    WebAppPhasePending  WebAppPhase = "Pending"
    WebAppPhaseRunning  WebAppPhase = "Running"
    WebAppPhaseDegraded WebAppPhase = "Degraded"
    WebAppPhaseFailed   WebAppPhase = "Failed"
)

// WebAppStatus defines the observed state of WebApp.
type WebAppStatus struct {
    // AvailableReplicas is the number of Pods in the Ready state.
    AvailableReplicas int32 `json:"availableReplicas,omitempty"`

    // ReadyReplicas is the number of Pods that have passed readiness checks.
    ReadyReplicas int32 `json:"readyReplicas,omitempty"`

    // Phase is a high-level summary of the WebApp lifecycle.
    Phase WebAppPhase `json:"phase,omitempty"`

    // DeploymentName is the name of the managed Deployment.
    DeploymentName string `json:"deploymentName,omitempty"`

    // ServiceName is the name of the managed Service.
    ServiceName string `json:"serviceName,omitempty"`

    // Conditions holds standard API conditions.
    // +listType=map
    // +listMapKey=type
    Conditions []metav1.Condition `json:"conditions,omitempty"`
}

// Condition type constants
const (
    // ConditionTypeAvailable means the WebApp has at least one ready pod.
    ConditionTypeAvailable = "Available"
    // ConditionTypeProgressing means a rollout or scale is in progress.
    ConditionTypeProgressing = "Progressing"
    // ConditionTypeDegraded means some (but not all) replicas are ready.
    ConditionTypeDegraded = "Degraded"
)

//+kubebuilder:object:root=true
//+kubebuilder:subresource:status
//+kubebuilder:resource:shortName=wa,categories=all
//+kubebuilder:printcolumn:name="Replicas",type=integer,JSONPath=".spec.replicas"
//+kubebuilder:printcolumn:name="Available",type=integer,JSONPath=".status.availableReplicas"
//+kubebuilder:printcolumn:name="Phase",type=string,JSONPath=".status.phase"
//+kubebuilder:printcolumn:name="Image",type=string,JSONPath=".spec.image"
//+kubebuilder:printcolumn:name="Age",type=date,JSONPath=".metadata.creationTimestamp"

// WebApp is the Schema for the webapps API.
// It provisions a Deployment, Service, and ConfigMap that serve the configured HTML page.
type WebApp struct {
    metav1.TypeMeta   `json:",inline"`
    metav1.ObjectMeta `json:"metadata,omitempty"`

    Spec   WebAppSpec   `json:"spec,omitempty"`
    Status WebAppStatus `json:"status,omitempty"`
}

//+kubebuilder:object:root=true

// WebAppList contains a list of WebApp.
type WebAppList struct {
    metav1.TypeMeta `json:",inline"`
    metav1.ListMeta `json:"metadata,omitempty"`
    Items           []WebApp `json:"items"`
}

func init() {
    SchemeBuilder.Register(&WebApp{}, &WebAppList{})
}

// internal/controller/webapp_controller.go
package controller

import (
    "context"
    "fmt"

    appsv1 "k8s.io/api/apps/v1"
    corev1 "k8s.io/api/core/v1"
    "k8s.io/apimachinery/pkg/api/errors"
    "k8s.io/apimachinery/pkg/api/meta"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/apimachinery/pkg/runtime"
    "k8s.io/apimachinery/pkg/types"
    ctrl "sigs.k8s.io/controller-runtime"
    "sigs.k8s.io/controller-runtime/pkg/client"
    "sigs.k8s.io/controller-runtime/pkg/log"

    webappv1 "codewizard.io/webapp-operator/api/v1"
)

// WebAppReconciler reconciles a WebApp object.
type WebAppReconciler struct {
    client.Client
    Scheme *runtime.Scheme
}

// RBAC markers - these generate config/rbac/role.yaml when `make manifests` is run.
//
//+kubebuilder:rbac:groups=apps.codewizard.io,resources=webapps,verbs=get;list;watch;create;update;patch;delete
//+kubebuilder:rbac:groups=apps.codewizard.io,resources=webapps/status,verbs=get;update;patch
//+kubebuilder:rbac:groups=apps.codewizard.io,resources=webapps/finalizers,verbs=update
//+kubebuilder:rbac:groups=apps,resources=deployments,verbs=get;list;watch;create;update;patch;delete
//+kubebuilder:rbac:groups=core,resources=services,verbs=get;list;watch;create;update;patch;delete
//+kubebuilder:rbac:groups=core,resources=configmaps,verbs=get;list;watch;create;update;patch;delete
//+kubebuilder:rbac:groups=core,resources=events,verbs=create;patch

// Reconcile is the main reconciliation loop.
// It is called whenever a WebApp CR (or a resource it owns) changes.
func (r *WebAppReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
    logger := log.FromContext(ctx)

    // ── Step 1: Fetch the WebApp instance ────────────────────────────────────
    webapp := &webappv1.WebApp{}
    if err := r.Get(ctx, req.NamespacedName, webapp); err != nil {
        if errors.IsNotFound(err) {
            // Object was deleted before we could reconcile - nothing to do.
            logger.Info("WebApp not found, likely deleted", "name", req.Name)
            return ctrl.Result{}, nil
        }
        return ctrl.Result{}, fmt.Errorf("fetching WebApp: %w", err)
    }

    logger.Info("Reconciling WebApp",
        "name", webapp.Name,
        "namespace", webapp.Namespace,
        "replicas", webapp.Spec.Replicas)

    // ── Step 2: Reconcile ConfigMap (HTML content) ───────────────────────────
    if err := r.reconcileConfigMap(ctx, webapp); err != nil {
        return ctrl.Result{}, fmt.Errorf("reconciling ConfigMap: %w", err)
    }

    // ── Step 3: Reconcile Deployment ─────────────────────────────────────────
    deployment, err := r.reconcileDeployment(ctx, webapp)
    if err != nil {
        return ctrl.Result{}, fmt.Errorf("reconciling Deployment: %w", err)
    }

    // ── Step 4: Reconcile Service ─────────────────────────────────────────────
    if err := r.reconcileService(ctx, webapp); err != nil {
        return ctrl.Result{}, fmt.Errorf("reconciling Service: %w", err)
    }

    // ── Step 5: Update Status ─────────────────────────────────────────────────
    if err := r.updateStatus(ctx, webapp, deployment); err != nil {
        return ctrl.Result{}, fmt.Errorf("updating status: %w", err)
    }

    return ctrl.Result{}, nil
}

// ── reconcileConfigMap ensures the HTML ConfigMap exists and is up-to-date. ──

func (r *WebAppReconciler) reconcileConfigMap(ctx context.Context, webapp *webappv1.WebApp) error {
    logger := log.FromContext(ctx)

    desired := &corev1.ConfigMap{
        ObjectMeta: metav1.ObjectMeta{
            Name:      webapp.Name + "-html",
            Namespace: webapp.Namespace,
            Labels:    labelsForWebApp(webapp.Name),
        },
        Data: map[string]string{
            "index.html": fmt.Sprintf(`<!DOCTYPE html>
<html>
<head><title>%s</title></head>
<body>
  <h1>%s</h1>
  <p>Managed by the <strong>WebApp Operator</strong> | Instance: %s</p>
</body>
</html>`, webapp.Spec.Message, webapp.Spec.Message, webapp.Name),
        },
    }

    // Set the WebApp as the owner of the ConfigMap.
    // When the WebApp CR is deleted, Kubernetes garbage-collects the ConfigMap automatically.
    if err := ctrl.SetControllerReference(webapp, desired, r.Scheme); err != nil {
        return err
    }

    // Fetch the existing ConfigMap
    existing := &corev1.ConfigMap{}
    err := r.Get(ctx, types.NamespacedName{Name: desired.Name, Namespace: desired.Namespace}, existing)
    if errors.IsNotFound(err) {
        logger.Info("Creating ConfigMap", "name", desired.Name)
        return r.Create(ctx, desired)
    }
    if err != nil {
        return err
    }

    // Update if the content has changed
    if existing.Data["index.html"] != desired.Data["index.html"] {
        existing.Data = desired.Data
        logger.Info("Updating ConfigMap", "name", existing.Name)
        return r.Update(ctx, existing)
    }

    return nil
}

// ── reconcileDeployment ensures the nginx Deployment exists and matches spec. ──

func (r *WebAppReconciler) reconcileDeployment(ctx context.Context, webapp *webappv1.WebApp) (*appsv1.Deployment, error) {
    logger := log.FromContext(ctx)

    labels := labelsForWebApp(webapp.Name)
    replicas := webapp.Spec.Replicas

    desired := &appsv1.Deployment{
        ObjectMeta: metav1.ObjectMeta{
            Name:      webapp.Name,
            Namespace: webapp.Namespace,
            Labels:    labels,
        },
        Spec: appsv1.DeploymentSpec{
            Replicas: &replicas,
            Selector: &metav1.LabelSelector{MatchLabels: labels},
            Template: corev1.PodTemplateSpec{
                ObjectMeta: metav1.ObjectMeta{Labels: labels},
                Spec: corev1.PodSpec{
                    Containers: []corev1.Container{
                        {
                            Name:            "nginx",
                            Image:           webapp.Spec.Image,
                            ImagePullPolicy: corev1.PullIfNotPresent,
                            Ports: []corev1.ContainerPort{
                                {ContainerPort: webapp.Spec.Port, Protocol: corev1.ProtocolTCP},
                            },
                            VolumeMounts: []corev1.VolumeMount{
                                {
                                    Name:      "html",
                                    MountPath: "/usr/share/nginx/html",
                                },
                            },
                            ReadinessProbe: &corev1.Probe{
                                ProbeHandler: corev1.ProbeHandler{
                                    HTTPGet: &corev1.HTTPGetAction{
                                        Path: "/",
                                        Port: intOrString(webapp.Spec.Port),
                                    },
                                },
                                InitialDelaySeconds: 5,
                                PeriodSeconds:       10,
                            },
                            LivenessProbe: &corev1.Probe{
                                ProbeHandler: corev1.ProbeHandler{
                                    HTTPGet: &corev1.HTTPGetAction{
                                        Path: "/",
                                        Port: intOrString(webapp.Spec.Port),
                                    },
                                },
                                InitialDelaySeconds: 15,
                                PeriodSeconds:       20,
                            },
                        },
                    },
                    Volumes: []corev1.Volume{
                        {
                            Name: "html",
                            VolumeSource: corev1.VolumeSource{
                                ConfigMap: &corev1.ConfigMapVolumeSource{
                                    LocalObjectReference: corev1.LocalObjectReference{
                                        Name: webapp.Name + "-html",
                                    },
                                },
                            },
                        },
                    },
                },
            },
        },
    }

    if err := ctrl.SetControllerReference(webapp, desired, r.Scheme); err != nil {
        return nil, err
    }

    existing := &appsv1.Deployment{}
    err := r.Get(ctx, types.NamespacedName{Name: desired.Name, Namespace: desired.Namespace}, existing)
    if errors.IsNotFound(err) {
        logger.Info("Creating Deployment", "name", desired.Name)
        if err := r.Create(ctx, desired); err != nil {
            return nil, err
        }
        return desired, nil
    }
    if err != nil {
        return nil, err
    }

    // Reconcile mutable fields: replicas and image
    needsUpdate := false
    if *existing.Spec.Replicas != replicas {
        existing.Spec.Replicas = &replicas
        needsUpdate = true
    }
    if existing.Spec.Template.Spec.Containers[0].Image != webapp.Spec.Image {
        existing.Spec.Template.Spec.Containers[0].Image = webapp.Spec.Image
        needsUpdate = true
    }

    if needsUpdate {
        logger.Info("Updating Deployment", "name", existing.Name,
            "replicas", replicas, "image", webapp.Spec.Image)
        if err := r.Update(ctx, existing); err != nil {
            return nil, err
        }
    }

    return existing, nil
}

// ── reconcileService ensures the Service exists and matches spec. ──────────────

func (r *WebAppReconciler) reconcileService(ctx context.Context, webapp *webappv1.WebApp) error {
    logger := log.FromContext(ctx)

    labels := labelsForWebApp(webapp.Name)
    svcType := corev1.ServiceType(webapp.Spec.ServiceType)

    desired := &corev1.Service{
        ObjectMeta: metav1.ObjectMeta{
            Name:      webapp.Name,
            Namespace: webapp.Namespace,
            Labels:    labels,
        },
        Spec: corev1.ServiceSpec{
            Selector: labels,
            Type:     svcType,
            Ports: []corev1.ServicePort{
                {
                    Port:       webapp.Spec.Port,
                    TargetPort: intOrString(webapp.Spec.Port),
                    Protocol:   corev1.ProtocolTCP,
                },
            },
        },
    }

    if err := ctrl.SetControllerReference(webapp, desired, r.Scheme); err != nil {
        return err
    }

    existing := &corev1.Service{}
    err := r.Get(ctx, types.NamespacedName{Name: desired.Name, Namespace: desired.Namespace}, existing)
    if errors.IsNotFound(err) {
        logger.Info("Creating Service", "name", desired.Name)
        return r.Create(ctx, desired)
    }
    if err != nil {
        return err
    }

    // Reconcile Service type (immutable field - recreate required)
    if existing.Spec.Type != svcType {
        logger.Info("Recreating Service due to type change", "old", existing.Spec.Type, "new", svcType)
        if err := r.Delete(ctx, existing); err != nil {
            return err
        }
        return r.Create(ctx, desired)
    }

    return nil
}

// ── updateStatus computes and persists the WebApp status. ───────────────────────

func (r *WebAppReconciler) updateStatus(ctx context.Context, webapp *webappv1.WebApp, deployment *appsv1.Deployment) error {
    // Work on a copy to avoid mutating the cached object
    updated := webapp.DeepCopy()

    available := deployment.Status.AvailableReplicas
    ready := deployment.Status.ReadyReplicas

    updated.Status.AvailableReplicas = available
    updated.Status.ReadyReplicas = ready
    updated.Status.DeploymentName = deployment.Name
    updated.Status.ServiceName = webapp.Name

    // Compute phase
    switch {
    case available == 0:
        updated.Status.Phase = webappv1.WebAppPhasePending
    case ready < webapp.Spec.Replicas:
        updated.Status.Phase = webappv1.WebAppPhaseDegraded
    default:
        updated.Status.Phase = webappv1.WebAppPhaseRunning
    }

    // Set the Available condition
    availableCond := metav1.Condition{
        Type:               webappv1.ConditionTypeAvailable,
        ObservedGeneration: webapp.Generation,
        LastTransitionTime: metav1.Now(),
    }
    if available >= webapp.Spec.Replicas {
        availableCond.Status = metav1.ConditionTrue
        availableCond.Reason = "DeploymentAvailable"
        availableCond.Message = fmt.Sprintf("%d/%d replicas are available", available, webapp.Spec.Replicas)
    } else {
        availableCond.Status = metav1.ConditionFalse
        availableCond.Reason = "DeploymentUnavailable"
        availableCond.Message = fmt.Sprintf("only %d/%d replicas are available", available, webapp.Spec.Replicas)
    }
    meta.SetStatusCondition(&updated.Status.Conditions, availableCond)

    // Only issue an update if anything changed
    if updated.Status.Phase != webapp.Status.Phase ||
        updated.Status.AvailableReplicas != webapp.Status.AvailableReplicas {
        return r.Status().Update(ctx, updated)
    }

    return nil
}

// ── SetupWithManager wires the controller into the manager. ─────────────────────

func (r *WebAppReconciler) SetupWithManager(mgr ctrl.Manager) error {
    return ctrl.NewControllerManagedBy(mgr).
        // Primary watch: WebApp CRs
        For(&webappv1.WebApp{}).
        // Secondary watches: owned resources - any change triggers reconciliation
        Owns(&appsv1.Deployment{}).
        Owns(&corev1.Service{}).
        Owns(&corev1.ConfigMap{}).
        Complete(r)
}

// ── Helpers ───────────────────────────────────────────────────────────────────────

func labelsForWebApp(name string) map[string]string {
    return map[string]string{
        "app.kubernetes.io/name":       "webapp",
        "app.kubernetes.io/instance":   name,
        "app.kubernetes.io/managed-by": "webapp-operator",
    }
}

func intOrString(port int32) intstr.IntOrString {
    return intstr.FromInt32(port)
}

const webappFinalizer = "apps.codewizard.io/finalizer"

// ── Finalizer handling ────────────────────────────────────────────────────────
if webapp.DeletionTimestamp.IsZero() {
    // Not being deleted - ensure finalizer is present
    if !controllerutil.ContainsFinalizer(webapp, webappFinalizer) {
        controllerutil.AddFinalizer(webapp, webappFinalizer)
        if err := r.Update(ctx, webapp); err != nil {
            return ctrl.Result{}, err
        }
        return ctrl.Result{}, nil  // re-queue after update
    }
} else {
    // Being deleted - run cleanup before allowing deletion
    if controllerutil.ContainsFinalizer(webapp, webappFinalizer) {
        logger.Info("Running finalizer cleanup", "name", webapp.Name)
        // (perform any external cleanup here, e.g. cloud resources, DNS records)

        // Remove finalizer - Kubernetes will then delete the object
        controllerutil.RemoveFinalizer(webapp, webappFinalizer)
        if err := r.Update(ctx, webapp); err != nil {
            return ctrl.Result{}, err
        }
    }
    return ctrl.Result{}, nil
}

func (r *WebApp) Default() {
    log := logf.Log.WithName("webapp-resource")
    log.Info("Applying defaults", "name", r.Name)

    // Set default image if not provided
    if r.Spec.Image == "" {
        r.Spec.Image = "nginx:1.25.3"
    }

    // Set default replicas
    if r.Spec.Replicas == 0 {
        r.Spec.Replicas = 1
    }

    // Set default port
    if r.Spec.Port == 0 {
        r.Spec.Port = 80
    }

    // Set default service type
    if r.Spec.ServiceType == "" {
        r.Spec.ServiceType = "ClusterIP"
    }
}

func (r *WebApp) ValidateCreate() (admission.Warnings, error) {
    return r.validateWebApp()
}

func (r *WebApp) ValidateUpdate(old runtime.Object) (admission.Warnings, error) {
    return r.validateWebApp()
}

func (r *WebApp) ValidateDelete() (admission.Warnings, error) {
    return nil, nil
}

func (r *WebApp) validateWebApp() (admission.Warnings, error) {
    var errs field.ErrorList

    // Replicas must be between 1 and 10
    if r.Spec.Replicas < 1 || r.Spec.Replicas > 10 {
        errs = append(errs, field.Invalid(
            field.NewPath("spec", "replicas"),
            r.Spec.Replicas,
            "must be between 1 and 10",
        ))
    }

    // Message must not be empty
    if r.Spec.Message == "" {
        errs = append(errs, field.Required(
            field.NewPath("spec", "message"),
            "message is required and cannot be empty",
        ))
    }

    if len(errs) > 0 {
        return nil, apierrors.NewInvalid(
            schema.GroupKind{Group: "apps.codewizard.io", Kind: "WebApp"},
            r.Name,
            errs,
        )
    }

    return nil, nil
}

package controller

import (
    "context"
    "time"

    . "github.com/onsi/ginkgo/v2"
    . "github.com/onsi/gomega"
    appsv1 "k8s.io/api/apps/v1"
    corev1 "k8s.io/api/core/v1"
    "k8s.io/apimachinery/pkg/types"

    webappv1 "codewizard.io/webapp-operator/api/v1"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

var _ = Describe("WebApp Controller", func() {
    const (
        WebAppName      = "test-webapp"
        WebAppNamespace = "default"
        timeout         = time.Second * 30
        interval        = time.Millisecond * 250
    )

    ctx := context.Background()

    Context("When creating a WebApp", func() {
        It("should create a Deployment, Service and ConfigMap", func() {
            // ── Create the WebApp CR ────────────────────────────────────────
            webapp := &webappv1.WebApp{
                ObjectMeta: metav1.ObjectMeta{
                    Name:      WebAppName,
                    Namespace: WebAppNamespace,
                },
                Spec: webappv1.WebAppSpec{
                    Replicas:    2,
                    Image:       "nginx:1.25.3",
                    Message:     "Hello from test",
                    Port:        80,
                    ServiceType: "ClusterIP",
                },
            }
            Expect(k8sClient.Create(ctx, webapp)).To(Succeed())

            // ── Assert: Deployment is created ────────────────────────────────
            deploymentLookup := types.NamespacedName{Name: WebAppName, Namespace: WebAppNamespace}
            createdDeployment := &appsv1.Deployment{}

            Eventually(func() error {
                return k8sClient.Get(ctx, deploymentLookup, createdDeployment)
            }, timeout, interval).Should(Succeed())

            Expect(*createdDeployment.Spec.Replicas).To(Equal(int32(2)))
            Expect(createdDeployment.Spec.Template.Spec.Containers[0].Image).To(Equal("nginx:1.25.3"))

            // ── Assert: Service is created ───────────────────────────────────
            createdService := &corev1.Service{}
            Eventually(func() error {
                return k8sClient.Get(ctx, deploymentLookup, createdService)
            }, timeout, interval).Should(Succeed())

            Expect(createdService.Spec.Type).To(Equal(corev1.ServiceTypeClusterIP))

            // ── Assert: ConfigMap is created ─────────────────────────────────
            cmLookup := types.NamespacedName{Name: WebAppName + "-html", Namespace: WebAppNamespace}
            createdCM := &corev1.ConfigMap{}
            Eventually(func() error {
                return k8sClient.Get(ctx, cmLookup, createdCM)
            }, timeout, interval).Should(Succeed())

            Expect(createdCM.Data["index.html"]).To(ContainSubstring("Hello from test"))
        })

        It("should update the Deployment when replicas change", func() {
            // Patch replicas from 2 → 4
            webapp := &webappv1.WebApp{}
            Expect(k8sClient.Get(ctx, types.NamespacedName{
                Name:      WebAppName,
                Namespace: WebAppNamespace,
            }, webapp)).To(Succeed())

            webapp.Spec.Replicas = 4
            Expect(k8sClient.Update(ctx, webapp)).To(Succeed())

            // Assert Deployment reflects new replica count
            Eventually(func() int32 {
                dep := &appsv1.Deployment{}
                _ = k8sClient.Get(ctx, types.NamespacedName{
                    Name:      WebAppName,
                    Namespace: WebAppNamespace,
                }, dep)
                return *dep.Spec.Replicas
            }, timeout, interval).Should(Equal(int32(4)))
        })

        It("should update the ConfigMap when message changes", func() {
            webapp := &webappv1.WebApp{}
            Expect(k8sClient.Get(ctx, types.NamespacedName{
                Name:      WebAppName,
                Namespace: WebAppNamespace,
            }, webapp)).To(Succeed())

            webapp.Spec.Message = "Updated message via test"
            Expect(k8sClient.Update(ctx, webapp)).To(Succeed())

            Eventually(func() string {
                cm := &corev1.ConfigMap{}
                _ = k8sClient.Get(ctx, types.NamespacedName{
                    Name:      WebAppName + "-html",
                    Namespace: WebAppNamespace,
                }, cm)
                return cm.Data["index.html"]
            }, timeout, interval).Should(ContainSubstring("Updated message via test"))
        })
    })
})