/*
Copyright 2026.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package controller

import (
	"context"
	"errors"
	"time"

	databasev1alpha1 "git.ddupan.top/panxiao81/postgresql-tenant-operator/api/v1alpha1"
	ctrl "sigs.k8s.io/controller-runtime"
)

type instancePhaseHandler func(context.Context, *databasev1alpha1.PostgreSQLInstance) (ctrl.Result, error)

type instanceStateMachine struct {
	instances PostgreSQLInstances
	handlers  map[databasev1alpha1.PostgreSQLInstancePhase]instancePhaseHandler
}

func newInstanceStateMachine(instances PostgreSQLInstances) *instanceStateMachine {
	m := &instanceStateMachine{instances: instances}
	m.handlers = map[databasev1alpha1.PostgreSQLInstancePhase]instancePhaseHandler{
		databasev1alpha1.PostgreSQLInstancePhasePending:              m.pending,
		databasev1alpha1.PostgreSQLInstancePhaseValidating:           m.validate,
		databasev1alpha1.PostgreSQLInstancePhaseInitializingRegistry: m.initializeRegistry,
		databasev1alpha1.PostgreSQLInstancePhaseReady:                m.ready,
		databasev1alpha1.PostgreSQLInstancePhaseDeleting:             m.deleting,
	}
	return m
}

func (m *instanceStateMachine) reconcile(ctx context.Context, instance *databasev1alpha1.PostgreSQLInstance) (ctrl.Result, error) {
	// Dispatch exactly one handler from the persisted checkpoint. A handler performs
	// its state action and returns the next checkpoint for the Reconciler to save.
	phase := instance.Status.Phase
	if !instance.DeletionTimestamp.IsZero() {
		phase = databasev1alpha1.PostgreSQLInstancePhaseDeleting
	} else if phase == "" {
		phase = databasev1alpha1.PostgreSQLInstancePhasePending
	}
	handler, found := m.handlers[phase]
	if !found {
		handler = m.pending
	}
	result, err := handler(ctx, instance)
	if err != nil {
		instance.Status.ObservedGeneration = instance.Generation
		reason := databasev1alpha1.ReasonDependencyUnavailable
		var categorized interface{ ConditionReason() string }
		if errors.As(err, &categorized) {
			reason = categorized.ConditionReason()
		}
		setFailedCondition(&instance.Status.Conditions, instance.Generation, reason, "instance dependency validation failed")
	}
	return result, err
}

func (m *instanceStateMachine) pending(_ context.Context, instance *databasev1alpha1.PostgreSQLInstance) (ctrl.Result, error) {
	// Persist intent before the next reconcile opens external connections.
	return advanceInstance(instance, databasev1alpha1.PostgreSQLInstancePhaseValidating,
		"instance dependencies are being validated"), nil
}

func (m *instanceStateMachine) validate(ctx context.Context, instance *databasev1alpha1.PostgreSQLInstance) (ctrl.Result, error) {
	version, err := m.instances.Validate(ctx, instance)
	if err != nil {
		return ctrl.Result{}, err
	}
	instance.Status.PostgreSQLVersion = version
	return advanceInstance(instance, databasev1alpha1.PostgreSQLInstancePhaseInitializingRegistry,
		"PostgreSQL registry is being initialized"), nil
}

func (m *instanceStateMachine) initializeRegistry(ctx context.Context, instance *databasev1alpha1.PostgreSQLInstance) (ctrl.Result, error) {
	version, err := m.instances.InitializeRegistry(ctx, instance)
	if err != nil {
		return ctrl.Result{}, err
	}
	instance.Status.PostgreSQLVersion = version
	instance.Status.Phase = databasev1alpha1.PostgreSQLInstancePhaseReady
	instance.Status.ObservedGeneration = instance.Generation
	setReadyCondition(&instance.Status.Conditions, instance.Generation, "instance dependencies are ready")
	return ctrl.Result{RequeueAfter: time.Minute}, nil
}

func (m *instanceStateMachine) ready(ctx context.Context, instance *databasev1alpha1.PostgreSQLInstance) (ctrl.Result, error) {
	if instance.Status.ObservedGeneration != instance.Generation {
		return m.pending(ctx, instance)
	}
	version, err := m.instances.Validate(ctx, instance)
	if err != nil {
		instance.Status.Phase = databasev1alpha1.PostgreSQLInstancePhaseValidating
		return ctrl.Result{}, err
	}
	instance.Status.PostgreSQLVersion = version
	return ctrl.Result{RequeueAfter: time.Minute}, nil
}

func (m *instanceStateMachine) deleting(_ context.Context, instance *databasev1alpha1.PostgreSQLInstance) (ctrl.Result, error) {
	m.instances.Forget(instance.Name)
	instance.Status.Phase = databasev1alpha1.PostgreSQLInstancePhaseDeleting
	setReconcilingCondition(&instance.Status.Conditions, instance.Generation, "instance deletion is reconciling")
	return ctrl.Result{}, nil
}

func advanceInstance(instance *databasev1alpha1.PostgreSQLInstance, phase databasev1alpha1.PostgreSQLInstancePhase, message string) ctrl.Result {
	instance.Status.Phase = phase
	setReconcilingCondition(&instance.Status.Conditions, instance.Generation, message)
	return ctrl.Result{RequeueAfter: time.Millisecond}
}