$mask = 0;
foreach ($this->attributes[$spanKind->name] ?? [] as $attribute) {
    // $attribute->m: semantic conventions that do not contain this attribute
    // $attribute->n: semantic conventions that contain this attribute as sampling relevant attribute
    $mask |= array_key_exists($attribute->name, $attributes) ? $attribute->m : $attribute->n;
}

$semanticConventions = [];
foreach ($this->semanticConventions as $i => $semanticConvention) {
    if ($mask & 1 << $i) {
        continue;
    }

    foreach ($attributes as $attribute => $_) {
        if (array_key_exists($attribute, $semanticConvention->attributes)) {
            continue;
        }
        if (array_key_exists(strrchr($attribute, '.') . '.*', $semanticConvention->attributes)) {
            continue;
        }

        continue 2;
    }

    $semanticConventions[] = $semanticConvention->name;
}

#[RetryThreshold(5)]
#[Warmup(100)]
#[Revs(10000)]
#[Iterations(100)]
#[OutputTimeUnit('seconds')]
#[OutputMode('throughput')]
final class SpanSuppressionStrategyBench {

    private readonly SpanBuilderInterface $builder;
    private readonly SpanSuppressor $suppressor;

    public function setupTracer(array $params): void {
        $tp = (new TracerProviderBuilder())
            ->setSampler($params['sampler'])
            ->setSuppressionStrategy($params['strategy'])
            ->build();
        $tracer = $tp->getTracer('bench', schemaUrl: 'https://opentelemetry.io/schemas/1.33.0');
        $this->builder = $tracer->spanBuilder('bench')
            ->setSpanKind($params['apiKind'])
            ->setAttributes($params['attributes']);
    }

    public function setupSuppressor(array $params): void {
        $this->suppressor = $params['strategy']->getSuppressor(new InstrumentationScope('bench', null, 'https://opentelemetry.io/schemas/1.33.0', new Attributes([])));
    }

    #[BeforeMethods('setupTracer')]
    #[ParamProviders(['suppressionStrategies', 'samplers', 'attributes'])]
    public function benchSpanBuilderStart(): void {
        $this->builder->startSpan();
    }

    #[BeforeMethods('setupSuppressor')]
    #[ParamProviders(['suppressionStrategies', 'attributes'])]
    public function benchResolveSuppression(array $params): SpanSuppression {
        return $this->suppressor->resolveSuppression($params['sdkKind'], $params['attributes']);
    }

    public function suppressionStrategies(): iterable {
        yield 'noop' => ['strategy' => new NoopSuppressionStrategy()];
        yield 'spanKind' => ['strategy' => new SpanKindSuppressionStrategy()];
        yield 'semConv' => ['strategy' => new SemanticConventionSuppressionStrategySimple([new SemConvResolver()])];
        yield 'semConv-optimized' => ['strategy' => new SemanticConventionSuppressionStrategy([new SemConvResolver()])];
    }

    public function samplers(): iterable {
        yield 'sampled' => ['sampler' => new AlwaysOnSampler()];
        yield 'dropped' => ['sampler' => new AlwaysOffSampler()];
    }

    public function attributes(): iterable {
        yield 'http' => ['apiKind' => SpanKind::KIND_CLIENT, 'sdkKind' => Kind::Client, 'attributes' => new Attributes([
            'http.request.method' => 'GET',
            'server.address' => 'https://example.com',
            'server.port' => '443',
            'url.full' => 'https://example.com',
            'url.scheme' => 'https',
            'http.request.body.size' => 0,
            'network.peer.address' => '127.0.0.1',
            'network.peer.port' => '443',
            # 'network.type' => 'ipv4',
            'network.protocol.name' => 'http',
            'network.transport' => 'tcp',
            'user_agent.original' => 'i-am-a-test',
        ])];
    }
}