package checker

import (
	"context"
	"fmt"

	sdk "git.happydns.org/checker-sdk-go/checker"
)

// loadXMPPData fetches the XMPP observation. On error, returns a CheckState
// the caller should emit to short-circuit its rule.
func loadXMPPData(ctx context.Context, obs sdk.ObservationGetter) (*XMPPData, *sdk.CheckState) {
	var data XMPPData
	if err := obs.Get(ctx, ObservationKeyXMPP, &data); err != nil {
		return nil, &sdk.CheckState{
			Status:  sdk.StatusError,
			Message: fmt.Sprintf("failed to load XMPP observation: %v", err),
			Code:    "xmpp.observation_error",
		}
	}
	return &data, nil
}

// wantsFromOpts reads the "mode" option and returns (wantC2S, wantS2S).
// Defaults to "both" when unset or invalid.
func wantsFromOpts(opts sdk.CheckerOptions) (bool, bool) {
	mode, _ := sdk.GetOption[string](opts, "mode")
	if mode == "" {
		mode = "both"
	}
	return mode != "s2s", mode != "c2s"
}

// statesFromIssues turns a list of derived Issues into CheckStates.
func statesFromIssues(issues []Issue) []sdk.CheckState {
	out := make([]sdk.CheckState, 0, len(issues))
	for _, is := range issues {
		out = append(out, issueToState(is))
	}
	return out
}

func issueToState(is Issue) sdk.CheckState {
	st := sdk.CheckState{
		Status:  severityToStatus(is.Severity),
		Message: is.Message,
		Code:    is.Code,
		Subject: is.Endpoint,
	}
	if is.Fix != "" {
		st.Meta = map[string]any{"fix": is.Fix}
	}
	return st
}

func passState(code, message string) sdk.CheckState {
	return sdk.CheckState{Status: sdk.StatusOK, Message: message, Code: code}
}

func notTestedState(code, message string) sdk.CheckState {
	return sdk.CheckState{Status: sdk.StatusUnknown, Message: message, Code: code}
}

func severityToStatus(sev string) sdk.Status {
	switch sev {
	case SeverityCrit:
		return sdk.StatusCrit
	case SeverityWarn:
		return sdk.StatusWarn
	case SeverityInfo:
		return sdk.StatusInfo
	default:
		return sdk.StatusOK
	}
}

// filterIssuesByCodes returns only the issues whose Code is in the given set,
// preserving their original order.
func filterIssuesByCodes(issues []Issue, codes ...string) []Issue {
	if len(codes) == 0 || len(issues) == 0 {
		return nil
	}
	set := make(map[string]struct{}, len(codes))
	for _, c := range codes {
		set[c] = struct{}{}
	}
	var out []Issue
	for _, is := range issues {
		if _, ok := set[is.Code]; ok {
			out = append(out, is)
		}
	}
	return out
}