<?php

declare(strict_types=1);

namespace App\Service;

use App\BusProNet\Model\Hotel;
use App\BusProNet\Model\Pickup;
use App\BusProNet\Model\XmlExportInfo;
use App\BusProNet\Traits\TypeConversionTrait;
use App\BusProNet\XmlCrawlerFactory;
use App\BusProNet\XmlLoader\HotelLoader;
use App\BusProNet\XmlLoader\PickupLoader;
use App\BusProNet\XmlParser\TravelParser;
use App\Model\Export;
use League\Flysystem\FilesystemOperator;
use League\Flysystem\StorageAttributes;
use Psr\Cache\InvalidArgumentException;
use Psr\Log\LoggerInterface;
use Symfony\Component\DomCrawler\Crawler;
use Symfony\Contracts\Cache\CacheInterface;
use Symfony\Contracts\Cache\ItemInterface;

/**
 * Flattens the BusPro XML export into one row per travel date x hotel, pickups resolved.
 *
 * Built from the XML file map rather than the travel_snapshot table. The table sits at
 * exactly this grain and is tempting, but it is refreshed on its own schedule, independent
 * of the master-data caches. Only the loaders share the bpn.cache pool under the xml-sync
 * tag, and that is what makes the consistency guarantee hold for free: /api/hotels,
 * /api/pickups and this export all move together when app:bpn:xml-sync invalidates the tag.
 *
 * Each Ziel_*.xml is read and walked exactly once. Looping TravelLoader::loadById() per row
 * would re-parse a whole file -- rooms, services, prices -- once per hotel on the date.
 */
class TravelExportBuilder
{
    use TypeConversionTrait;

    private const CACHE_KEY = 'bpn_travels_export';

    public function __construct(
        private readonly HotelLoader $hotelLoader,
        private readonly PickupLoader $pickupLoader,
        private readonly TravelParser $travelParser,
        private readonly FilesystemOperator $xmlExport,
        private readonly CacheInterface $cache,
        private readonly LoggerInterface $logger,
    ) {
    }

    /**
     * Assembles the whole export, cached as one unit alongside the sibling loaders.
     */
    public function build(): Export
    {
        try {
            return $this->cache->get(self::CACHE_KEY, function (ItemInterface $item) {
                $item->expiresAfter(3 * 60 * 60);
                $item->tag(['xml-sync']);

                return $this->assemble();
            });
        } catch (InvalidArgumentException $e) {
            throw new \RuntimeException('Cache key error in TravelExportBuilder', 0, $e);
        }
    }

    private function assemble(): Export
    {
        // Read before the walk and cached with the rows, so every page served from this
        // copy names the same source export. A client that sees it change between pages
        // knows xml-sync swapped the export underneath its walk.
        $sourceGeneratedAt = XmlExportInfo::fromStorage($this->xmlExport)?->lastTransfer;

        $hotels = $this->hotelLoader->loadAll();
        $pickupMasterData = $this->pickupLoader->loadAll();

        /** @var array<string, array<string, mixed>> $rows keyed by travelId-hotelId */
        $rows = [];
        $skipped = 0;
        /** @var array<int, true> $pickupsWithoutMasterData */
        $pickupsWithoutMasterData = [];

        $files = $this
            ->xmlExport
            ->listContents('.')
            ->filter(fn (StorageAttributes $attributes) => $attributes->isFile() && str_starts_with($attributes->path(), 'Ziel_'));

        foreach ($files as $file) {
            $crawler = XmlCrawlerFactory::create($this->xmlExport->read($file->path()));

            $crawler->filterXPath('//reisen/reise/termin')->each(
                function (Crawler $node) use (&$rows, &$skipped, &$pickupsWithoutMasterData, $hotels, $pickupMasterData) {
                    $this->collectTravel($node, $rows, $skipped, $pickupsWithoutMasterData, $hotels, $pickupMasterData);
                }
            );
        }

        return new Export(
            array_values($rows),
            $skipped,
            count($pickupsWithoutMasterData),
            new \DateTimeImmutable(),
            $sourceGeneratedAt,
        );
    }

    /**
     * @param array<string, array<string, mixed>> $rows
     * @param array<int, true>                    $pickupsWithoutMasterData
     * @param array<int, Hotel>                   $hotels
     * @param array<int|string, Pickup>           $pickupMasterData
     */
    private function collectTravel(
        Crawler $node,
        array &$rows,
        int &$skipped,
        array &$pickupsWithoutMasterData,
        array $hotels,
        array $pickupMasterData,
    ): void {
        $hotelNodes = $node->filterXPath('.//hotel');

        // Dates first: getPickups() needs a non-null default date for the time-only zeit
        // shape, and parsing them up front is also what turns an unusable date into a
        // dropped row rather than a row with a null date the consumer cannot key on.
        $dateFrom = $this->stringToDate($node->attr('termin'));
        $dateTo = $this->stringToDate($node->attr('bis'));

        if (null === $dateFrom || null === $dateTo) {
            $this->logger->warning('Travel export: unparseable travel date', [
                'travel_id' => $node->attr('idbuspro'),
                'termin' => $node->attr('termin'),
                'bis' => $node->attr('bis'),
            ]);
            $skipped += $hotelNodes->count();

            return;
        }

        $travelId = (int) $node->attr('idbuspro');

        // getPickups() is what buys stringToDateTimeFuzzy() for both zeit shapes and
        // adjustOvernightTimes(), which rolls an 02:15 listed after a 23:59 onto the next
        // calendar day. Resolved once per travel date, then shared by its hotel rows.
        //
        // Resolved in UTC: the times are BusPro's clock readings, and in Europe/Berlin a
        // bare 02:45 on the spring-forward night would move to 03:45.
        $pickups = $this->buildPickups(
            $this->travelParser->getPickups(
                $node->filterXPath('.//zustiege/zustieg'),
                new \DateTimeImmutable($dateFrom->format('Y-m-d'), new \DateTimeZone('UTC')),
                true,
            ),
            $pickupMasterData,
            $pickupsWithoutMasterData,
        );

        // The product a date belongs to, from the enclosing <reise>. Not derivable from the
        // date code: DWWMP runs dates coded DWWMW…, and group travels carry each group's code.
        $productNode = $node->getNode(0)?->parentNode;

        $travel = [
            'busProId' => $travelId,
            'code' => $node->attr('code'),
            'productCode' => $productNode instanceof \DOMElement ? $this->trimOrNull($productNode->getAttribute('code')) : null,
            'product' => $this->trimOrNull($this->getStringOrNullValue($node->filterXPath('.//text'))),
            'dateFrom' => $dateFrom->format('Y-m-d'),
            'dateTo' => $dateTo->format('Y-m-d'),
        ];

        $hotelNodes->each(function (Crawler $hotelNode) use (&$rows, &$skipped, $hotels, $travel, $travelId, $pickups) {
            $hotelId = (int) $hotelNode->attr('idbuspro');

            // Defensive: no travel in the current snapshot references a hotel that
            // hotel.xml does not carry. A row without master data would reach the consumer
            // with no name and no country, so it is dropped and counted instead.
            if (false === isset($hotels[$hotelId])) {
                $this->logger->warning('Travel export: hotel missing from master data', [
                    'travel_id' => $travelId,
                    'hotel_id' => $hotelId,
                ]);
                ++$skipped;

                return;
            }

            $hotel = $hotels[$hotelId];

            // Keyed by the pair the consumer upserts on, so a date repeated across files
            // collapses last-wins instead of reaching it as a duplicate.
            $rows[$travelId.'-'.$hotelId] = $travel + [
                'hotel' => [
                    'busProId' => $hotelId,
                    'code' => $hotel->code,
                    'name' => $hotel->name,
                    'costUnit' => $hotel->costUnit,
                    'country' => $hotel->country,
                    'countryCode' => $hotel->countryCode,
                ],
                'pickups' => $pickups,
            ];
        });
    }

    /**
     * Joins the travel XML's pickups against zustiege.xml.
     *
     * Deliberately not PickupLoader::patchPickupsDetails(), which sorts by time -- the
     * contract is source order, which is the order the disposition lists them in. Nor
     * enrichPickupDetails(), which is private and passes over a miss silently.
     *
     * @param array<int, Pickup>        $pickups                  pickups indexed by id, in source order
     * @param array<int|string, Pickup> $masterData
     * @param array<int, true>          $pickupsWithoutMasterData
     *
     * @return list<array<string, mixed>>
     */
    private function buildPickups(array $pickups, array $masterData, array &$pickupsWithoutMasterData): array
    {
        $resolved = [];

        foreach ($pickups as $pickup) {
            $pickupId = $pickup->id;

            // Defensive: none exist today. An entry with no id is not addressable by the
            // consumer, so drop the entry -- never the row it belongs to.
            if (null === $pickupId || 0 === $pickupId) {
                continue;
            }

            $details = $masterData[$pickupId] ?? null;

            // Around 21 ids referenced by travel XML have no entry in zustiege.xml. The
            // entry is emitted anyway: dropping it would hide a real departure point from
            // the disposition UI, where a nameless stop is still better than a missing one.
            if (null === $details) {
                $pickupsWithoutMasterData[$pickupId] = true;
            }

            $resolved[] = [
                'busProId' => $pickupId,
                'code' => $details?->code,
                'city' => $details?->city,
                'street' => $details?->street,
                'time' => $pickup->time?->format('H:i'),
                // Emitted for time-only sources too: adjustOvernightTimes() has already
                // worked out the real day, and a null here would throw that away. A clock
                // reading without an offset, like `time`.
                'datetime' => $pickup->time?->format('Y-m-d\TH:i:s'),
            ];
        }

        return $resolved;
    }

    private function getStringOrNullValue(Crawler $node): ?string
    {
        return 0 < $node->count() ? $node->text() : null;
    }

    private function trimOrNull(?string $value): ?string
    {
        if (null === $value) {
            return null;
        }

        $trimmed = trim($value);

        return '' === $trimmed ? null : $trimmed;
    }
}