package lifecycle

import (
	"context"
	"errors"
	"fmt"
	"strings"
	"testing"
)

type testShutdownHook struct {
	errs        map[string]error
	lastFailure error
}

func (h *testShutdownHook) OnShutdownStarted(ctx context.Context) error {
	return h.errs["OnShutdownStarted"]
}

func (h *testShutdownHook) OnModulesStopped(ctx context.Context) error {
	return h.errs["OnModulesStopped"]
}

func (h *testShutdownHook) OnCleanupStarted(ctx context.Context) error {
	return h.errs["OnCleanupStarted"]
}

func (h *testShutdownHook) OnShutdownCompleted(ctx context.Context) error {
	return h.errs["OnShutdownCompleted"]
}

func (h *testShutdownHook) OnShutdownFailed(ctx context.Context, err error) error {
	h.lastFailure = err
	return h.errs["OnShutdownFailed"]
}

func TestShutdownManagerErrorAggregation(t *testing.T) {
	sm := NewShutdownManager(nil, ShutdownConfig{})
	sm.logger = nil

	txHash := "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
	firstErr := fmt.Errorf("first failure on %s", txHash)
	secondErr := errors.New("second")

	sm.recordShutdownError("first error", firstErr)
	sm.recordShutdownError("second error", secondErr)

	if got := len(sm.shutdownErrors); got != 2 {
		t.Fatalf("expected 2 recorded errors, got %d", got)
	}

	combined := sm.combinedShutdownError()
	if combined == nil {
		t.Fatal("expected combined shutdown error, got nil")
	}
	if !errors.Is(combined, firstErr) || !errors.Is(combined, secondErr) {
		t.Fatalf("combined error does not contain original errors: %v", combined)
	}

	exportedErrors := sm.ShutdownErrors()
	if len(exportedErrors) != 2 {
		t.Fatalf("expected exported error slice of length 2, got %d", len(exportedErrors))
	}

	details := sm.ShutdownErrorDetails()
	if len(details) != 2 {
		t.Fatalf("expected error detail slice of length 2, got %d", len(details))
	}
	if details[0].TxHash != txHash {
		t.Fatalf("expected recorded error to track tx hash %s, got %s", txHash, details[0].TxHash)
	}
	if details[0].Err == nil || !strings.Contains(details[0].Err.Error(), "tx_hash="+txHash) {
		t.Fatalf("expected recorded error message to include tx hash, got %v", details[0].Err)
	}
}

func TestShutdownManagerCallHooksAggregatesErrors(t *testing.T) {
	sm := NewShutdownManager(nil, ShutdownConfig{})
	sm.logger = nil
	sm.shutdownErrors = nil

	hookErrA := errors.New("hookA failure")
	hookErrB := errors.New("hookB failure")
	hookA := &testShutdownHook{
		errs: map[string]error{
			"OnShutdownFailed": hookErrA,
		},
	}
	hookB := &testShutdownHook{
		errs: map[string]error{
			"OnShutdownFailed": hookErrB,
		},
	}

	sm.shutdownHooks = []ShutdownHook{hookA, hookB}

	cause := errors.New("original failure")
	err := sm.callHooks(context.Background(), "OnShutdownFailed", cause)
	if err == nil {
		t.Fatal("expected aggregated error from hooks, got nil")
	}
	if !errors.Is(err, hookErrA) || !errors.Is(err, hookErrB) {
		t.Fatalf("expected aggregated error to contain hook failures, got %v", err)
	}
	if hookA.lastFailure != cause || hookB.lastFailure != cause {
		t.Fatal("expected hook to receive original failure cause")
	}
	if len(sm.ShutdownErrors()) != 2 {
		t.Fatalf("expected shutdown errors to be recorded for each hook failure, got %d", len(sm.ShutdownErrors()))
	}
}