<?php

declare(strict_types=1);

namespace App\Config;

final readonly class QueryEnricherConfig
{
    /**
     * Keep the enrichment vocabulary in the class for now.
     *
     * Important:
     * - This is intentionally NOT externalized yet.
     * - Add or maintain the current project-specific mappings here.
     * - The later move to external config/files can happen separately.
     *
     * Supported shapes:
     *
     * 1) Simple mapping:
     * [
     *     'water hardness' => 'residual hardness',
     *     'device' => 'instrument',
     * ]
     *
     * 2) Small synonym groups:
     * [
     *     ['water hardness', 'residual hardness', 'hardness'],
     *     ['device', 'instrument', 'meter'],
     * ]
     *
     * The public API stays intentionally simple:
     * - getEnrichQueryList(): array<string,string>
     *
     * This keeps QueryEnricher generic while the domain vocabulary
     * deliberately remains inside this class for now.
     *
     * Replace the example entries below with your real project mappings.
     *
     * @var array<int|string, mixed>
     */
    private const ENRICH_QUERY_LIST = [
        'Wasserhärte' => 'Resthärte',
        'Gerät' => 'Modell',
        'Indikator' => 'Chemie',
        'Seminar' => 'Webinar',
        'Schulung' => 'Seminar',
        'Indikatoren' => 'Indikator',
        'Wasserhärte-Grenzwert' => 'Resthärte',
        'Resthärte-Grenzwert' => 'Wasserhärte',
        'Grenzwert' => 'Überwachungsbereich',
        'store'=>'shop'
    ];

    /**
     * Returns a normalized, deduplicated mapping for the QueryEnricher.
     *
     * Output format:
     * [
     *     'term a' => 'term b',
     *     'term c' => 'term d',
     * ]
     *
     * Rules:
     * - ignore empty / invalid values
     * - trim and normalize whitespace
     * - ignore self-mappings
     * - preserve first valid rule if duplicates normalize to the same key
     *
     * @return array<string, string>
     */
    public function getEnrichQueryList(): array
    {
        $normalized = [];

        foreach (self::ENRICH_QUERY_LIST as $key => $value) {
            if (is_array($value)) {
                $this->ingestGroup($normalized, $value);
                continue;
            }

            $left = $this->normalizePhrase(is_string($key) ? $key : '');
            $right = $this->normalizePhrase(is_string($value) ? $value : '');

            if (!$this->isValidPair($left, $right)) {
                continue;
            }

            if (!isset($normalized[$left])) {
                $normalized[$left] = $right;
            }
        }

        return $normalized;
    }

    /**
     * Returns true when at least one valid enrichment rule exists.
     */
    public function hasRules(): bool
    {
        return $this->getEnrichQueryList() !== [];
    }

    /**
     * @param array<string, string> $normalized
     * @param array<int|string, mixed> $group
     */
    private function ingestGroup(array &$normalized, array $group): void
    {
        $items = [];

        foreach ($group as $item) {
            if (!is_string($item)) {
                continue;
            }

            $item = $this->normalizePhrase($item);

            if ($item === '') {
                continue;
            }

            $items[$item] = $item;
        }

        $items = array_values($items);

        if (count($items) < 2) {
            return;
        }

        /**
         * Turn a synonym group into a conservative chain:
         * ['a', 'b', 'c'] => a=>b, b=>c
         *
         * QueryEnricher builds a bidirectional lookup later,
         * so the config output stays intentionally small.
         */
        for ($i = 0, $max = count($items) - 1; $i < $max; $i++) {
            $left = $items[$i];
            $right = $items[$i + 1];

            if (!$this->isValidPair($left, $right)) {
                continue;
            }

            if (!isset($normalized[$left])) {
                $normalized[$left] = $right;
            }
        }
    }

    private function isValidPair(string $left, string $right): bool
    {
        if ($left === '' || $right === '') {
            return false;
        }

        if ($left === $right) {
            return false;
        }

        return true;
    }

    private function normalizePhrase(string $value): string
    {
        $value = trim($value);

        if ($value === '') {
            return '';
        }

        $value = mb_strtolower($value, 'UTF-8');
        $value = preg_replace('/\s+/u', ' ', $value) ?? $value;

        return trim($value);
    }
}