<?php
declare(strict_types=1);

namespace App;

final class ListingCatalog
{
    private array $tableCache = [];
    private array $columnCache = [];

    public function __construct(private \PDO $pdo)
    {
    }

    public function ensureSchema(): void
    {
        $statements = [
            'CREATE TABLE IF NOT EXISTS listing_categories (
                id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
                slug VARCHAR(120) NOT NULL UNIQUE,
                title VARCHAR(160) NOT NULL,
                category_group ENUM("general","event","place","food","family","partner") NOT NULL DEFAULT "general",
                sort_order SMALLINT UNSIGNED NOT NULL DEFAULT 0,
                created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
                updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
            ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci',
            'CREATE TABLE IF NOT EXISTS listing_places (
                id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
                created_by BIGINT UNSIGNED NULL,
                source_type ENUM("user","partner","admin","system") NOT NULL DEFAULT "user",
                title VARCHAR(180) NOT NULL,
                description TEXT NULL,
                street VARCHAR(180) NULL,
                zip CHAR(5) NULL,
                city VARCHAR(120) NULL,
                region VARCHAR(120) NULL,
                lat DECIMAL(10,7) NULL,
                lng DECIMAL(10,7) NULL,
                website_url VARCHAR(255) NULL,
                phone VARCHAR(60) NULL,
                place_kind VARCHAR(80) NULL,
                opening_hours_note TEXT NULL,
                opening_hours_json LONGTEXT NULL,
                provider_hint ENUM("manual","osm","google") NOT NULL DEFAULT "manual",
                external_place_id VARCHAR(190) NULL,
                google_place_id VARCHAR(190) NULL,
                rating_value DECIMAL(3,2) NULL,
                rating_count INT UNSIGNED NULL,
                status ENUM("draft","published","archived") NOT NULL DEFAULT "published",
                created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
                updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
                CONSTRAINT fk_listing_places_user FOREIGN KEY (created_by) REFERENCES users(id) ON DELETE SET NULL,
                INDEX idx_listing_places_city (city),
                INDEX idx_listing_places_region (region),
                INDEX idx_listing_places_latlng (lat, lng),
                INDEX idx_listing_places_kind (place_kind)
            ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci',
            'CREATE TABLE IF NOT EXISTS listings (
                id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
                created_by BIGINT UNSIGNED NULL,
                owner_type ENUM("user","partner","admin","system") NOT NULL DEFAULT "user",
                listing_type ENUM("event","partner_offer","place","editorial_event") NOT NULL DEFAULT "event",
                primary_place_id BIGINT UNSIGNED NULL,
                title VARCHAR(200) NOT NULL,
                teaser_public VARCHAR(280) NOT NULL,
                description TEXT NOT NULL,
                image_path VARCHAR(255) NULL,
                special_conditions_note TEXT NULL,
                visibility ENUM("public","members") NOT NULL DEFAULT "public",
                status ENUM("draft","published","cancelled","archived") NOT NULL DEFAULT "draft",
                supports_registration TINYINT(1) NOT NULL DEFAULT 0,
                supports_capacity TINYINT(1) NOT NULL DEFAULT 0,
                supports_pricing TINYINT(1) NOT NULL DEFAULT 0,
                is_recurring TINYINT(1) NOT NULL DEFAULT 0,
                legacy_event_id BIGINT UNSIGNED NULL,
                created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
                updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
                CONSTRAINT fk_listings_user FOREIGN KEY (created_by) REFERENCES users(id) ON DELETE SET NULL,
                CONSTRAINT fk_listings_place FOREIGN KEY (primary_place_id) REFERENCES listing_places(id) ON DELETE SET NULL,
                CONSTRAINT fk_listings_legacy_event FOREIGN KEY (legacy_event_id) REFERENCES events(id) ON DELETE SET NULL,
                INDEX idx_listings_type (listing_type),
                INDEX idx_listings_status (status),
                INDEX idx_listings_owner (owner_type)
            ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci',
            'CREATE TABLE IF NOT EXISTS listing_category_map (
                listing_id BIGINT UNSIGNED NOT NULL,
                category_id BIGINT UNSIGNED NOT NULL,
                PRIMARY KEY (listing_id, category_id),
                CONSTRAINT fk_lcm_listing FOREIGN KEY (listing_id) REFERENCES listings(id) ON DELETE CASCADE,
                CONSTRAINT fk_lcm_category FOREIGN KEY (category_id) REFERENCES listing_categories(id) ON DELETE CASCADE
            ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci',
            'CREATE TABLE IF NOT EXISTS listing_occurrences (
                id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
                listing_id BIGINT UNSIGNED NOT NULL,
                occurrence_type ENUM("single","series","range","open_ended") NOT NULL DEFAULT "single",
                starts_at DATETIME NULL,
                ends_at DATETIME NULL,
                recurrence_rule VARCHAR(255) NULL,
                recurrence_until DATETIME NULL,
                capacity_total SMALLINT UNSIGNED NULL,
                booking_url VARCHAR(255) NULL,
                status ENUM("scheduled","cancelled","sold_out") NOT NULL DEFAULT "scheduled",
                created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
                updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
                CONSTRAINT fk_listing_occurrences_listing FOREIGN KEY (listing_id) REFERENCES listings(id) ON DELETE CASCADE,
                INDEX idx_listing_occurrences_start (starts_at),
                INDEX idx_listing_occurrences_type (occurrence_type),
                INDEX idx_listing_occurrences_status (status)
            ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci',
            'CREATE TABLE IF NOT EXISTS listing_prices (
                id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
                listing_id BIGINT UNSIGNED NOT NULL,
                occurrence_id BIGINT UNSIGNED NULL,
                label VARCHAR(120) NOT NULL,
                audience ENUM("general","adult","child","family","group") NOT NULL DEFAULT "general",
                price_type ENUM("free","fixed","from","up_to","range","request") NOT NULL DEFAULT "fixed",
                amount DECIMAL(10,2) NULL,
                amount_secondary DECIMAL(10,2) NULL,
                currency CHAR(3) NOT NULL DEFAULT "EUR",
                note VARCHAR(255) NULL,
                created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
                updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
                CONSTRAINT fk_listing_prices_listing FOREIGN KEY (listing_id) REFERENCES listings(id) ON DELETE CASCADE,
                CONSTRAINT fk_listing_prices_occurrence FOREIGN KEY (occurrence_id) REFERENCES listing_occurrences(id) ON DELETE CASCADE,
                INDEX idx_listing_prices_listing (listing_id)
            ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci',
            'CREATE TABLE IF NOT EXISTS listing_benefits (
                id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
                listing_id BIGINT UNSIGNED NOT NULL,
                occurrence_id BIGINT UNSIGNED NULL,
                benefit_type ENUM("voucher_code","voucher_hint","discount_text") NOT NULL DEFAULT "voucher_hint",
                title VARCHAR(160) NOT NULL,
                code VARCHAR(120) NULL,
                description TEXT NULL,
                valid_from DATETIME NULL,
                valid_until DATETIME NULL,
                is_public TINYINT(1) NOT NULL DEFAULT 1,
                created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
                updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
                CONSTRAINT fk_listing_benefits_listing FOREIGN KEY (listing_id) REFERENCES listings(id) ON DELETE CASCADE,
                CONSTRAINT fk_listing_benefits_occurrence FOREIGN KEY (occurrence_id) REFERENCES listing_occurrences(id) ON DELETE CASCADE,
                INDEX idx_listing_benefits_listing (listing_id)
            ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci',
            'CREATE TABLE IF NOT EXISTS listing_moderation_requests (
                id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
                listing_id BIGINT UNSIGNED NOT NULL,
                request_type ENUM("create","update","delete") NOT NULL,
                request_status ENUM("open","approved","rejected") NOT NULL DEFAULT "open",
                requested_by BIGINT UNSIGNED NOT NULL,
                reviewed_by BIGINT UNSIGNED NULL,
                request_reason TEXT NULL,
                review_note TEXT NULL,
                payload_json LONGTEXT NULL,
                created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
                reviewed_at DATETIME NULL,
                updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
                CONSTRAINT fk_listing_moderation_listing FOREIGN KEY (listing_id) REFERENCES listings(id) ON DELETE CASCADE,
                CONSTRAINT fk_listing_moderation_requested_by FOREIGN KEY (requested_by) REFERENCES users(id) ON DELETE CASCADE,
                CONSTRAINT fk_listing_moderation_reviewed_by FOREIGN KEY (reviewed_by) REFERENCES users(id) ON DELETE SET NULL,
                INDEX idx_listing_moderation_status (request_status),
                INDEX idx_listing_moderation_type (request_type),
                INDEX idx_listing_moderation_user (requested_by)
            ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci',
        ];

        foreach ($statements as $sql) {
            $this->pdo->exec($sql);
        }

        $columnStatements = [
            'listing_places.opening_hours_note' => 'ALTER TABLE listing_places ADD COLUMN opening_hours_note TEXT NULL AFTER place_kind',
            'listing_places.opening_hours_json' => 'ALTER TABLE listing_places ADD COLUMN opening_hours_json LONGTEXT NULL AFTER opening_hours_note',
            'listings.image_path' => 'ALTER TABLE listings ADD COLUMN image_path VARCHAR(255) NULL AFTER description',
            'listings.special_conditions_note' => 'ALTER TABLE listings ADD COLUMN special_conditions_note TEXT NULL AFTER image_path',
        ];
        foreach ($columnStatements as $key => $sql) {
            [$table, $column] = explode('.', $key, 2);
            if (!$this->hasColumn($table, $column)) {
                $this->pdo->exec($sql);
                $this->columnCache[$key] = true;
            }
        }

        $seed = $this->pdo->prepare(
            'INSERT INTO listing_categories (slug, title, category_group, sort_order)
             VALUES (:slug, :title, :groupName, :sortOrder)
             ON DUPLICATE KEY UPDATE title = VALUES(title), category_group = VALUES(category_group), sort_order = VALUES(sort_order), updated_at = CURRENT_TIMESTAMP'
        );
        foreach ($this->defaultCategories() as $index => $category) {
            $seed->execute([
                'slug' => $category['slug'],
                'title' => $category['title'],
                'groupName' => $category['group'],
                'sortOrder' => $index + 1,
            ]);
        }
    }

    public function status(): array
    {
        $tables = [
            'listing_categories',
            'listing_places',
            'listings',
            'listing_category_map',
            'listing_occurrences',
            'listing_prices',
            'listing_benefits',
            'listing_moderation_requests',
        ];
        $missing = [];
        foreach ($tables as $table) {
            if (!$this->hasTable($table)) {
                $missing[] = $table;
            }
        }

        return [
            'complete' => $missing === [],
            'missing' => $missing,
            'tables' => $tables,
        ];
    }

    public function listCategories(?array $groups = null): array
    {
        $this->ensureSchema();
        $params = [];
        $sql = 'SELECT id, slug, title, category_group FROM listing_categories';
        if ($groups && $groups !== []) {
            $placeholders = implode(',', array_fill(0, count($groups), '?'));
            $sql .= " WHERE category_group IN ($placeholders)";
            $params = array_values($groups);
        }
        $sql .= ' ORDER BY sort_order ASC, title ASC';
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute($params);
        return $stmt->fetchAll(\PDO::FETCH_ASSOC) ?: [];
    }

    public function ensureCategoryForInput(string $input, string $group = 'general'): ?array
    {
        $this->ensureSchema();
        $input = trim($input);
        if ($input === '') {
            return null;
        }

        $slug = $this->slugify($input);
        $stmt = $this->pdo->prepare(
            'SELECT id, slug, title, category_group, sort_order
             FROM listing_categories
             WHERE slug = :slug OR LOWER(title) = LOWER(:title)
             ORDER BY sort_order ASC, id ASC
             LIMIT 1'
        );
        $stmt->execute([
            'slug' => $slug,
            'title' => $input,
        ]);
        $existing = $stmt->fetch(\PDO::FETCH_ASSOC);
        if ($existing) {
            $existing['is_new'] = false;
            return $existing;
        }

        $insert = $this->pdo->prepare(
            'INSERT INTO listing_categories (slug, title, category_group, sort_order)
             VALUES (:slug, :title, :groupName, 999)'
        );
        $insert->execute([
            'slug' => $slug,
            'title' => $input,
            'groupName' => in_array($group, ['general', 'event', 'place', 'food', 'family', 'partner'], true) ? $group : 'general',
        ]);

        return [
            'id' => (int)$this->pdo->lastInsertId(),
            'slug' => $slug,
            'title' => $input,
            'category_group' => $group,
            'sort_order' => 999,
            'is_new' => true,
        ];
    }

    public function listCategoryReviewItems(): array
    {
        $this->ensureSchema();
        $stmt = $this->pdo->query(
            'SELECT c.id, c.slug, c.title, c.category_group, c.sort_order,
                    (SELECT COUNT(*) FROM listing_category_map m WHERE m.category_id = c.id) AS listing_count,
                    (SELECT COUNT(*) FROM listing_places p WHERE p.place_kind = c.slug) AS place_count
             FROM listing_categories c
             ORDER BY
               CASE WHEN c.sort_order >= 900 THEN 0 ELSE 1 END,
               c.sort_order ASC,
               c.title ASC'
        );
        $rows = $stmt ? ($stmt->fetchAll(\PDO::FETCH_ASSOC) ?: []) : [];

        $eventStmt = $this->pdo->query('SELECT category_slug, COUNT(*) AS total FROM events WHERE category_slug IS NOT NULL AND category_slug <> "" GROUP BY category_slug');
        $eventCounts = [];
        foreach (($eventStmt ? $eventStmt->fetchAll(\PDO::FETCH_ASSOC) : []) as $row) {
            $eventCounts[(string)$row['category_slug']] = (int)$row['total'];
        }

        foreach ($rows as &$row) {
            $row['event_count'] = $eventCounts[(string)$row['slug']] ?? 0;
            $row['needs_review'] = ((int)($row['sort_order'] ?? 0)) >= 900;
        }
        unset($row);

        return $rows;
    }

    public function mergeCategories(string $sourceSlug, string $targetSlug): void
    {
        $this->ensureSchema();
        $sourceSlug = trim($sourceSlug);
        $targetSlug = trim($targetSlug);
        if ($sourceSlug === '' || $targetSlug === '' || $sourceSlug === $targetSlug) {
            throw new \RuntimeException('Bitte zwei unterschiedliche Kategorien auswählen.');
        }

        $lookup = $this->pdo->prepare('SELECT id, slug FROM listing_categories WHERE slug = :slug LIMIT 1');
        $lookup->execute(['slug' => $sourceSlug]);
        $source = $lookup->fetch(\PDO::FETCH_ASSOC);
        $lookup->execute(['slug' => $targetSlug]);
        $target = $lookup->fetch(\PDO::FETCH_ASSOC);
        if (!$source || !$target) {
            throw new \RuntimeException('Kategorie nicht gefunden.');
        }

        $sourceId = (int)$source['id'];
        $targetId = (int)$target['id'];

        $this->pdo->beginTransaction();
        try {
            $mapRows = $this->pdo->prepare('SELECT listing_id FROM listing_category_map WHERE category_id = :categoryId');
            $mapRows->execute(['categoryId' => $sourceId]);
            $listingIds = $mapRows->fetchAll(\PDO::FETCH_COLUMN) ?: [];
            $insertMap = $this->pdo->prepare(
                'INSERT IGNORE INTO listing_category_map (listing_id, category_id) VALUES (:listingId, :categoryId)'
            );
            foreach ($listingIds as $listingId) {
                $insertMap->execute([
                    'listingId' => (int)$listingId,
                    'categoryId' => $targetId,
                ]);
            }
            $this->pdo->prepare('DELETE FROM listing_category_map WHERE category_id = :categoryId')->execute(['categoryId' => $sourceId]);
            $this->pdo->prepare('UPDATE listing_places SET place_kind = :target WHERE place_kind = :source')->execute([
                'target' => $targetSlug,
                'source' => $sourceSlug,
            ]);
            $this->pdo->prepare('UPDATE events SET category_slug = :target WHERE category_slug = :source')->execute([
                'target' => $targetSlug,
                'source' => $sourceSlug,
            ]);
            $this->pdo->prepare('DELETE FROM listing_categories WHERE id = :id')->execute(['id' => $sourceId]);
            $this->pdo->commit();
        } catch (\Throwable $e) {
            if ($this->pdo->inTransaction()) {
                $this->pdo->rollBack();
            }
            throw $e;
        }
    }

    public function listPublishedDirectoryEntries(): array
    {
        $this->ensureSchema();
        $stmt = $this->pdo->query(
            'SELECT l.id, l.created_by, l.listing_type, l.title, l.teaser_public, l.visibility, l.status, l.image_path,
                    lp.title AS place_title, lp.street, lp.zip, lp.city, lp.region, lp.place_kind,
                    lo.starts_at, lo.ends_at, lo.occurrence_type,
                    lc.title AS category_title, lc.slug AS category_slug
             FROM listings l
             LEFT JOIN listing_places lp ON lp.id = l.primary_place_id
             LEFT JOIN listing_occurrences lo ON lo.listing_id = l.id
             LEFT JOIN listing_category_map lcm ON lcm.listing_id = l.id
             LEFT JOIN listing_categories lc ON lc.id = lcm.category_id
             WHERE l.listing_type IN ("place","editorial_event")
               AND l.status = "published"
               AND (lp.status = "published" OR lp.status IS NULL)
             ORDER BY
               CASE l.listing_type
                 WHEN "place" THEN 1
                 WHEN "editorial_event" THEN 2
                 ELSE 3
               END,
               l.title ASC,
               COALESCE(lo.starts_at, l.created_at) ASC'
        );
        return $stmt ? ($stmt->fetchAll(\PDO::FETCH_ASSOC) ?: []) : [];
    }

    public function listUserSubmittedEntries(int $userId): array
    {
        $this->ensureSchema();
        $stmt = $this->pdo->prepare(
            'SELECT l.id, l.listing_type, l.title, l.teaser_public, l.visibility, l.status, l.image_path,
                    lp.title AS place_title, lp.city, lp.region, lp.place_kind,
                    lo.starts_at, lo.ends_at, lo.occurrence_type,
                    lc.title AS category_title, lc.slug AS category_slug,
                    mr.request_type AS moderation_request_type,
                    mr.request_status AS moderation_request_status,
                    mr.review_note AS moderation_review_note,
                    mr.created_at AS moderation_created_at
             FROM listings l
             LEFT JOIN listing_places lp ON lp.id = l.primary_place_id
             LEFT JOIN listing_occurrences lo ON lo.listing_id = l.id
             LEFT JOIN listing_category_map lcm ON lcm.listing_id = l.id
             LEFT JOIN listing_categories lc ON lc.id = lcm.category_id
             LEFT JOIN listing_moderation_requests mr
               ON mr.id = (
                 SELECT sub.id
                 FROM listing_moderation_requests sub
                 WHERE sub.listing_id = l.id
                 ORDER BY sub.created_at DESC, sub.id DESC
                 LIMIT 1
               )
             WHERE l.created_by = :uid
             ORDER BY
               CASE l.listing_type
                 WHEN "place" THEN 1
                 WHEN "editorial_event" THEN 2
                 ELSE 3
               END,
               COALESCE(lo.starts_at, l.created_at) ASC,
               l.created_at DESC'
        );
        $stmt->execute(['uid' => $userId]);
        return $stmt->fetchAll(\PDO::FETCH_ASSOC) ?: [];
    }

    public function listDashboardEntries(int $userId): array
    {
        return $this->listUserSubmittedEntries($userId);
    }

    public function getMemberEntry(int $listingId): ?array
    {
        $this->ensureSchema();
        $stmt = $this->pdo->prepare(
            'SELECT l.*, lp.title AS place_title, lp.description AS place_description, lp.street, lp.zip, lp.city, lp.region, lp.lat, lp.lng, lp.place_kind, lp.phone, lp.website_url, lp.opening_hours_note, lp.opening_hours_json,
                    lo.id AS occurrence_id, lo.starts_at, lo.ends_at, lo.occurrence_type,
                    lo.recurrence_rule, lo.recurrence_until, lo.capacity_total,
                    lc.slug AS category_slug
             FROM listings l
             LEFT JOIN listing_places lp ON lp.id = l.primary_place_id
             LEFT JOIN listing_occurrences lo ON lo.listing_id = l.id
             LEFT JOIN listing_category_map lcm ON lcm.listing_id = l.id
             LEFT JOIN listing_categories lc ON lc.id = lcm.category_id
             WHERE l.id = :id
             LIMIT 1'
        );
        $stmt->execute(['id' => $listingId]);
        $row = $stmt->fetch(\PDO::FETCH_ASSOC);
        if (!$row) {
            return null;
        }
        $row['prices'] = $this->listPrices((int)$row['id']);
        $row['opening_hours'] = $this->decodeJsonRows((string)($row['opening_hours_json'] ?? ''));
        return $row;
    }

    public function getDashboardEntry(int $userId, int $listingId): ?array
    {
        $row = $this->getMemberEntry($listingId);
        if (!$row || (int)($row['created_by'] ?? 0) !== $userId) {
            return null;
        }
        return $row;
    }

    public function listPlaceSuggestions(int $limit = 40): array
    {
        $this->ensureSchema();
        $stmt = $this->pdo->prepare(
            'SELECT DISTINCT lp.id, lp.title, lp.street, lp.zip, lp.city, lp.region, lp.place_kind
             FROM listing_places lp
             INNER JOIN listings l ON l.primary_place_id = lp.id
             WHERE lp.status IN ("draft","published")
               AND l.status IN ("draft","published")
               AND l.listing_type IN ("place","editorial_event")
             ORDER BY lp.updated_at DESC
             LIMIT :limit'
        );
        $stmt->bindValue(':limit', max(1, min(200, $limit)), \PDO::PARAM_INT);
        $stmt->execute();
        return $stmt->fetchAll(\PDO::FETCH_ASSOC) ?: [];
    }

    public function listEventLocationOptions(int $limit = 80): array
    {
        $this->ensureSchema();
        $stmt = $this->pdo->prepare(
            'SELECT l.id,
                    l.listing_type,
                    l.title,
                    l.status,
                    lp.street,
                    lp.zip,
                    lp.city,
                    lp.region,
                    lp.lat,
                    lp.lng,
                    lp.place_kind,
                    lo.starts_at,
                    lo.recurrence_until,
                    lc.slug AS category_slug,
                    lc.title AS category_title
             FROM listings l
             LEFT JOIN listing_places lp ON lp.id = l.primary_place_id
             LEFT JOIN listing_occurrences lo ON lo.listing_id = l.id
             LEFT JOIN listing_category_map lcm ON lcm.listing_id = l.id
             LEFT JOIN listing_categories lc ON lc.id = lcm.category_id
             WHERE l.listing_type IN ("place","editorial_event")
               AND l.status IN ("draft","published")
               AND (
                 l.listing_type = "place"
                 OR (
                   lo.starts_at IS NOT NULL
                   AND DATE(lo.starts_at) <= CURRENT_DATE()
                   AND (
                     lo.recurrence_until IS NULL
                     OR DATE(lo.recurrence_until) >= CURRENT_DATE()
                   )
                 )
               )
             ORDER BY
               CASE l.listing_type
                 WHEN "place" THEN 1
                 WHEN "editorial_event" THEN 2
                 ELSE 3
               END,
               l.title ASC,
               COALESCE(lo.starts_at, l.created_at) ASC
             LIMIT :limit'
        );
        $stmt->bindValue(':limit', max(1, min(250, $limit)), \PDO::PARAM_INT);
        $stmt->execute();
        return $stmt->fetchAll(\PDO::FETCH_ASSOC) ?: [];
    }

    public function getEventLocationSource(int $listingId): ?array
    {
        $this->ensureSchema();
        $stmt = $this->pdo->prepare(
            'SELECT l.id,
                    l.listing_type,
                    l.title,
                    l.status,
                    lp.street,
                    lp.zip,
                    lp.city,
                    lp.region,
                    lp.lat,
                    lp.lng,
                    lp.place_kind,
                    lo.starts_at,
                    lo.recurrence_until,
                    lc.slug AS category_slug,
                    lc.title AS category_title
             FROM listings l
             LEFT JOIN listing_places lp ON lp.id = l.primary_place_id
             LEFT JOIN listing_occurrences lo ON lo.listing_id = l.id
             LEFT JOIN listing_category_map lcm ON lcm.listing_id = l.id
             LEFT JOIN listing_categories lc ON lc.id = lcm.category_id
             WHERE l.id = :id
               AND l.listing_type IN ("place","editorial_event")
               AND l.status IN ("draft","published")
             LIMIT 1'
        );
        $stmt->execute(['id' => $listingId]);
        $row = $stmt->fetch(\PDO::FETCH_ASSOC);
        return $row ?: null;
    }

    public function listUserOpenModerationRequestMap(int $userId): array
    {
        $this->ensureSchema();
        $stmt = $this->pdo->prepare(
            'SELECT listing_id, GROUP_CONCAT(request_type ORDER BY created_at ASC SEPARATOR ",") AS request_types
             FROM listing_moderation_requests
             WHERE requested_by = :uid
               AND request_status = "open"
             GROUP BY listing_id'
        );
        $stmt->execute(['uid' => $userId]);
        $map = [];
        foreach ($stmt->fetchAll(\PDO::FETCH_ASSOC) ?: [] as $row) {
            $types = array_values(array_filter(array_map('trim', explode(',', (string)($row['request_types'] ?? '')))));
            $map[(int)$row['listing_id']] = $types;
        }
        return $map;
    }

    public function submitCreateSuggestion(int $userId, array $data): int
    {
        $this->ensureSchema();
        $this->assertNoDuplicateEntry($data);
        $listingId = $this->saveDashboardEntry($userId, $data, null, 'draft', 'draft');
        $this->createModerationRequest($listingId, 'create', $userId, null, null);
        return $listingId;
    }

    public function submitUpdateRequest(int $userId, int $listingId, array $data, string $reason): int
    {
        $this->ensureSchema();
        $reason = trim($reason);
        if ($reason === '') {
            throw new \RuntimeException('Bitte gib eine Begründung für die Änderungsanfrage an.');
        }
        $entry = $this->getMemberEntry($listingId);
        if (!$entry || (string)($entry['status'] ?? '') !== 'published') {
            throw new \RuntimeException('Eintrag nicht gefunden.');
        }
        if ($this->hasOpenModerationRequest($listingId, ['update'])) {
            throw new \RuntimeException('Für diesen Eintrag gibt es bereits eine offene Änderungsanfrage.');
        }

        $proposal = $this->buildModerationPayload($data, $entry);
        $this->assertNoDuplicateEntry($proposal, $listingId);
        return $this->createModerationRequest($listingId, 'update', $userId, $reason, $proposal);
    }

    public function submitDeleteRequest(int $userId, int $listingId, string $reason): int
    {
        $this->ensureSchema();
        $reason = trim($reason);
        if ($reason === '') {
            throw new \RuntimeException('Bitte gib eine Begründung für die Löschanfrage an.');
        }
        $entry = $this->getMemberEntry($listingId);
        if (!$entry || (string)($entry['status'] ?? '') !== 'published') {
            throw new \RuntimeException('Eintrag nicht gefunden.');
        }
        if ($this->hasOpenModerationRequest($listingId, ['delete'])) {
            throw new \RuntimeException('Für diesen Eintrag gibt es bereits eine offene Löschanfrage.');
        }

        return $this->createModerationRequest($listingId, 'delete', $userId, $reason, null);
    }

    public function listOpenModerationRequests(): array
    {
        $this->ensureSchema();
        $stmt = $this->pdo->query(
            'SELECT mr.*, l.title, l.listing_type, l.status AS listing_status,
                    lp.street, lp.zip, lp.city, lp.region,
                    up.display_name AS requested_by_name
             FROM listing_moderation_requests mr
             INNER JOIN listings l ON l.id = mr.listing_id
             LEFT JOIN listing_places lp ON lp.id = l.primary_place_id
             LEFT JOIN user_profiles up ON up.user_id = mr.requested_by
             WHERE mr.request_status = "open"
             ORDER BY mr.created_at ASC, mr.id ASC'
        );
        $rows = $stmt ? ($stmt->fetchAll(\PDO::FETCH_ASSOC) ?: []) : [];
        foreach ($rows as &$row) {
            $row['payload'] = $this->decodeJsonRows((string)($row['payload_json'] ?? ''));
        }
        unset($row);
        return $rows;
    }

    public function decideModerationRequest(int $reviewerUserId, int $requestId, string $decision, ?string $reviewNote = null): void
    {
        $this->ensureSchema();
        $decision = $decision === 'approved' ? 'approved' : 'rejected';
        $stmt = $this->pdo->prepare(
            'SELECT mr.*, l.created_by, l.primary_place_id, l.image_path, l.listing_type, l.status AS listing_status
             FROM listing_moderation_requests mr
             INNER JOIN listings l ON l.id = mr.listing_id
             WHERE mr.id = :id
               AND mr.request_status = "open"
             LIMIT 1'
        );
        $stmt->execute(['id' => $requestId]);
        $request = $stmt->fetch(\PDO::FETCH_ASSOC);
        if (!$request) {
            throw new \RuntimeException('Moderationsanfrage nicht gefunden.');
        }

        $payload = $this->decodeJsonRows((string)($request['payload_json'] ?? ''));
        $listingId = (int)$request['listing_id'];
        $createdBy = (int)($request['created_by'] ?? 0);

        $this->pdo->beginTransaction();
        try {
            if ($decision === 'approved') {
                if ((string)$request['request_type'] === 'create') {
                    $currentEntry = $this->getMemberEntry($listingId);
                    if (!$currentEntry) {
                        throw new \RuntimeException('Eintrag nicht gefunden.');
                    }
                    $this->assertNoDuplicateEntry($currentEntry, $listingId);
                    $this->pdo->prepare('UPDATE listings SET status = "published", updated_at = NOW() WHERE id = :id')->execute(['id' => $listingId]);
                    if (!empty($request['primary_place_id'])) {
                        $this->pdo->prepare('UPDATE listing_places SET status = "published", updated_at = NOW() WHERE id = :id')->execute(['id' => (int)$request['primary_place_id']]);
                    }
                } elseif ((string)$request['request_type'] === 'update') {
                    if ($payload === []) {
                        throw new \RuntimeException('Für diese Änderungsanfrage fehlen die vorgeschlagenen Daten.');
                    }
                    $this->assertNoDuplicateEntry($payload, $listingId);
                    $this->saveDashboardEntry($createdBy, $payload, $listingId, 'published', 'published');
                } elseif ((string)$request['request_type'] === 'delete') {
                    $this->pdo->prepare('UPDATE listings SET status = "archived", updated_at = NOW() WHERE id = :id')->execute(['id' => $listingId]);
                    if (!empty($request['primary_place_id'])) {
                        $this->pdo->prepare('UPDATE listing_places SET status = "archived", updated_at = NOW() WHERE id = :id')->execute(['id' => (int)$request['primary_place_id']]);
                    }
                }
            } elseif ((string)$request['request_type'] === 'create') {
                $this->pdo->prepare('UPDATE listings SET status = "archived", updated_at = NOW() WHERE id = :id')->execute(['id' => $listingId]);
                if (!empty($request['primary_place_id'])) {
                    $this->pdo->prepare('UPDATE listing_places SET status = "archived", updated_at = NOW() WHERE id = :id')->execute(['id' => (int)$request['primary_place_id']]);
                }
            }

            $update = $this->pdo->prepare(
                'UPDATE listing_moderation_requests
                 SET request_status = :status, reviewed_by = :reviewedBy, review_note = :reviewNote, reviewed_at = NOW(), updated_at = NOW()
                 WHERE id = :id'
            );
            $update->execute([
                'status' => $decision,
                'reviewedBy' => $reviewerUserId,
                'reviewNote' => trim((string)$reviewNote) !== '' ? trim((string)$reviewNote) : null,
                'id' => $requestId,
            ]);

            $this->pdo->commit();
        } catch (\Throwable $e) {
            if ($this->pdo->inTransaction()) {
                $this->pdo->rollBack();
            }
            throw $e;
        }
    }

    public function saveDashboardEntry(int $userId, array $data, ?int $listingId = null, string $listingStatus = 'published', string $placeStatus = 'published'): int
    {
        $this->ensureSchema();
        $entryType = (string)($data['entry_kind'] ?? 'editorial_event');
        if (!in_array($entryType, ['place', 'editorial_event'], true)) {
            throw new \RuntimeException('Ungültiger Eintragstyp.');
        }

        $title = trim((string)($data['title'] ?? ''));
        $teaser = trim((string)($data['teaser'] ?? ''));
        $description = trim((string)($data['description'] ?? ''));
        $openingHoursNote = trim((string)($data['opening_hours_note'] ?? ''));
        $openingHoursRows = $this->normalizeOpeningHoursRows($data);
        $visibility = (string)($data['visibility'] ?? 'public');
        $categoryInput = trim((string)($data['category_input'] ?? $data['category_slug'] ?? ''));
        $placeKind = $categoryInput;
        $street = trim((string)($data['street'] ?? ''));
        $zip = trim((string)($data['zip'] ?? ''));
        $city = trim((string)($data['city'] ?? ''));
        $region = trim((string)($data['region'] ?? ''));
        $phone = trim((string)($data['phone'] ?? ''));
        $websiteUrl = trim((string)($data['website_url'] ?? ''));
        $lat = isset($data['lat']) && $data['lat'] !== '' ? (float)$data['lat'] : null;
        $lng = isset($data['lng']) && $data['lng'] !== '' ? (float)$data['lng'] : null;
        $startsAt = trim((string)($data['starts_at'] ?? ''));
        $recurrenceMode = (string)($data['recurrence_mode'] ?? 'single');
        $recurrenceUntil = trim((string)($data['recurrence_until'] ?? ''));
        $weekdayValues = array_values(array_filter(array_map('strval', (array)($data['recurrence_weekdays'] ?? []))));
        $specialConditionsNote = trim((string)($data['special_conditions_note'] ?? ''));
        $imagePath = trim((string)($data['image_path'] ?? ''));
        $capacityTotal = isset($data['capacity_total']) && $data['capacity_total'] !== '' ? (int)$data['capacity_total'] : null;

        if ($title === '' || $description === '') {
            throw new \RuntimeException('Bitte fülle Titel und Beschreibung aus.');
        }
        if (!in_array($visibility, ['public', 'members'], true)) {
            $visibility = 'public';
        }
        if ($entryType === 'editorial_event' && $startsAt === '') {
            throw new \RuntimeException('Bitte gib für sonstige Veranstaltungen ein Datum an.');
        }
        if ($entryType === 'editorial_event' && $recurrenceUntil === '') {
            throw new \RuntimeException('Bitte gib für Veranstaltungen ein Gültig-bis-Datum an.');
        }
        if (!in_array($listingStatus, ['draft', 'published', 'cancelled', 'archived'], true)) {
            $listingStatus = 'draft';
        }
        if (!in_array($placeStatus, ['draft', 'published', 'archived'], true)) {
            $placeStatus = 'draft';
        }
        $startsAt = $this->normalizeDateForStorage($startsAt, false);
        $recurrenceUntil = $this->normalizeDateForStorage($recurrenceUntil, true);

        $managesTransaction = !$this->pdo->inTransaction();
        if ($managesTransaction) {
            $this->pdo->beginTransaction();
        }
        try {
            $category = $this->ensureCategoryForInput($categoryInput, $entryType === 'place' ? 'place' : 'event');
            $placeKind = (string)($category['slug'] ?? '');
            $categoryId = isset($category['id']) ? (int)$category['id'] : null;

            if ($listingId !== null && $listingId > 0) {
                $existing = $this->getDashboardEntry($userId, $listingId);
                if (!$existing) {
                    throw new \RuntimeException('Eintrag nicht gefunden.');
                }
                $placeId = isset($existing['primary_place_id']) ? (int)$existing['primary_place_id'] : 0;
                if ($placeId > 0) {
                    $placeStmt = $this->pdo->prepare(
                        'UPDATE listing_places
                         SET title = :title, description = :description, street = :street, zip = :zip, city = :city, region = :region,
                             lat = :lat, lng = :lng, website_url = :websiteUrl, phone = :phone, place_kind = :placeKind,
                             opening_hours_note = :openingHoursNote, opening_hours_json = :openingHoursJson, status = :placeStatus, updated_at = NOW()
                         WHERE id = :id'
                    );
                    $placeStmt->execute([
                        'title' => $title,
                        'description' => $description,
                        'street' => $street !== '' ? $street : null,
                        'zip' => $zip !== '' ? $zip : null,
                        'city' => $city !== '' ? $city : null,
                        'region' => $region !== '' ? $region : null,
                        'lat' => $lat,
                        'lng' => $lng,
                        'websiteUrl' => $websiteUrl !== '' ? $websiteUrl : null,
                        'phone' => $phone !== '' ? $phone : null,
                        'placeKind' => $placeKind !== '' ? $placeKind : null,
                        'openingHoursNote' => $openingHoursNote !== '' ? $openingHoursNote : null,
                        'openingHoursJson' => $openingHoursRows !== [] ? json_encode($openingHoursRows, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES) : null,
                        'placeStatus' => $placeStatus,
                        'id' => $placeId,
                    ]);
                }
                $listingStmt = $this->pdo->prepare(
                    'UPDATE listings
                     SET listing_type = :listingType, title = :title, teaser_public = :teaser, description = :description,
                         image_path = :imagePath, special_conditions_note = :specialConditionsNote, visibility = :visibility,
                         supports_registration = 0, supports_capacity = :supportsCapacity, supports_pricing = :supportsPricing,
                         is_recurring = :isRecurring, status = :listingStatus, updated_at = NOW()
                     WHERE id = :id AND created_by = :uid'
                );
                $listingStmt->execute([
                    'listingType' => $entryType,
                    'title' => $title,
                    'teaser' => $teaser !== '' ? $teaser : $title,
                    'description' => $description,
                    'imagePath' => $imagePath !== '' ? $imagePath : null,
                    'specialConditionsNote' => $specialConditionsNote !== '' ? $specialConditionsNote : null,
                    'visibility' => $visibility,
                    'supportsCapacity' => $capacityTotal !== null ? 1 : 0,
                    'supportsPricing' => $this->hasPriceRows($data) || $specialConditionsNote !== '' ? 1 : 0,
                    'isRecurring' => $entryType === 'editorial_event' && $recurrenceMode !== 'single' ? 1 : 0,
                    'listingStatus' => $listingStatus,
                    'id' => $listingId,
                    'uid' => $userId,
                ]);

                $this->pdo->prepare('DELETE FROM listing_occurrences WHERE listing_id = :listingId')->execute(['listingId' => $listingId]);
                $this->saveOccurrenceAndPrices($listingId, $entryType, $startsAt, $recurrenceMode, $weekdayValues, $recurrenceUntil, $capacityTotal, $data);
            } else {
                $placeStmt = $this->pdo->prepare(
                    'INSERT INTO listing_places (created_by, source_type, title, description, street, zip, city, region, lat, lng, website_url, phone, place_kind, opening_hours_note, opening_hours_json, provider_hint, status, created_at, updated_at)
                     VALUES (:uid, "user", :title, :description, :street, :zip, :city, :region, :lat, :lng, :websiteUrl, :phone, :placeKind, :openingHoursNote, :openingHoursJson, "manual", :placeStatus, NOW(), NOW())'
                );
                $placeStmt->execute([
                    'uid' => $userId,
                    'title' => $title,
                    'description' => $description,
                    'street' => $street !== '' ? $street : null,
                    'zip' => $zip !== '' ? $zip : null,
                    'city' => $city !== '' ? $city : null,
                    'region' => $region !== '' ? $region : null,
                    'lat' => $lat,
                    'lng' => $lng,
                    'websiteUrl' => $websiteUrl !== '' ? $websiteUrl : null,
                    'phone' => $phone !== '' ? $phone : null,
                    'placeKind' => $placeKind !== '' ? $placeKind : null,
                    'openingHoursNote' => $openingHoursNote !== '' ? $openingHoursNote : null,
                    'openingHoursJson' => $openingHoursRows !== [] ? json_encode($openingHoursRows, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES) : null,
                    'placeStatus' => $placeStatus,
                ]);
                $placeId = (int)$this->pdo->lastInsertId();

                $listingStmt = $this->pdo->prepare(
                    'INSERT INTO listings (created_by, owner_type, listing_type, primary_place_id, title, teaser_public, description, image_path, special_conditions_note, visibility, status, supports_registration, supports_capacity, supports_pricing, is_recurring, created_at, updated_at)
                     VALUES (:uid, "user", :listingType, :placeId, :title, :teaser, :description, :imagePath, :specialConditionsNote, :visibility, :listingStatus, 0, :supportsCapacity, :supportsPricing, :isRecurring, NOW(), NOW())'
                );
                $listingStmt->execute([
                    'uid' => $userId,
                    'listingType' => $entryType,
                    'placeId' => $placeId,
                    'title' => $title,
                    'teaser' => $teaser !== '' ? $teaser : $title,
                    'description' => $description,
                    'imagePath' => $imagePath !== '' ? $imagePath : null,
                    'specialConditionsNote' => $specialConditionsNote !== '' ? $specialConditionsNote : null,
                    'visibility' => $visibility,
                    'listingStatus' => $listingStatus,
                    'supportsCapacity' => $capacityTotal !== null ? 1 : 0,
                    'supportsPricing' => $this->hasPriceRows($data) || $specialConditionsNote !== '' ? 1 : 0,
                    'isRecurring' => $entryType === 'editorial_event' && $recurrenceMode !== 'single' ? 1 : 0,
                ]);
                $listingId = (int)$this->pdo->lastInsertId();

                $this->saveOccurrenceAndPrices($listingId, $entryType, $startsAt, $recurrenceMode, $weekdayValues, $recurrenceUntil, $capacityTotal, $data);
            }

            $this->pdo->prepare('DELETE FROM listing_category_map WHERE listing_id = :listingId')->execute(['listingId' => $listingId]);
            if ($categoryId !== null) {
                $mapStmt = $this->pdo->prepare('INSERT INTO listing_category_map (listing_id, category_id) VALUES (:listingId, :categoryId)');
                $mapStmt->execute([
                    'listingId' => $listingId,
                    'categoryId' => $categoryId,
                ]);
            }

            if ($managesTransaction) {
                $this->pdo->commit();
            }
            return (int)$listingId;
        } catch (\Throwable $e) {
            if ($managesTransaction && $this->pdo->inTransaction()) {
                $this->pdo->rollBack();
            }
            throw $e;
        }
    }

    private function saveOccurrenceAndPrices(int $listingId, string $entryType, string $startsAt, string $recurrenceMode, array $weekdayValues, string $recurrenceUntil, ?int $capacityTotal, array $data): void
    {
        $occurrenceId = null;
        if ($entryType === 'editorial_event') {
            [$occurrenceType, $recurrenceRule] = $this->buildRecurrence($recurrenceMode, $weekdayValues);
            $occStmt = $this->pdo->prepare(
                'INSERT INTO listing_occurrences (listing_id, occurrence_type, starts_at, recurrence_rule, recurrence_until, capacity_total, status, created_at, updated_at)
                 VALUES (:listingId, :occurrenceType, :startsAt, :recurrenceRule, :recurrenceUntil, :capacityTotal, "scheduled", NOW(), NOW())'
            );
            $occStmt->execute([
                'listingId' => $listingId,
                'occurrenceType' => $occurrenceType,
                'startsAt' => $startsAt !== '' ? $startsAt : null,
                'recurrenceRule' => $recurrenceRule,
                'recurrenceUntil' => $recurrenceUntil !== '' ? $recurrenceUntil : null,
                'capacityTotal' => $capacityTotal,
            ]);
            $occurrenceId = (int)$this->pdo->lastInsertId();
        }

        $this->pdo->prepare('DELETE FROM listing_prices WHERE listing_id = :listingId')->execute(['listingId' => $listingId]);
        $priceRows = $this->normalizePriceRows($data);
        if ($priceRows === []) {
            return;
        }

        $insertPrice = $this->pdo->prepare(
            'INSERT INTO listing_prices (listing_id, occurrence_id, label, audience, price_type, amount, amount_secondary, currency, note, created_at, updated_at)
             VALUES (:listingId, :occurrenceId, :label, :audience, :priceType, :amount, :amountSecondary, "EUR", :note, NOW(), NOW())'
        );

        foreach ($priceRows as $row) {
            $insertPrice->execute([
                'listingId' => $listingId,
                'occurrenceId' => $occurrenceId,
                'label' => $row['label'],
                'audience' => $row['audience'],
                'priceType' => $row['price_type'],
                'amount' => $row['amount'],
                'amountSecondary' => $row['amount_secondary'],
                'note' => $row['note'],
            ]);
        }
    }

    private function listPrices(int $listingId): array
    {
        $stmt = $this->pdo->prepare('SELECT * FROM listing_prices WHERE listing_id = :listingId ORDER BY id ASC');
        $stmt->execute(['listingId' => $listingId]);
        return $stmt->fetchAll(\PDO::FETCH_ASSOC) ?: [];
    }

    private function buildRecurrence(string $recurrenceMode, array $weekdayValues): array
    {
        $map = ['mo' => 'MO', 'di' => 'TU', 'mi' => 'WE', 'do' => 'TH', 'fr' => 'FR', 'sa' => 'SA', 'so' => 'SU'];
        if ($recurrenceMode === 'daily') {
            return ['series', 'FREQ=DAILY'];
        }
        if ($recurrenceMode === 'weekly') {
            return ['series', 'FREQ=WEEKLY'];
        }
        if ($recurrenceMode === 'weekdays') {
            return ['series', 'FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR'];
        }
        if ($recurrenceMode === 'custom_weekdays' && $weekdayValues !== []) {
            $days = [];
            foreach ($weekdayValues as $value) {
                if (isset($map[$value])) {
                    $days[] = $map[$value];
                }
            }
            if ($days !== []) {
                return ['series', 'FREQ=WEEKLY;BYDAY=' . implode(',', $days)];
            }
        }
        return ['single', null];
    }

    private function normalizeOpeningHoursRows(array $data): array
    {
        $labels = (array)($data['opening_day_label'] ?? []);
        $fromValues = (array)($data['opening_time_from'] ?? []);
        $toValues = (array)($data['opening_time_to'] ?? []);
        $notes = (array)($data['opening_note'] ?? []);
        $count = max(count($labels), count($fromValues), count($toValues), count($notes));
        $rows = [];
        for ($index = 0; $index < $count; $index++) {
            $row = [
                'day_label' => trim((string)($labels[$index] ?? '')),
                'time_from' => trim((string)($fromValues[$index] ?? '')),
                'time_to' => trim((string)($toValues[$index] ?? '')),
                'note' => trim((string)($notes[$index] ?? '')),
            ];
            if ($row['day_label'] === '' && $row['time_from'] === '' && $row['time_to'] === '' && $row['note'] === '') {
                continue;
            }
            $rows[] = $row;
        }
        return $rows;
    }

    private function normalizePriceRows(array $data): array
    {
        $amounts = (array)($data['price_amount'] ?? []);
        $ageFroms = (array)($data['price_age_from'] ?? []);
        $ageTos = (array)($data['price_age_to'] ?? []);
        $count = max(count($amounts), count($ageFroms), count($ageTos));
        $rows = [];
        for ($index = 0; $index < $count; $index++) {
            $amount = trim((string)($amounts[$index] ?? ''));
            $ageFrom = trim((string)($ageFroms[$index] ?? ''));
            $ageTo = trim((string)($ageTos[$index] ?? ''));
            if ($amount === '' && $ageFrom === '' && $ageTo === '') {
                continue;
            }
            $noteParts = [];
            if ($ageFrom !== '' || $ageTo !== '') {
                $ageText = [];
                if ($ageFrom !== '') {
                    $ageText[] = 'ab ' . $ageFrom . ' Jahre';
                }
                if ($ageTo !== '') {
                    $ageText[] = 'bis ' . $ageTo . ' Jahre';
                }
                $noteParts[] = implode(', ', $ageText);
            }
            $rows[] = [
                'label' => 'Preis',
                'audience' => 'general',
                'price_type' => $amount === '' ? 'request' : 'fixed',
                'amount' => $amount !== '' ? (float)str_replace(',', '.', $amount) : null,
                'amount_secondary' => null,
                'note' => $noteParts !== [] ? implode(' | ', $noteParts) : null,
            ];
        }
        return $rows;
    }

    private function hasPriceRows(array $data): bool
    {
        return $this->normalizePriceRows($data) !== [];
    }

    private function decodeJsonRows(string $json): array
    {
        if ($json === '') {
            return [];
        }
        $decoded = json_decode($json, true);
        return is_array($decoded) ? $decoded : [];
    }

    private function normalizeDateForStorage(string $value, bool $endOfDay): string
    {
        $value = trim($value);
        if ($value === '') {
            return '';
        }
        if (preg_match('/^\d{4}-\d{2}-\d{2}$/', $value) === 1) {
            return $value . ($endOfDay ? ' 23:59:59' : ' 00:00:00');
        }
        return $value;
    }

    private function slugify(string $value): string
    {
        $value = mb_strtolower(trim($value));
        $value = strtr($value, ['ä' => 'ae', 'ö' => 'oe', 'ü' => 'ue', 'ß' => 'ss']);
        $value = preg_replace('/[^a-z0-9]+/u', '-', $value) ?: '';
        return trim($value, '-');
    }

    public function deleteDashboardEntry(int $userId, int $listingId): void
    {
        $this->ensureSchema();
        $entry = $this->getDashboardEntry($userId, $listingId);
        if (!$entry) {
            throw new \RuntimeException('Eintrag nicht gefunden.');
        }

        $this->pdo->beginTransaction();
        try {
            $this->pdo->prepare('DELETE FROM listings WHERE id = :id AND created_by = :uid')->execute([
                'id' => $listingId,
                'uid' => $userId,
            ]);
            if (!empty($entry['primary_place_id'])) {
                $this->pdo->prepare('DELETE FROM listing_places WHERE id = :id')->execute([
                    'id' => (int)$entry['primary_place_id'],
                ]);
            }
            $this->pdo->commit();
        } catch (\Throwable $e) {
            if ($this->pdo->inTransaction()) {
                $this->pdo->rollBack();
            }
            throw $e;
        }
    }

    private function createModerationRequest(int $listingId, string $requestType, int $requestedBy, ?string $reason, ?array $payload): int
    {
        $stmt = $this->pdo->prepare(
            'INSERT INTO listing_moderation_requests (listing_id, request_type, request_status, requested_by, request_reason, payload_json)
             VALUES (:listingId, :requestType, "open", :requestedBy, :requestReason, :payloadJson)'
        );
        $stmt->execute([
            'listingId' => $listingId,
            'requestType' => $requestType,
            'requestedBy' => $requestedBy,
            'requestReason' => trim((string)$reason) !== '' ? trim((string)$reason) : null,
            'payloadJson' => $payload !== null ? json_encode($payload, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES) : null,
        ]);
        return (int)$this->pdo->lastInsertId();
    }

    private function hasOpenModerationRequest(int $listingId, array $requestTypes): bool
    {
        $requestTypes = array_values(array_filter(array_map('strval', $requestTypes)));
        if ($requestTypes === []) {
            return false;
        }
        $placeholders = implode(',', array_fill(0, count($requestTypes), '?'));
        $params = array_merge([$listingId], $requestTypes);
        $stmt = $this->pdo->prepare(
            "SELECT id FROM listing_moderation_requests WHERE listing_id = ? AND request_status = 'open' AND request_type IN ($placeholders) LIMIT 1"
        );
        $stmt->execute($params);
        return (bool)$stmt->fetchColumn();
    }

    private function buildModerationPayload(array $data, array $existing): array
    {
        $payload = $data;
        $fieldMap = [
            'title' => 'title',
            'description' => 'description',
            'teaser' => 'teaser_public',
            'street' => 'street',
            'zip' => 'zip',
            'city' => 'city',
            'region' => 'region',
            'lat' => 'lat',
            'lng' => 'lng',
            'visibility' => 'visibility',
            'category_slug' => 'category_slug',
            'image_path' => 'image_path',
            'special_conditions_note' => 'special_conditions_note',
            'phone' => 'phone',
            'website_url' => 'website_url',
            'opening_hours_note' => 'opening_hours_note',
            'starts_at' => 'starts_at',
            'recurrence_until' => 'recurrence_until',
            'recurrence_rule' => 'recurrence_rule',
            'entry_kind' => 'listing_type',
        ];
        foreach ($fieldMap as $payloadKey => $existingKey) {
            if (!array_key_exists($payloadKey, $payload) || $payload[$payloadKey] === '') {
                $payload[$payloadKey] = $existing[$existingKey] ?? '';
            }
        }
        if (!isset($payload['category_input']) || trim((string)$payload['category_input']) === '') {
            $payload['category_input'] = $existing['category_slug'] ?? '';
        }
        if (!isset($payload['recurrence_mode']) || trim((string)$payload['recurrence_mode']) === '') {
            $payload['recurrence_mode'] = $this->recurrenceModeFromRule((string)($existing['recurrence_rule'] ?? ''));
        }
        if (!isset($payload['entry_kind']) || trim((string)$payload['entry_kind']) === '') {
            $payload['entry_kind'] = $existing['listing_type'] ?? 'editorial_event';
        }
        if (!isset($payload['capacity_total']) && isset($existing['capacity_total'])) {
            $payload['capacity_total'] = $existing['capacity_total'];
        }
        return $payload;
    }

    private function recurrenceModeFromRule(string $rule): string
    {
        if (str_contains($rule, 'FREQ=DAILY')) {
            return 'daily';
        }
        if (str_contains($rule, 'FREQ=WEEKLY')) {
            return 'weekly';
        }
        return 'single';
    }

    private function assertNoDuplicateEntry(array $data, ?int $excludeListingId = null): void
    {
        $title = mb_strtolower(trim((string)($data['title'] ?? '')));
        $street = mb_strtolower(trim((string)($data['street'] ?? '')));
        $zip = trim((string)($data['zip'] ?? ''));
        $city = mb_strtolower(trim((string)($data['city'] ?? '')));
        if ($title === '' || ($street === '' && $zip === '' && $city === '')) {
            return;
        }

        $sql = 'SELECT l.id, l.title, lp.street, lp.zip, lp.city
                FROM listings l
                INNER JOIN listing_places lp ON lp.id = l.primary_place_id
                WHERE l.listing_type IN ("place","editorial_event")
                  AND l.status IN ("draft","published")
                  AND LOWER(TRIM(l.title)) = :title
                  AND LOWER(TRIM(COALESCE(lp.street, ""))) = :street
                  AND TRIM(COALESCE(lp.zip, "")) = :zip
                  AND LOWER(TRIM(COALESCE(lp.city, ""))) = :city';
        $params = [
            'title' => $title,
            'street' => $street,
            'zip' => $zip,
            'city' => $city,
        ];
        if ($excludeListingId !== null && $excludeListingId > 0) {
            $sql .= ' AND l.id <> :excludeId';
            $params['excludeId'] = $excludeListingId;
        }
        $sql .= ' LIMIT 1';
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute($params);
        $duplicate = $stmt->fetch(\PDO::FETCH_ASSOC);
        if ($duplicate) {
            throw new \RuntimeException('Ein ähnlicher Ort oder eine ähnliche Veranstaltung mit gleichem Namen und gleicher Adresse ist bereits vorhanden.');
        }
    }

    private function hasTable(string $table): bool
    {
        if (array_key_exists($table, $this->tableCache)) {
            return $this->tableCache[$table];
        }

        try {
            $stmt = $this->pdo->prepare('SELECT 1 FROM information_schema.tables WHERE table_schema = DATABASE() AND table_name = :table LIMIT 1');
            $stmt->execute(['table' => $table]);
            return $this->tableCache[$table] = (bool)$stmt->fetchColumn();
        } catch (\Throwable) {
            return $this->tableCache[$table] = false;
        }
    }

    private function hasColumn(string $table, string $column): bool
    {
        $key = $table . '.' . $column;
        if (array_key_exists($key, $this->columnCache)) {
            return $this->columnCache[$key];
        }
        try {
            $stmt = $this->pdo->prepare('SELECT 1 FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = :table AND column_name = :column LIMIT 1');
            $stmt->execute([
                'table' => $table,
                'column' => $column,
            ]);
            return $this->columnCache[$key] = (bool)$stmt->fetchColumn();
        } catch (\Throwable) {
            return $this->columnCache[$key] = false;
        }
    }

    private function defaultCategories(): array
    {
        return [
            ['slug' => 'spielplatz', 'title' => 'Spielplatz', 'group' => 'place'],
            ['slug' => 'cafe', 'title' => 'Café', 'group' => 'food'],
            ['slug' => 'restaurant', 'title' => 'Restaurant', 'group' => 'food'],
            ['slug' => 'indoor-spielort', 'title' => 'Indoor-Spielort', 'group' => 'place'],
            ['slug' => 'zirkus', 'title' => 'Zirkus', 'group' => 'event'],
            ['slug' => 'huepfburgen', 'title' => 'Hüpfburgen', 'group' => 'event'],
            ['slug' => 'workshop', 'title' => 'Workshop', 'group' => 'event'],
            ['slug' => 'kurs', 'title' => 'Kurs', 'group' => 'event'],
            ['slug' => 'familienfest', 'title' => 'Familienfest', 'group' => 'family'],
        ];
    }
}