package com.baiyue.eventbridge.metrics;

import com.baiyue.eventbridge.domain.BridgeInbox;
import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
import io.micrometer.core.instrument.MeterRegistry;
import org.junit.jupiter.api.Test;

import java.lang.reflect.Modifier;
import java.util.Arrays;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.mockito.Mockito.mock;

class EventBridgeMetricsTest {

    @Test
    void productionConstructorIsExplicitForSpringWhenTestClockConstructorAlsoExists() throws Exception {
        assertThat(EventBridgeMetrics.class.getConstructor(MeterRegistry.class)
                .isAnnotationPresent(Autowired.class)).isTrue();
    }

    @Test
    void springContextCreatesMetricsBeanWithTheAnnotatedProductionConstructor() {
        try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext()) {
            context.registerBean(MeterRegistry.class, SimpleMeterRegistry::new);
            context.register(EventBridgeMetrics.class);
            context.refresh();

            assertThat(context.getBean(EventBridgeMetrics.class)).isNotNull();
        }
    }

    @Test
    void collapsesUnboundedRegionAndEventTypeLabelsToOther() {
        SimpleMeterRegistry registry = new SimpleMeterRegistry();
        EventBridgeMetrics metrics = new EventBridgeMetrics(registry);
        BridgeInbox event = new BridgeInbox();
        event.setTargetRegion("customer-controlled-region");
        event.setEventType("dynamic-event-123456");

        metrics.recordTransport(event, EventBridgeMetrics.TransportResult.RETRY);

        assertThat(registry.get(EventBridgeMetrics.TRANSPORT_METRIC)
                .tags("target_region", "OTHER", "event_type", "OTHER", "result", "RETRY")
                .counter().count()).isEqualTo(1.0);
        assertThat(registry.getMeters()).allSatisfy(meter -> assertThat(meter.getId().getTags())
                .noneMatch(tag -> tag.getValue().contains("dynamic-event")));
        assertThat(EventBridgeMetrics.eventType(null)).isEqualTo("OTHER");
    }

    @Test
    void everyFrozenEventTypeHasABoundedTagValue() {
        assertThat(Arrays.stream(com.baiyue.common.event.EventTypes.class.getFields())
                .filter(field -> Modifier.isStatic(field.getModifiers()) && field.getType() == String.class)
                .map(field -> {
                    try {
                        return (String) field.get(null);
                    } catch (IllegalAccessException exception) {
                        throw new AssertionError(exception);
                    }
                })).allMatch(value -> EventBridgeMetrics.eventType(value).equals(value));
    }

    @Test
    void metricsFailureDoesNotChangeTransportControlFlow() {
        EventBridgeMetrics metrics = new EventBridgeMetrics(mock(MeterRegistry.class));
        BridgeInbox event = new BridgeInbox();
        event.setTargetRegion("CN");
        event.setEventType(com.baiyue.common.event.EventTypes.OVERSEAS_CONTAINER_UNLOADED);

        assertThatCode(() -> metrics.recordTransport(event, EventBridgeMetrics.TransportResult.RETRY))
                .doesNotThrowAnyException();
    }
}