/*
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 {
	initializer PostgreSQLInstanceInitializer
	handlers    map[databasev1alpha1.PostgreSQLInstancePhase]instancePhaseHandler
}

func newInstanceStateMachine(initializer PostgreSQLInstanceInitializer) *instanceStateMachine {
	m := &instanceStateMachine{initializer: initializer}
	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) {
	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) {
	return advanceInstance(instance, databasev1alpha1.PostgreSQLInstancePhaseValidating,
		"instance dependencies are being validated"), nil
}

func (m *instanceStateMachine) validate(ctx context.Context, instance *databasev1alpha1.PostgreSQLInstance) (ctrl.Result, error) {
	if m.initializer == nil {
		return ctrl.Result{}, nil
	}
	version, err := m.initializer.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) {
	if m.initializer == nil {
		return ctrl.Result{}, nil
	}
	version, err := m.initializer.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)
	}
	if m.initializer == nil {
		return ctrl.Result{}, nil
	}
	version, err := m.initializer.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) {
	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}
}