package orchestrator

import (
	"context"
	"fmt"
	"log"

	"provisioning/internal/events"
	"provisioning/internal/model"
	"provisioning/internal/statemachine"
	"provisioning/internal/store"
)

type Runner struct {
	Hosts  *store.Hosts
	Ops    *store.Operations
	Locks  *store.Locks
	Hub    *events.Hub
}

func (r *Runner) Transition(ctx context.Context, hostID int64, trigger statemachine.Trigger) (model.HostState, error) {
	host, err := r.Hosts.Get(ctx, hostID)
	if err != nil {
		return "", fmt.Errorf("transition: get host: %w", err)
	}
	next, err := statemachine.Next(host.State, trigger)
	if err != nil {
		return "", fmt.Errorf("transition: %w", err)
	}
	if err := r.Hosts.UpdateState(ctx, hostID, next); err != nil {
		return "", fmt.Errorf("transition: update state: %w", err)
	}
	log.Printf("host %d (%s): %s -> %s [%s]", hostID, host.Hostname, host.State, next, trigger)
	r.Hub.Publish(events.Event{
		Name:    "host.state_changed",
		Payload: fmt.Sprintf(`{"host_id":%d,"old_state":"%s","new_state":"%s"}`, hostID, host.State, next),
	})
	return next, nil
}

func (r *Runner) FailHost(ctx context.Context, hostID int64, reason string) {
	if _, err := r.Transition(ctx, hostID, statemachine.TriggerFailed); err != nil {
		log.Printf("host %d: failed to transition to failed state: %v", hostID, err)
		return
	}
	op, err := r.Ops.GetActive(ctx, hostID)
	if err == nil {
		_ = r.Ops.Fail(ctx, op.ID, reason)
	}
	_ = r.Locks.Release(ctx, hostID)
}