#include "detailview.h"
#include "../../tokens/AnimationTokens.h"
#include "../../utils/fadehelper.h"
#include "../../components/detailactionwidget.h"
#include "../../components/detailbottominfowidget.h"
#include "../../components/detailcontentwidget.h"
#include "../../components/detailtagbutton.h"
#include "../../components/flowlayout.h"
#include "../../components/horizontallistviewgallery.h"
#include "../../components/mediaactionmenu.h"
#include "../../components/mediasectionwidget.h"
#include "../../components/modernmenubutton.h"
#include "../../components/moderntoast.h"
#include "../../managers/playbackmanager.h"
#include "../../managers/thememanager.h"
#include "../../utils/mediaitemutils.h"
#include "../../utils/detailcacheutils.h"
#include "../../utils/mediasourcepreferenceutils.h"
#include "../../utils/numberextractor.h"
#include "../../utils/playerpreferenceutils.h"
#include "../../utils/smoothscrollcontroller.h"
#include "overviewdialog.h"
#include <config/config_keys.h>
#include <config/configstore.h>
#include <qembycore.h>
#include <services/manager/servermanager.h>
#include <services/media/mediaservice.h>

#include <QClipboard>
#include <QDate>
#include <QDebug>
#include <QEvent>
#include <QFuture>
#include <QFutureWatcher>
#include <QGraphicsDropShadowEffect>
#include <QGridLayout>
#include <QGuiApplication>
#include <QHash>
#include <QHBoxLayout>
#include <QIcon>
#include <QImage>
#include <QIntValidator>
#include <QLabel>
#include <QLineEdit>
#include <QListView>
#include <QPainter>
#include <QPainterPath>
#include <QPointer>
#include <QPushButton>
#include <QRegularExpression>
#include <QScrollArea>
#include <QScrollBar>
#include <QSignalBlocker>
#include <QTextDocument>
#include <QTimer>
#include <QVBoxLayout>
#include <QWheelEvent>
#include <QtConcurrent/QtConcurrentRun>

#include <qcorofuture.h>

#include <optional>

namespace {

QWidget *createTransparentReserveWidget(QWidget *parent, const char *objectName,
                                        int height) {
  auto *widget = new QWidget(parent);
  widget->setObjectName(QString::fromLatin1(objectName));
  widget->setFixedHeight(height);
  widget->hide();
  return widget;
}

int reserveHeightFor(QWidget *widget, int fallbackHeight) {
  if (!widget)
    return fallbackHeight;

  const int hintHeight = widget->sizeHint().height();
  return qMax(fallbackHeight, hintHeight);
}

void showReserveWidget(QWidget *reserve, int height = -1) {
  if (!reserve)
    return;
  if (height > 0 && reserve->height() != height)
    reserve->setFixedHeight(height);
  reserve->show();
}

void hideReserveWidget(QWidget *reserve) {
  if (reserve)
    reserve->hide();
}

void prepareReservedSection(QWidget *reserve, MediaSectionWidget *section,
                            int height = -1) {
  showReserveWidget(reserve, height);
  if (section)
    section->clear();
}

void applyReservedSectionItems(QWidget *reserve, MediaSectionWidget *section,
                               const QList<MediaItem> &items) {
  if (!section) {
    hideReserveWidget(reserve);
    return;
  }

  if (items.isEmpty()) {
    section->clear();
    hideReserveWidget(reserve);
    return;
  }

  hideReserveWidget(reserve);
  section->setItems(items);
}







QString computeSourcesFingerprint(const QList<MediaSourceInfo> &sources) {
  if (sources.isEmpty())
    return QStringLiteral("<empty>");
  QStringList parts;
  parts.reserve(sources.size());
  for (const auto &src : sources) {
    QStringList streamParts;
    streamParts.reserve(src.mediaStreams.size());
    for (const auto &s : src.mediaStreams) {
      streamParts << QStringLiteral("%1:%2:%3:%4")
                         .arg(s.type, QString::number(s.index), s.codec,
                              s.language);
    }
    parts << QStringLiteral("%1#%2#%3")
                 .arg(src.id, QString::number(src.mediaStreams.size()),
                      streamParts.join(QLatin1Char('|')));
  }
  return parts.join(QLatin1Char(';'));
}




QString computeBottomInfoFingerprint(const MediaItem &item,
                                     const QList<MediaSourceInfo> &sources) {
  QStringList studioParts;
  studioParts.reserve(item.studios.size());
  for (const auto &s : item.studios)
    studioParts << s.name;

  QStringList urlParts;
  urlParts.reserve(item.externalUrls.size());
  for (const auto &u : item.externalUrls)
    urlParts << (u.name + QLatin1Char('=') + u.url);

  return QStringLiteral("%1|tags=%2|studios=%3|urls=%4|src=%5")
      .arg(item.id, item.tags.join(QLatin1Char(',')),
           studioParts.join(QLatin1Char(',')),
           urlParts.join(QLatin1Char(',')), computeSourcesFingerprint(sources));
}

QString formatDetailReleaseDate(const MediaItem &item) {
  QString dateText = item.premiereDate.trimmed();
  if (!dateText.isEmpty()) {
    const int timeSeparator = dateText.indexOf(QLatin1Char('T'));
    if (timeSeparator > 0)
      dateText = dateText.left(timeSeparator);

    
    const int dateLen = dateText.length();
    if (dateLen > 0) {
      const QString dateOnly = dateText.left(qMin(dateLen, 10));
      const QDate date = QDate::fromString(dateOnly, Qt::ISODate);
      if (date.isValid())
        return date.toString(QStringLiteral("yyyy-MM-dd"));
      return dateOnly;
    }
  }

  if (item.productionYear > 0)
    return QString::number(item.productionYear);

  return QString();
}

QString formatEpisodeTag(const MediaItem &item) {
  QString tag;
  if (item.parentIndexNumber >= 0) {
    tag += QStringLiteral("S%1").arg(item.parentIndexNumber, 2, 10,
                                     QLatin1Char('0'));
  }
  if (item.indexNumber >= 0) {
    tag += QStringLiteral("E%1").arg(item.indexNumber, 2, 10,
                                     QLatin1Char('0'));
  }
  return tag;
}

MediaItem resolveSeasonPlaybackEpisode(const QList<MediaItem> &episodes) {
  for (const MediaItem &episode : episodes) {
    if (episode.userData.playbackPositionTicks > 0 &&
        !episode.userData.played && episode.userData.playedPercentage < 99.0) {
      return episode;
    }
  }

  for (const MediaItem &episode : episodes) {
    if (!episode.userData.played)
      return episode;
  }

  return episodes.isEmpty() ? MediaItem{} : episodes.first();
}

MediaItem withSeedContext(MediaItem cachedItem, const MediaItem &seedItem) {
  if (seedItem.id.isEmpty() || seedItem.id != cachedItem.id)
    return cachedItem;

  if (cachedItem.name.trimmed().isEmpty())
    cachedItem.name = seedItem.name;
  if (cachedItem.type.trimmed().isEmpty())
    cachedItem.type = seedItem.type;
  if (cachedItem.mediaType.trimmed().isEmpty())
    cachedItem.mediaType = seedItem.mediaType;
  if (cachedItem.overview.trimmed().isEmpty())
    cachedItem.overview = seedItem.overview;
  if (cachedItem.genres.isEmpty())
    cachedItem.genres = seedItem.genres;
  if (cachedItem.taglines.isEmpty())
    cachedItem.taglines = seedItem.taglines;
  if (cachedItem.mediaSources.isEmpty())
    cachedItem.mediaSources = seedItem.mediaSources;
  if (cachedItem.images.primaryTag.isEmpty() &&
      cachedItem.images.thumbTag.isEmpty() &&
      cachedItem.images.backdropTag.isEmpty() &&
      cachedItem.images.logoTag.isEmpty()) {
    cachedItem.images = seedItem.images;
  }

  cachedItem.playlistId = seedItem.playlistId;
  cachedItem.playlistItemId = seedItem.playlistItemId;
  cachedItem.hasResumeContext = seedItem.hasResumeContext;
  cachedItem.resumeItemId = seedItem.resumeItemId;
  cachedItem.resumeUserData = seedItem.resumeUserData;
  return cachedItem;
}

bool mediaItemListsEqual(const QList<MediaItem> &left,
                         const QList<MediaItem> &right) {
  if (left.size() != right.size())
    return false;

  for (int i = 0; i < left.size(); ++i) {
    if (DetailCacheUtils::fingerprint(left[i]) !=
        DetailCacheUtils::fingerprint(right[i])) {
      return false;
    }
  }
  return true;
}

QCoro::Task<bool> mediaItemListsEqualAsync(QList<MediaItem> left,
                                           QList<MediaItem> right) {
  co_return co_await QtConcurrent::run(
      [left = std::move(left), right = std::move(right)]() mutable {
        return mediaItemListsEqual(left, right);
      });
}

QString castFingerprint(const MediaItem &item) {
  QStringList parts;
  parts.reserve(item.people.size());
  for (const auto &person : item.people) {
    parts << QStringLiteral("%1:%2:%3:%4")
                 .arg(person.id, person.name, person.type, person.role);
  }
  return parts.join(QLatin1Char('|'));
}

bool episodesBelongToSeason(const QList<MediaItem> &episodes,
                            const MediaItem &season) {
  if (episodes.isEmpty() || season.indexNumber < 0)
    return true;

  for (const MediaItem &episode : episodes) {
    if (episode.parentIndexNumber < 0)
      continue;
    if (episode.parentIndexNumber != season.indexNumber)
      return false;
  }
  return true;
}

bool cacheEntryHasAnySecondaryData(
    const DetailCacheUtils::DetailCacheEntry &entry) {
  return entry.hasPlayableItem || entry.hasSeasons || entry.hasSeasonEpisodes ||
         entry.hasSimilarItems || entry.hasCollections ||
         entry.hasAdditionalParts || !entry.item.people.isEmpty();
}

struct CachedDetailImages {
  std::optional<QImage> poster;
  std::optional<QImage> backdrop;
  std::optional<QImage> logo;
};

void saveDetailCacheAsync(QString serverId, QString userId, MediaItem item,
                          QString fingerprint) {
  if (serverId.isEmpty() || userId.isEmpty() || item.id.isEmpty())
    return;

  (void)QtConcurrent::run([serverId = std::move(serverId),
                           userId = std::move(userId), item = std::move(item),
                           fingerprint = std::move(fingerprint)]() mutable {
    QString errorString;
    const QString itemId = item.id;
    DetailCacheUtils::DetailCacheEntry entry;
    const auto existing = DetailCacheUtils::load(serverId, userId, itemId);
    if (existing.has_value())
      entry = *existing;
    entry.item = item;
    if (entry.hasPlayableItem && !entry.playableItemFromServer) {
      entry.hasPlayableItem = false;
      entry.playableItem = MediaItem{};
    }
    const bool saved =
        DetailCacheUtils::save(serverId, userId, entry, &errorString);
    if (saved) {
      qDebug() << "[DetailView] Detail cache saved"
               << "itemId=" << itemId
               << "fingerprint=" << fingerprint.left(12);
    } else {
      qWarning() << "[DetailView] Detail cache save failed"
                 << "itemId=" << itemId << "error=" << errorString;
    }
  });
}

void saveDetailCacheEntryAsync(QString serverId, QString userId,
                               DetailCacheUtils::DetailCacheEntry entry,
                               QString reason) {
  if (serverId.isEmpty() || userId.isEmpty() || entry.item.id.isEmpty())
    return;

  (void)QtConcurrent::run([serverId = std::move(serverId),
                           userId = std::move(userId), entry = std::move(entry),
                           reason = std::move(reason)]() mutable {
    QString errorString;
    const QString itemId = entry.item.id;
    const auto existing = DetailCacheUtils::load(serverId, userId, itemId);
    if (existing.has_value()) {
      if (!entry.hasPlayableItem && existing->hasPlayableItem &&
          existing->playableItemFromServer) {
        entry.hasPlayableItem = true;
        entry.playableItem = existing->playableItem;
        entry.playableItemFromServer = true;
      }
      if (!entry.hasSeasons && existing->hasSeasons) {
        entry.hasSeasons = true;
        entry.seasons = existing->seasons;
      }
      if (!entry.hasSeasonEpisodes && existing->hasSeasonEpisodes) {
        entry.hasSeasonEpisodes = true;
        entry.seasonEpisodes = existing->seasonEpisodes;
        entry.seasonIndex = existing->seasonIndex;
        entry.seasonId = existing->seasonId;
      }
      if (!entry.hasSimilarItems && existing->hasSimilarItems) {
        entry.hasSimilarItems = true;
        entry.similarItems = existing->similarItems;
      }
      if (!entry.hasCollections && existing->hasCollections) {
        entry.hasCollections = true;
        entry.collections = existing->collections;
      }
      if (!entry.hasAdditionalParts && existing->hasAdditionalParts) {
        entry.hasAdditionalParts = true;
        entry.additionalParts = existing->additionalParts;
      }
    }
    if (entry.hasPlayableItem && !entry.playableItemFromServer) {
      entry.hasPlayableItem = false;
      entry.playableItem = MediaItem{};
    }
    const QString itemFp = DetailCacheUtils::fingerprint(entry.item);
    const QString sectionsFp = DetailCacheUtils::sectionsFingerprint(entry);
    const bool saved =
        DetailCacheUtils::save(serverId, userId, entry, &errorString);
    if (saved) {
      qDebug() << "[DetailView] Detail cache snapshot saved"
               << "itemId=" << itemId << "reason=" << reason
               << "fingerprint=" << itemFp.left(12)
               << "sections=" << sectionsFp.left(12);
    } else {
      qWarning() << "[DetailView] Detail cache snapshot save failed"
                 << "itemId=" << itemId << "reason=" << reason
                 << "error=" << errorString;
    }
  });
}

void saveDetailImageAsync(QString serverId, QString userId,
                          QString ownerItemId, QString role,
                          QString imageItemId, QString imageType,
                          QString imageTag, int maxWidth, QImage image) {
  if (serverId.isEmpty() || userId.isEmpty() || ownerItemId.isEmpty() ||
      imageTag.isEmpty() || image.isNull())
    return;

  (void)QtConcurrent::run([serverId = std::move(serverId),
                           userId = std::move(userId),
                           ownerItemId = std::move(ownerItemId),
                           role = std::move(role),
                           imageItemId = std::move(imageItemId),
                           imageType = std::move(imageType),
                           imageTag = std::move(imageTag), maxWidth,
                           image = std::move(image)]() mutable {
    QString errorString;
    const bool saved = DetailCacheUtils::saveImage(
        serverId, userId, ownerItemId, role, imageItemId, imageType, imageTag,
        maxWidth, image, &errorString);
    if (!saved) {
      qWarning() << "[DetailView] Detail image cache save failed"
                 << "itemId=" << ownerItemId << "role=" << role
                 << "error=" << errorString;
    }
  });
}

} 

DetailView::DetailView(QEmbyCore *core, QWidget *parent)
    : BaseView(core, parent) {
  setAttribute(Qt::WA_StyledBackground, true);
  setObjectName("detail-view");
  setProperty("showGlobalSearch", true);
  setupUi();
}

void DetailView::scrollToTop() {
  if (m_mainScrollArea && m_mainScrollArea->verticalScrollBar()) {
    if (m_vScrollController) {
      m_vScrollController->scrollTo(0, false);
    } else {
      m_mainScrollArea->verticalScrollBar()->setValue(0);
    }
  }
}

void DetailView::setupUi() {
  auto *mainLayout = new QVBoxLayout(this);
  mainLayout->setContentsMargins(0, 0, 0, 0);

  m_mainScrollArea = new QScrollArea(this);
  m_mainScrollArea->setWidgetResizable(true);
  m_mainScrollArea->setFrameShape(QFrame::NoFrame);
  m_mainScrollArea->setObjectName("detail-scrollarea");
  m_mainScrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
  m_mainScrollArea->setStyleSheet("QScrollArea { background: transparent; }");

  m_vScrollController =
      new SmoothScrollController(m_mainScrollArea->verticalScrollBar(), this);
  m_vScrollController->setDuration(AnimationTokens::DurationMs::kFast);

  m_contentWidget = new DetailContentWidget(m_mainScrollArea);
  m_contentWidget->setObjectName("detail-content-container");

  auto *contentLayout = new QVBoxLayout(m_contentWidget);
  contentLayout->setContentsMargins(0, 0, 0, 10);
  contentLayout->setSpacing(0);

  QWidget *infoContainer = new QWidget(m_contentWidget);
  infoContainer->setObjectName("detail-info-container");
  infoContainer->setStyleSheet(
      "QWidget#detail-info-container { background: transparent; }");

  m_infoLayout = new QGridLayout(infoContainer);
  m_infoLayout->setContentsMargins(40, 40, 40, 0);
  m_infoLayout->setHorizontalSpacing(40);
  m_infoLayout->setVerticalSpacing(0);
  m_infoLayout->setRowMinimumHeight(0, 110);

  m_logoLabel = new QLabel(infoContainer);
  m_logoLabel->setObjectName("detail-logo-label");
  m_logoLabel->setAlignment(Qt::AlignRight | Qt::AlignTop);
  m_infoLayout->addWidget(m_logoLabel, 0, 1, 1, 2,
                          Qt::AlignRight | Qt::AlignTop);

  m_posterLabel = new QLabel(infoContainer);
  m_posterLabel->setFixedSize(250, 375);
  m_posterLabel->setObjectName("detail-poster-label");
  m_posterLabel->setAlignment(Qt::AlignCenter);

  
  
  
  m_posterShadow = new QGraphicsDropShadowEffect(this);
  m_posterShadow->setBlurRadius(20);
  m_posterShadow->setColor(QColor(0, 0, 0, 80));
  m_posterShadow->setOffset(0, 8);
  m_posterShadow->setEnabled(false);
  m_posterLabel->setGraphicsEffect(m_posterShadow);
  m_infoLayout->addWidget(m_posterLabel, 1, 0, 1, 1, Qt::AlignTop);

  m_textContainer = new QWidget(infoContainer);
  m_textContainer->setMaximumWidth(1200);
  m_textContainer->setSizePolicy(QSizePolicy::Expanding,
                                 QSizePolicy::Preferred);
  auto *textLayout = new QVBoxLayout(m_textContainer);
  textLayout->setContentsMargins(0, 0, 0, 0);
  textLayout->setSpacing(10);
  textLayout->setAlignment(Qt::AlignTop);

  m_titleLabel = new QLabel(m_textContainer);
  m_titleLabel->setObjectName("detail-title");
  m_titleLabel->setWordWrap(true);

  m_metaRowWidget = new QWidget(m_textContainer);
  m_metaRowWidget->setObjectName("detail-meta-row");
  auto *metaLayout = new QHBoxLayout(m_metaRowWidget);
  metaLayout->setContentsMargins(0, 0, 0, 0);
  metaLayout->setSpacing(6);

  m_ratingStarLabel = new QLabel(m_metaRowWidget);
  m_ratingStarLabel->setFixedWidth(16);
  m_ratingStarLabel->setAlignment(Qt::AlignCenter);
  m_ratingStarLabel->setPixmap(
      QIcon(":/svg/dark/star-filled.svg").pixmap(16, 16));
  m_ratingStarLabel->setContentsMargins(0, 2, 0, 0);
  m_ratingStarLabel->hide();

  m_metaLabel = new QLabel(m_metaRowWidget);
  m_metaLabel->setObjectName("detail-meta");
  m_metaLabel->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Preferred);

  m_numberButton = new QPushButton(m_metaRowWidget);
  m_numberButton->setObjectName("detail-number-chip");
  m_numberButton->setCursor(Qt::PointingHandCursor);
  m_numberButton->setFocusPolicy(Qt::NoFocus);
  m_numberButton->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Fixed);
  m_numberButton->hide();
  connect(m_numberButton, &QPushButton::clicked, this,
          &DetailView::copyDisplayedNumber);

  metaLayout->addWidget(m_ratingStarLabel);
  metaLayout->addWidget(m_metaLabel, 0, Qt::AlignLeft);
  metaLayout->addWidget(m_numberButton, 0, Qt::AlignLeft);
  metaLayout->addStretch(1);
  m_metaRowWidget->hide();

  m_tagsWidget = new QWidget(m_textContainer);
  m_tagsWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
  m_tagsLayout = new FlowLayout(m_tagsWidget, 0, 8, 8);

  m_actionWidget = new DetailActionWidget(m_textContainer);
  connect(m_actionWidget, &DetailActionWidget::playRequested, this,
          [this]() -> QCoro::Task<void> {
            co_await executePlay(m_currentPlayableItem, 0);
          });
  connect(m_actionWidget, &DetailActionWidget::resumeRequested, this,
          [this]() -> QCoro::Task<void> {
            co_await executePlay(
                m_currentPlayableItem,
                m_currentPlayableItem.userData.playbackPositionTicks);
          });
  connect(m_actionWidget, &DetailActionWidget::favoriteRequested, this,
          [this]() {
            if (!m_currentMediaItem.id.isEmpty())
              handleFavoriteRequested(m_currentMediaItem);
          });
  connect(m_actionWidget, &DetailActionWidget::playedToggleRequested, this,
          [this]() {
            const MediaItem &target =
                m_currentPlayableItem.type == "Episode" ? m_currentPlayableItem
                                                        : m_currentMediaItem;
            if (target.id.isEmpty())
              return;
            if (target.userData.played)
              handleMarkUnplayedRequested(target);
            else
              handleMarkPlayedRequested(target);
          });
  connect(ThemeManager::instance(), &ThemeManager::themeChanged, this,
          [this]() {
            const MediaItem &target =
                m_currentPlayableItem.type == "Episode" ? m_currentPlayableItem
                                                        : m_currentMediaItem;
            if (!target.id.isEmpty())
              m_actionWidget->setPlayedState(target.userData.played);
          });
  connect(m_actionWidget, &DetailActionWidget::sourceVersionChanged, this,
          &DetailView::onVersionChanged);
  connect(m_actionWidget, &DetailActionWidget::externalPlayRequested, this,
          [this](const QString &playerPath) -> QCoro::Task<void> {
            co_await executeExternalPlay(m_currentPlayableItem, playerPath);
          });

  m_taglineLabel = new QLabel(m_textContainer);
  m_taglineLabel->setObjectName("detail-tagline");

  m_overviewLabel = new QLabel(m_textContainer);
  m_overviewLabel->setObjectName("detail-overview");
  m_overviewLabel->setWordWrap(true);
  m_overviewLabel->setSizePolicy(QSizePolicy::Preferred,
                                 QSizePolicy::Preferred);
  m_overviewLabel->setAlignment(Qt::AlignTop | Qt::AlignLeft);
  m_overviewLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
  connect(m_overviewLabel, &QLabel::linkActivated, this,
          &DetailView::onOverviewMoreClicked);

  textLayout->addWidget(m_titleLabel);
  textLayout->addWidget(m_metaRowWidget);
  textLayout->addWidget(m_tagsWidget);
  textLayout->addWidget(m_actionWidget);
  textLayout->addSpacing(4);
  textLayout->addWidget(m_taglineLabel);
  textLayout->addWidget(m_overviewLabel);
  textLayout->addSpacing(10);

  m_infoLayout->addWidget(m_textContainer, 1, 1, 1, 1, Qt::AlignTop);
  m_infoLayout->setColumnStretch(0, 0);
  m_infoLayout->setColumnStretch(1, 10);
  m_infoLayout->setColumnStretch(2, 1);
  contentLayout->addWidget(infoContainer);

  
  
  
  m_seasonWidget =
      new MediaSectionWidget(tr("Seasons"), m_core, m_contentWidget);
  m_seasonWidget->setCardStyle(MediaCardDelegate::Poster);
  m_seasonWidget->setGalleryHeight(300);

  
  m_episodeWidget =
      new MediaSectionWidget(tr("Episodes"), m_core, m_contentWidget);
  m_episodeWidget->setCardStyle(MediaCardDelegate::LibraryTile);
  m_episodeWidget->gallery()->setHoverControls(
      MediaCardDelegate::HoverControlPlay |
      MediaCardDelegate::HoverControlMore);
  
  
  {
    int imgH = 100;
    int imgW = qRound(imgH * 16.0 / 9.0); 
    const QSize episodeTileSize(imgW + 16, 8 + imgH + 6 + 20); 
    m_episodeTileWidth = episodeTileSize.width();
    m_episodeWidget->setTileSize(episodeTileSize);
  }
  m_episodeWidget->setGalleryHeight(145);

  
  m_episodeHeaderControls = new QWidget(m_episodeWidget);
  m_episodeHeaderControls->setObjectName("detail-episode-header-controls");
  m_episodeHeaderControls->setSizePolicy(QSizePolicy::Fixed,
                                         QSizePolicy::Fixed);
  auto *episodeHeaderLayout = new QHBoxLayout(m_episodeHeaderControls);
  episodeHeaderLayout->setContentsMargins(0, 0, 0, 0);
  episodeHeaderLayout->setSpacing(6);
  episodeHeaderLayout->setSizeConstraint(QLayout::SetFixedSize);

  m_seasonSwitcher = new ModernMenuButton(m_episodeHeaderControls);
  m_seasonSwitcher->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
  m_seasonSwitcher->hide(); 

  m_episodeJumpEdit = new QLineEdit(m_episodeHeaderControls);
  m_episodeJumpEdit->setObjectName("detail-episode-jump-edit");
  m_episodeJumpEdit->setPlaceholderText(tr("Ep #"));
  m_episodeJumpEdit->setToolTip(tr("Jump to episode number"));
  m_episodeJumpEdit->setAlignment(Qt::AlignCenter);
  m_episodeJumpEdit->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
  m_episodeJumpEdit->setFixedWidth(64);
  m_episodeJumpEdit->setFixedHeight(m_seasonSwitcher->sizeHint().height());
  m_episodeJumpEdit->setMaxLength(4);
  m_episodeJumpValidator = new QIntValidator(1, 9999, m_episodeJumpEdit);
  m_episodeJumpEdit->setValidator(m_episodeJumpValidator);
  m_episodeJumpEdit->hide(); 

  episodeHeaderLayout->addWidget(m_seasonSwitcher, 0, Qt::AlignVCenter);
  episodeHeaderLayout->addWidget(m_episodeJumpEdit, 0, Qt::AlignVCenter);
  m_episodeHeaderControls->hide();
  m_episodeWidget->setHeaderWidget(m_episodeHeaderControls);
  m_episodeHeaderControls->hide();

  m_episodeSectionReserveWidget = createTransparentReserveWidget(
      m_contentWidget, "detail-episode-section-reserve",
      reserveHeightFor(m_episodeWidget, 190));
  m_seasonSectionReserveWidget = createTransparentReserveWidget(
      m_contentWidget, "detail-season-section-reserve",
      reserveHeightFor(m_seasonWidget, 320));

  connect(m_seasonSwitcher, &ModernMenuButton::currentIndexChanged, this,
          [this](int idx) {
            if (idx >= 0 && idx != m_currentSeasonIndex) {
              markManualSeriesSelection(QStringLiteral("season-switcher"));
              m_currentSeasonIndex = idx;
              QCoro::connect(switchToSeason(idx, true), this, []() {});
            }
          });
  connect(m_episodeJumpEdit, &QLineEdit::editingFinished, this,
          &DetailView::submitEpisodeJump);

  m_castWidget =
      new MediaSectionWidget(tr("Cast & Crew"), m_core, m_contentWidget);
  m_castWidget->setCardStyle(MediaCardDelegate::Cast);
  m_castWidget->setGalleryHeight(280);

  m_castSectionReserveWidget = new QWidget(m_contentWidget);
  m_castSectionReserveWidget->setObjectName("detail-cast-section-reserve");
  m_castSectionReserveWidget->setFixedHeight(
      qMax(320, m_castWidget->sizeHint().height()));
  m_castSectionReserveWidget->hide();

  m_additionalPartsWidget =
      new MediaSectionWidget(tr("Additional Parts"), m_core, m_contentWidget);
  m_additionalPartsWidget->setCardStyle(MediaCardDelegate::Poster);
  m_additionalPartsWidget->setGalleryHeight(300);
  m_additionalPartsSectionReserveWidget = createTransparentReserveWidget(
      m_contentWidget, "detail-additional-section-reserve",
      reserveHeightFor(m_additionalPartsWidget, 350));

  m_collectionWidget =
      new MediaSectionWidget(tr("Collection"), m_core, m_contentWidget);
  m_collectionWidget->setCardStyle(MediaCardDelegate::Poster);
  m_collectionWidget->setGalleryHeight(300);
  m_collectionSectionReserveWidget = createTransparentReserveWidget(
      m_contentWidget, "detail-collection-section-reserve",
      reserveHeightFor(m_collectionWidget, 350));

  m_similarWidget =
      new MediaSectionWidget(tr("More Like This"), m_core, m_contentWidget);
  m_similarWidget->setCardStyle(MediaCardDelegate::Poster);
  m_similarWidget->setGalleryHeight(300);
  m_similarSectionReserveWidget = createTransparentReserveWidget(
      m_contentWidget, "detail-similar-section-reserve",
      reserveHeightFor(m_similarWidget, 350));

  m_seasonWidget->gallery()->listView()->viewport()->installEventFilter(this);
  m_episodeWidget->gallery()->listView()->viewport()->installEventFilter(this);
  m_castWidget->gallery()->listView()->viewport()->installEventFilter(this);
  m_additionalPartsWidget->gallery()
      ->listView()
      ->viewport()
      ->installEventFilter(this);
  m_collectionWidget->gallery()->listView()->viewport()->installEventFilter(
      this);
  m_similarWidget->gallery()->listView()->viewport()->installEventFilter(this);

  auto connectGallerySignals = [this](MediaSectionWidget *widget) {
    connect(widget, &MediaSectionWidget::playRequested, this,
            &BaseView::handlePlayRequested);
    connect(widget, &MediaSectionWidget::favoriteRequested, this,
            &BaseView::handleFavoriteRequested);
    connect(widget, &MediaSectionWidget::moreMenuRequested, this,
            &BaseView::handleMoreMenuRequested);
  };

  connectGallerySignals(m_castWidget);
  connectGallerySignals(m_additionalPartsWidget);
  connectGallerySignals(m_collectionWidget);
  connectGallerySignals(m_similarWidget);

  connect(m_seasonWidget, &MediaSectionWidget::playRequested, this,
          [this](MediaItem item) -> QCoro::Task<void> {
            if (item.type == "Season") {
              markManualSeriesSelection(QStringLiteral("season-play"));
              co_await executePlaySeason(item);
            } else {
              handlePlayRequested(item);
            }
          });
  connect(m_seasonWidget, &MediaSectionWidget::favoriteRequested, this,
          &BaseView::handleFavoriteRequested);
  connect(m_seasonWidget, &MediaSectionWidget::moreMenuRequested, this,
          &BaseView::handleMoreMenuRequested);

  connect(m_episodeWidget, &MediaSectionWidget::playRequested, this,
          [this](MediaItem item) -> QCoro::Task<void> {
            if (item.type == "Episode") {
              markManualSeriesSelection(QStringLiteral("episode-play"));
              co_await applySeriesPlayableItem(item, false);
              if (m_currentPlayableItem.id == item.id) {
                co_await executePlay(
                    m_currentPlayableItem,
                    m_currentPlayableItem.userData.playbackPositionTicks);
              }
            } else {
              handlePlayRequested(item);
            }
          });
  connect(m_episodeWidget, &MediaSectionWidget::favoriteRequested, this,
          &BaseView::handleFavoriteRequested);
  connect(m_episodeWidget, &MediaSectionWidget::moreMenuRequested, this,
          [this](const MediaItem &item, const QPoint &globalPos) {
            MediaActionMenu menu(item, m_core, this,
                                 {CardContextMenuAction::MarkPlayed,
                                  CardContextMenuAction::MarkUnplayed});
            CardContextMenuRequest request = menu.execRequest(globalPos);
            dispatchCardContextMenuRequest(item, request);
          });

  auto commonClicked = [this](const MediaItem &item) {
    if (item.type == "BoxSet" || item.type == "Playlist" ||
        item.type == "Folder")
      Q_EMIT navigateToFolder(item.id, item.name);
    else if (item.type == "Person")
      Q_EMIT navigateToPerson(item.id, item.name);
    else
      Q_EMIT navigateToDetail(item.id, item.name, item);
  };

  
  connect(m_seasonWidget, &MediaSectionWidget::itemClicked, this,
          [this](const MediaItem &item) {
            if (item.type == "Season")
              Q_EMIT navigateToSeason(m_currentItemId, item.id, item.name);
            else
              Q_EMIT navigateToDetail(item.id, item.name, item);
          });

  
  connect(m_episodeWidget, &MediaSectionWidget::itemClicked, this,
          [this, commonClicked](const MediaItem &item) {
            if (item.type == "Episode") {
              markManualSeriesSelection(QStringLiteral("episode-click"));
              QCoro::connect(applySeriesPlayableItem(item, true), this,
                             []() {});
            } else {
              commonClicked(item);
            }
          });

  connect(m_castWidget, &MediaSectionWidget::itemClicked, this,
          [this](const MediaItem &item) {
            Q_EMIT navigateToPerson(item.id, item.name);
          });
  connect(m_additionalPartsWidget, &MediaSectionWidget::itemClicked, this,
          commonClicked);
  connect(m_collectionWidget, &MediaSectionWidget::itemClicked, this,
          [this, commonClicked](const MediaItem &item) {
            if (!item.id.isEmpty()) {
              qDebug() << "[DetailView] Navigate collection membership"
                       << "itemId=" << item.id << "name=" << item.name
                       << "type=" << item.type
                       << "collectionType=" << item.collectionType;
              Q_EMIT navigateToFolder(item.id, item.name);
              return;
            }
            commonClicked(item);
          });
  connect(m_similarWidget, &MediaSectionWidget::itemClicked, this,
          commonClicked);

  contentLayout->addWidget(m_episodeSectionReserveWidget);
  contentLayout->addWidget(m_episodeWidget);
  contentLayout->addWidget(m_seasonSectionReserveWidget);
  contentLayout->addWidget(m_seasonWidget);
  contentLayout->addWidget(m_castSectionReserveWidget);
  contentLayout->addWidget(m_castWidget);
  contentLayout->addWidget(m_additionalPartsSectionReserveWidget);
  contentLayout->addWidget(m_additionalPartsWidget);
  contentLayout->addWidget(m_collectionSectionReserveWidget);
  contentLayout->addWidget(m_collectionWidget);
  contentLayout->addWidget(m_similarSectionReserveWidget);
  contentLayout->addWidget(m_similarWidget);

  m_bottomInfoWidget = new DetailBottomInfoWidget(m_contentWidget);
  connect(m_bottomInfoWidget, &DetailBottomInfoWidget::filterClicked, this,
          [this](const QString &type, const QString &value) {
            Q_EMIT navigateToFilteredView(type, value);
          });
  m_bottomInfoReserveWidget = createTransparentReserveWidget(
      m_contentWidget, "detail-bottom-info-reserve", 220);
  contentLayout->addWidget(m_bottomInfoReserveWidget);
  contentLayout->addWidget(m_bottomInfoWidget);

  contentLayout->addStretch();
  m_mainScrollArea->setWidget(m_contentWidget);
  mainLayout->addWidget(m_mainScrollArea);
  m_mainScrollArea->viewport()->installEventFilter(this);
}

QCoro::Task<void> DetailView::loadItem(const QString &itemId,
                                       const MediaItem &seedItem) {
  QPointer<DetailView> safeThis(this);
  setDeferredPresentationBatchActive(false);
  m_currentItemId = itemId;
  
  
  m_skipNextSilentRefresh = true;
  m_pendingDeferredFetchId = itemId;
  m_pendingFetchedItem = MediaItem{};
  m_pendingFetchReady = false;
  m_pendingAnimationGuardDone = false;
  m_pendingFetchedItemFromCache = false;
  m_deferBottomInfoReveal = false;
  m_currentPlayableItem = MediaItem{};
  m_currentSeasonEpisodes.clear();
  updateEpisodeJumpControl(0);
  
  m_appliedSourcesFingerprint.clear();
  m_appliedBottomInfoFingerprint.clear();
  m_detailCacheServerId.clear();
  m_detailCacheUserId.clear();
  m_cachedDetailFingerprint.clear();
  m_cachedSectionsFingerprint.clear();
  m_cachedSeriesPlayableItem = MediaItem{};
  m_cachedSeriesSeasons.clear();
  m_cachedSeasonEpisodes.clear();
  m_cachedSimilarItems.clear();
  m_cachedCollections.clear();
  m_cachedAdditionalParts.clear();
  m_cachedSeasonId.clear();
  m_manualSelectedSeasonId.clear();
  m_manualSelectedEpisodeId.clear();
  m_cachedSeasonIndex = -1;
  m_manualSelectedSeasonIndex = -1;
  m_hasManualSeriesSelection = false;
  m_hasCachedSeriesPlayableItem = false;
  m_hasCachedSeriesSeasons = false;
  m_hasCachedSeasonEpisodes = false;
  m_hasCachedSimilarItems = false;
  m_hasCachedCollections = false;
  m_hasCachedAdditionalParts = false;
  m_hasCachedCastData = false;
  m_appliedCachedCastToUi = false;
  m_appliedCachedSeriesSeasonsToUi = false;
  m_appliedCachedSeasonEpisodesToUi = false;
  m_appliedCachedSimilarItemsToUi = false;
  m_appliedCachedCollectionsToUi = false;
  m_appliedCachedAdditionalPartsToUi = false;
  m_appliedCastFingerprint.clear();
  m_appliedSeriesPlayableFingerprint.clear();

  if (m_core && m_core->serverManager()) {
    const ServerProfile profile = m_core->serverManager()->activeProfile();
    m_detailCacheServerId = profile.id;
    m_detailCacheUserId = profile.userId;
  }

  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  const bool hasSeed = !seedItem.id.isEmpty();
  
  
  
  m_deferBottomInfoReveal = hasSeed;

  if (hasSeed) {
    m_currentPlayableItem = seedItem;
    applySeedToUi(seedItem);
    if (seedItem.type == "Series") {
      prepareReservedSection(m_episodeSectionReserveWidget, m_episodeWidget,
                             reserveHeightFor(m_episodeWidget, 190));
      prepareReservedSection(m_seasonSectionReserveWidget, m_seasonWidget,
                             reserveHeightFor(m_seasonWidget, 320));
    } else {
      hideReserveWidget(m_episodeSectionReserveWidget);
      hideReserveWidget(m_seasonSectionReserveWidget);
      m_seasonWidget->clear();
      m_episodeWidget->clear();
    }
  } else {
    
    m_titleLabel->setText(tr("Loading..."));
    m_logoLabel->clear();
    m_logoLabel->hide();
    m_metaLabel->clear();
    updateDisplayNumber(QString());
    m_metaRowWidget->hide();
    m_overviewLabel->clear();
    m_taglineLabel->hide();

    m_currentBackdropPix = QPixmap();
    m_currentPosterPix = QPixmap();
    updateBackdrop();
    m_posterLabel->setPixmap(QPixmap());

    m_actionWidget->clear();
    m_bottomInfoWidget->clear();
    clearLayout(m_tagsLayout);

    m_seasonWidget->clear();
    m_episodeWidget->clear();
    hideReserveWidget(m_episodeSectionReserveWidget);
    hideReserveWidget(m_seasonSectionReserveWidget);

    m_seriesSeasons.clear();
    m_currentSeasonIndex = 0;
    if (m_seasonSwitcher) {
      QSignalBlocker blocker(m_seasonSwitcher);
      m_seasonSwitcher->clear();
      m_seasonSwitcher->hide();
    }
    updateEpisodeHeaderControlsVisibility();
  }

  
  
  prepareReservedSection(m_castSectionReserveWidget, m_castWidget,
                         reserveHeightFor(m_castWidget, 320));
  prepareReservedSection(m_additionalPartsSectionReserveWidget,
                         m_additionalPartsWidget,
                         reserveHeightFor(m_additionalPartsWidget, 350));
  prepareReservedSection(m_collectionSectionReserveWidget, m_collectionWidget,
                         reserveHeightFor(m_collectionWidget, 350));
  prepareReservedSection(m_similarSectionReserveWidget, m_similarWidget,
                         reserveHeightFor(m_similarWidget, 350));

  scrollToTop();

  
  
  if (!itemId.isEmpty()) {
    QCoro::connect(loadDetailCacheAndStartPrefetch(
                       itemId, seedItem, m_detailCacheServerId,
                       m_detailCacheUserId),
                   this, []() {});
  }

  
  
  // Guard tracks the page-slide duration (kSlow) so the poster shadow / deferred
  // content reveal lands as the incoming slide settles; kept in sync via the token.
  QTimer::singleShot(AnimationTokens::DurationMs::kSlow, this, [safeThis, itemId]() {
    if (!safeThis || safeThis->m_pendingDeferredFetchId != itemId)
      return;
    if (safeThis->m_posterShadow)
      safeThis->m_posterShadow->setEnabled(true);
    safeThis->m_pendingAnimationGuardDone = true;
    safeThis->maybeFlushDeferredUpdate(itemId);
  });

  co_return;
}

QCoro::Task<void>
DetailView::loadDetailCacheAndStartPrefetch(QString itemId, MediaItem seedItem,
                                            QString cacheServerId,
                                            QString cacheUserId) {
  QPointer<DetailView> safeThis(this);
  QString targetId = std::move(itemId);
  MediaItem seed = std::move(seedItem);
  QString serverId = std::move(cacheServerId);
  QString userId = std::move(cacheUserId);
  QString cachedFingerprint;

  if (!serverId.isEmpty() && !userId.isEmpty() && !targetId.isEmpty()) {
    const auto cachedEntry = co_await QtConcurrent::run(
        [serverId, userId, targetId]() mutable {
          return DetailCacheUtils::load(serverId, userId, targetId);
        });
    if (!safeThis || safeThis->m_currentItemId != targetId)
      co_return;

    if (cachedEntry.has_value()) {
      MediaItem cachedItem = withSeedContext(cachedEntry->item, seed);
      cachedFingerprint = cachedEntry->fingerprint;

      safeThis->m_cachedDetailFingerprint = cachedEntry->fingerprint;
      safeThis->m_cachedSectionsFingerprint =
          cachedEntry->sectionsFingerprint;
      safeThis->m_cachedSeriesPlayableItem =
          withSeedContext(cachedEntry->playableItem, MediaItem{});
      safeThis->m_cachedSeriesSeasons = cachedEntry->seasons;
      safeThis->m_cachedSeasonEpisodes = cachedEntry->seasonEpisodes;
      safeThis->m_cachedSimilarItems = cachedEntry->similarItems;
      safeThis->m_cachedCollections = cachedEntry->collections;
      safeThis->m_cachedAdditionalParts = cachedEntry->additionalParts;
      safeThis->m_cachedSeasonId = cachedEntry->seasonId;
      safeThis->m_cachedSeasonIndex = cachedEntry->seasonIndex;
      safeThis->m_manualSelectedSeasonId.clear();
      safeThis->m_manualSelectedSeasonIndex = -1;
      safeThis->m_manualSelectedEpisodeId.clear();
      safeThis->m_hasCachedSeriesPlayableItem =
          cachedEntry->hasPlayableItem && cachedEntry->playableItemFromServer;
      if (!safeThis->m_hasCachedSeriesPlayableItem)
        safeThis->m_cachedSeriesPlayableItem = MediaItem{};
      safeThis->m_hasCachedSeriesSeasons = cachedEntry->hasSeasons;
      safeThis->m_hasCachedSeasonEpisodes =
          cachedEntry->hasSeasonEpisodes;
      safeThis->m_hasCachedSimilarItems = cachedEntry->hasSimilarItems;
      safeThis->m_hasCachedCollections = cachedEntry->hasCollections;
      safeThis->m_hasCachedAdditionalParts =
          cachedEntry->hasAdditionalParts;
      safeThis->m_hasCachedCastData = !cachedItem.people.isEmpty();
      const bool hasCachedSecondaryData =
          cacheEntryHasAnySecondaryData(*cachedEntry);

      if (!cachedItem.name.trimmed().isEmpty()) {
        safeThis->m_pendingFetchedItem = cachedItem;
        safeThis->m_pendingFetchReady = true;
        safeThis->m_pendingFetchedItemFromCache = true;

        
        
        const bool hasSeedUi =
            safeThis->m_currentMediaItem.id == targetId &&
            !safeThis->m_currentMediaItem.name.trimmed().isEmpty();
        if (!hasSeedUi) {
          safeThis->applySeedToUi(cachedItem);
        }
        safeThis->maybeFlushDeferredUpdate(targetId);

        qDebug() << "[DetailView] Detail cache hit"
                 << "itemId=" << targetId
                 << "fingerprint=" << cachedFingerprint.left(12)
                 << "hasSecondaryCache=" << hasCachedSecondaryData
                 << "deferredSeedApply=" << hasSeedUi;
      } else {
        cachedFingerprint.clear();
        safeThis->m_cachedDetailFingerprint.clear();
        safeThis->m_cachedSectionsFingerprint.clear();
        safeThis->m_cachedSeriesPlayableItem = MediaItem{};
        safeThis->m_cachedSeriesSeasons.clear();
        safeThis->m_cachedSeasonEpisodes.clear();
        safeThis->m_cachedSimilarItems.clear();
        safeThis->m_cachedCollections.clear();
        safeThis->m_cachedAdditionalParts.clear();
        safeThis->m_cachedSeasonId.clear();
        safeThis->m_manualSelectedSeasonId.clear();
        safeThis->m_manualSelectedEpisodeId.clear();
        safeThis->m_cachedSeasonIndex = -1;
        safeThis->m_manualSelectedSeasonIndex = -1;
        safeThis->m_hasCachedSeriesPlayableItem = false;
        safeThis->m_hasCachedSeriesSeasons = false;
        safeThis->m_hasCachedSeasonEpisodes = false;
        safeThis->m_hasCachedSimilarItems = false;
        safeThis->m_hasCachedCollections = false;
        safeThis->m_hasCachedAdditionalParts = false;
        safeThis->m_hasCachedCastData = false;
        qWarning() << "[DetailView] Ignore incomplete detail cache"
                   << "itemId=" << targetId
                   << "file=" << cachedEntry->filePath;
      }
    } else {
      qDebug() << "[DetailView] Detail cache miss"
               << "itemId=" << targetId;
    }
  }

  if (!safeThis || safeThis->m_currentItemId != targetId)
    co_return;

  if (safeThis->m_core && safeThis->m_core->mediaService()) {
    QCoro::connect(safeThis->prefetchItemDetail(targetId, serverId, userId,
                                                cachedFingerprint),
                   safeThis.data(), []() {});
  }
}

QCoro::Task<void> DetailView::prefetchItemDetail(QString itemId,
                                                 QString cacheServerId,
                                                 QString cacheUserId,
                                                 QString cachedFingerprint) {
  QPointer<DetailView> safeThis(this);
  QString targetId = std::move(itemId);
  QString serverId = std::move(cacheServerId);
  QString userId = std::move(cacheUserId);
  QString previousFingerprint = std::move(cachedFingerprint);

  try {
    MediaItem item =
        co_await m_core->mediaService()->getItemDetail(targetId);
    const QString fetchedFingerprint = co_await QtConcurrent::run(
        [item]() mutable { return DetailCacheUtils::fingerprint(item); });
    const bool differsFromCache =
        previousFingerprint.isEmpty() ||
        fetchedFingerprint != previousFingerprint;

    if (differsFromCache) {
      saveDetailCacheAsync(serverId, userId, item, fetchedFingerprint);
    } else {
      qDebug() << "[DetailView] Detail cache unchanged"
               << "itemId=" << targetId
               << "fingerprint=" << fetchedFingerprint.left(12);
    }

    if (!safeThis || (safeThis->m_pendingDeferredFetchId != targetId &&
                      safeThis->m_currentItemId != targetId)) {
      
      co_return;
    }

    safeThis->m_cachedDetailFingerprint = fetchedFingerprint;

    if (safeThis->m_pendingDeferredFetchId == targetId) {
      if (!differsFromCache && safeThis->m_pendingFetchReady &&
          safeThis->m_pendingFetchedItemFromCache) {
        safeThis->maybeFlushDeferredUpdate(targetId);
        co_return;
      }

      
      
      safeThis->m_pendingFetchedItem = std::move(item);
      safeThis->m_pendingFetchReady = true;
      safeThis->m_pendingFetchedItemFromCache = false;
      safeThis->maybeFlushDeferredUpdate(targetId);
      co_return;
    }

    
    if (safeThis->m_currentItemId == targetId && differsFromCache) {
      qDebug() << "[DetailView] Applying refreshed detail after cache"
               << "itemId=" << targetId;
      QCoro::connect(safeThis->executeDeferredUpdate(std::move(item), true),
                     safeThis.data(), []() {});
    }
  } catch (...) {
    if (safeThis && safeThis->m_pendingDeferredFetchId == targetId) {
      if (!safeThis->m_pendingFetchReady &&
          safeThis->m_currentMediaItem.id != targetId) {
        safeThis->m_pendingDeferredFetchId.clear();
        const QString errorText = tr("Error Loading Item");
        QMetaObject::invokeMethod(
            safeThis.data(),
            [safeThis, targetId, errorText]() {
              if (safeThis && safeThis->m_currentItemId == targetId)
                safeThis->m_titleLabel->setText(errorText);
            },
            Qt::QueuedConnection);
      } else {
        qDebug() << "[DetailView] Detail refresh failed; using existing data"
                 << "itemId=" << targetId;
      }
    }
  }
}

void DetailView::maybeFlushDeferredUpdate(const QString &itemId) {
  if (m_pendingDeferredFetchId != itemId)
    return;
  if (!m_pendingFetchReady || !m_pendingAnimationGuardDone)
    return;

  
  m_pendingDeferredFetchId.clear();

  MediaItem item = m_pendingFetchedItem;
  const bool fromCache = m_pendingFetchedItemFromCache;
  m_pendingFetchedItem = MediaItem{};
  m_pendingFetchReady = false;
  m_pendingAnimationGuardDone = false;
  m_pendingFetchedItemFromCache = false;

  if (item.type != "Series" || m_currentPlayableItem.type != "Episode" ||
      m_currentPlayableItem.id.isEmpty()) {
    m_currentPlayableItem = item;
  }
  qDebug() << "[DetailView] Deferred detail update"
           << "itemId=" << itemId << "fromCache=" << fromCache;
  QCoro::connect(executeDeferredUpdate(std::move(item)), this, []() {});
}

QCoro::Task<void> DetailView::executeDeferredUpdate(MediaItem item,
                                                    bool isSilentRefresh) {
  QPointer<DetailView> safeThis(this);
  const QString targetId = item.id;
  const QString detectedType = item.type;
  const bool batchPresentation = isVisible();

  if (batchPresentation) {
    
    
    
    setDeferredPresentationBatchActive(true);
    QTimer::singleShot(160, this, [safeThis]() {
      if (safeThis && safeThis->m_deferredPresentationBatchActive)
        safeThis->setDeferredPresentationBatchActive(false);
    });
  }

  
  
  
  co_await updateUi(item, isSilentRefresh);
  if (!safeThis)
    co_return;
  safeThis->persistDetailCacheSnapshot(QStringLiteral("detail-ui"));

  if (isSilentRefresh) {
    safeThis->setDeferredPresentationBatchActive(false);
    co_return;
  }

  if (batchPresentation) {
    QTimer::singleShot(0, safeThis.data(),
                       [safeThis, targetId, detectedType]() {
                         if (!safeThis)
                           return;
                         safeThis->finishDeferredPresentationBatch(targetId,
                                                                   detectedType);
                       });
  } else {
    safeThis->startSecondaryFetches(targetId, detectedType);
  }
}

void DetailView::setDeferredPresentationBatchActive(bool active) {
  m_deferredPresentationBatchActive = active;
}

void DetailView::finishDeferredPresentationBatch(
    const QString &targetId, const QString &detectedType) {
  if (m_currentItemId != targetId) {
    setDeferredPresentationBatchActive(false);
    return;
  }

  updateTagLayoutHeight();
  updateEpisodeJumpControl(m_currentSeasonEpisodes.size());

  if (m_contentWidget && m_contentWidget->layout())
    m_contentWidget->layout()->activate();
  if (layout())
    layout()->activate();

  setDeferredPresentationBatchActive(false);

  startSecondaryFetches(targetId, detectedType);
}

void DetailView::startSecondaryFetches(const QString &targetId,
                                       const QString &detectedType) {
  if (targetId.isEmpty() || !m_core || !m_core->mediaService())
    return;

  const auto startNetworkFetches = [this, targetId, detectedType]() {
    qDebug() << "[DetailView][network] Start secondary fetches"
             << "itemId=" << targetId << "type=" << detectedType;
    QCoro::connect(
        executeFetchSecondaries(QPointer<DetailView>(this), m_core, targetId,
                                detectedType),
        this, []() {});
  };

  if (detectedType == "Series") {
    const bool hasCachedSeriesSecondaryUi =
        m_hasCachedCastData || m_hasCachedSeriesPlayableItem ||
        m_hasCachedSeriesSeasons || m_hasCachedSeasonEpisodes ||
        m_hasCachedSimilarItems || m_hasCachedCollections ||
        m_hasCachedAdditionalParts;
    startNetworkFetches();
    if (hasCachedSeriesSecondaryUi) {
      applyCachedSecondaryData(targetId, detectedType);
    } else {
      qDebug() << "[DetailView][cache-ui] Skip cached secondary data"
               << "itemId=" << targetId << "type=" << detectedType
               << "reason=" << "no-cached-series-secondary-data";
    }
    return;
  }

  applyCachedSecondaryData(targetId, detectedType);
  startNetworkFetches();
}

void DetailView::applyCachedSecondaryData(const QString &targetId,
                                          const QString &detectedType,
                                          bool revealBottomInfo) {
  if (targetId != m_currentItemId)
    return;

  qDebug() << "[DetailView][cache-ui] Applying cached secondary data"
           << "itemId=" << targetId << "type=" << detectedType
           << "sections=" << m_cachedSectionsFingerprint.left(12);

  if (detectedType == "Series") {
    if (!m_hasManualSeriesSelection && m_hasCachedSeriesPlayableItem &&
        m_cachedSeriesPlayableItem.type == "Episode" &&
        !m_cachedSeriesPlayableItem.id.isEmpty()) {
      if (m_currentPlayableItem.id != m_cachedSeriesPlayableItem.id)
        applySeriesPlayableItemToUi(m_cachedSeriesPlayableItem);
    }

    if (m_hasCachedSeriesSeasons && !m_appliedCachedSeriesSeasonsToUi) {
      m_seriesSeasons = m_cachedSeriesSeasons;
      int targetSeasonIdx = 0;
      const int cachedEpisodeSeasonIndex = m_cachedSeasonIndex;
      const QString cachedEpisodeSeasonId = m_cachedSeasonId;
      bool selectedSeasonResolved = false;
      if (m_hasManualSeriesSelection && m_currentSeasonIndex >= 0 &&
          m_currentSeasonIndex < m_seriesSeasons.size()) {
        targetSeasonIdx = m_currentSeasonIndex;
        selectedSeasonResolved = true;
      }
      const int playableParentIdx = m_currentPlayableItem.parentIndexNumber;
      if (!selectedSeasonResolved && !m_hasManualSeriesSelection &&
          playableParentIdx >= 0) {
        for (int i = 0; i < m_seriesSeasons.size(); ++i) {
          if (m_seriesSeasons[i].indexNumber == playableParentIdx) {
            targetSeasonIdx = i;
            break;
          }
        }
      }
      if (!m_seriesSeasons.isEmpty()) {
        targetSeasonIdx = qBound(0, targetSeasonIdx,
                                 m_seriesSeasons.size() - 1);
        m_currentSeasonIndex = targetSeasonIdx;
        updateSeasonSwitcher(targetSeasonIdx);
      }

      if (m_hasCachedSeasonEpisodes &&
          cachedEpisodeSeasonIndex == targetSeasonIdx &&
          cachedEpisodeSeasonId ==
              (m_seriesSeasons.isEmpty()
                   ? QString()
                   : m_seriesSeasons[targetSeasonIdx].id) &&
          !m_seriesSeasons.isEmpty() &&
          episodesBelongToSeason(m_cachedSeasonEpisodes,
                                 m_seriesSeasons[targetSeasonIdx])) {
        m_currentSeasonEpisodes = m_cachedSeasonEpisodes;
        if (!m_appliedCachedSeasonEpisodesToUi && m_episodeWidget) {
          applyReservedSectionItems(m_episodeSectionReserveWidget,
                                    m_episodeWidget,
                                    m_currentSeasonEpisodes);
          updateEpisodeJumpControl(m_currentSeasonEpisodes.size());
          const QString highlightedEpisodeId = m_currentPlayableItem.id;
          if (!highlightedEpisodeId.isEmpty()) {
            m_episodeWidget->gallery()->setHighlightedItemId(
                highlightedEpisodeId);
            m_episodeWidget->gallery()->scrollToItemId(highlightedEpisodeId);
          }
        }
        m_appliedCachedSeasonEpisodesToUi = true;
      }

      if (m_seasonWidget) {
        m_seasonWidget->setTitle(tr("Seasons"));
        m_seasonWidget->setCardStyle(MediaCardDelegate::Poster);
        m_seasonWidget->setGalleryHeight(300);
        applyReservedSectionItems(m_seasonSectionReserveWidget, m_seasonWidget,
                                  m_seriesSeasons);
        m_appliedCachedSeriesSeasonsToUi = true;
      }
    }
  }

  
  if (m_hasCachedCastData && !m_appliedCachedCastToUi) {
    applyCastSection(m_currentMediaItem);
    m_appliedCachedCastToUi = true;
  }
  if (revealBottomInfo && m_deferBottomInfoReveal) {
    m_deferBottomInfoReveal = false;
    hideReserveWidget(m_bottomInfoReserveWidget);
    if (m_bottomInfoWidget)
      m_bottomInfoWidget->show();
  }

  
  
  
  if (m_hasCachedAdditionalParts && !m_appliedCachedAdditionalPartsToUi) {
    applyReservedSectionItems(m_additionalPartsSectionReserveWidget,
                              m_additionalPartsWidget,
                              m_cachedAdditionalParts);
    m_appliedCachedAdditionalPartsToUi = true;
  } else if (!m_hasCachedAdditionalParts &&
             (m_hasCachedCollections || m_hasCachedSimilarItems)) {
    applyReservedSectionItems(m_additionalPartsSectionReserveWidget,
                              m_additionalPartsWidget, {});
  }

  if (m_hasCachedCollections && !m_appliedCachedCollectionsToUi) {
    applyCollectionGalleryLayout(m_cachedCollections);
    applyReservedSectionItems(m_collectionSectionReserveWidget,
                              m_collectionWidget, m_cachedCollections);
    m_appliedCachedCollectionsToUi = true;
  } else if (!m_hasCachedCollections && m_hasCachedSimilarItems) {
    applyReservedSectionItems(m_collectionSectionReserveWidget,
                              m_collectionWidget, {});
  }

  if (m_hasCachedSimilarItems && !m_appliedCachedSimilarItemsToUi) {
    applyReservedSectionItems(m_similarSectionReserveWidget, m_similarWidget,
                              m_cachedSimilarItems);
    m_appliedCachedSimilarItemsToUi = true;
  }
}

void DetailView::persistDetailCacheSnapshot(const QString &reason) {
  if (m_detailCacheServerId.isEmpty() || m_detailCacheUserId.isEmpty() ||
      m_currentMediaItem.id.isEmpty())
    return;

  DetailCacheUtils::DetailCacheEntry entry;
  entry.item = m_currentMediaItem;
  const bool isSeries = m_currentMediaItem.type == "Series";
  entry.hasPlayableItem = isSeries && m_currentPlayableItem.type == "Episode" &&
                          !m_currentPlayableItem.id.isEmpty();
  if (entry.hasPlayableItem)
    entry.playableItem = m_currentPlayableItem;
  entry.hasSeasons = isSeries && m_hasCachedSeriesSeasons;
  entry.seasons = m_cachedSeriesSeasons;
  entry.hasSeasonEpisodes = isSeries && m_hasCachedSeasonEpisodes;
  entry.seasonEpisodes = m_cachedSeasonEpisodes;
  entry.seasonIndex = isSeries ? m_cachedSeasonIndex : -1;
  entry.seasonId = isSeries ? m_cachedSeasonId : QString();
  entry.playableItemFromServer = entry.hasPlayableItem;
  entry.hasSimilarItems = m_hasCachedSimilarItems;
  entry.similarItems = m_cachedSimilarItems;
  entry.hasCollections = m_hasCachedCollections;
  entry.collections = m_cachedCollections;
  entry.hasAdditionalParts = m_hasCachedAdditionalParts;
  entry.additionalParts = m_cachedAdditionalParts;

  saveDetailCacheEntryAsync(m_detailCacheServerId, m_detailCacheUserId, entry,
                            reason);
}

void DetailView::updateMetaRow(const MediaItem &item,
                               const QString &leadingMeta) {
  QStringList metas;
  if (item.communityRating > 0) {
    m_ratingStarLabel->show();
    metas << QString::number(item.communityRating, 'f', 1);
  } else {
    m_ratingStarLabel->hide();
  }
  if (!leadingMeta.isEmpty())
    metas << leadingMeta;
  const QString releaseDate = formatDetailReleaseDate(item);
  if (!releaseDate.isEmpty())
    metas << releaseDate;
  if (item.runTimeTicks > 0)
    metas << formatRunTime(item.runTimeTicks);
  if (!item.officialRating.isEmpty())
    metas << item.officialRating;

  m_metaLabel->setText(metas.join("  \u2022  "));
  m_metaRowWidget->show();
}






void DetailView::applySeedToUi(const MediaItem &seed) {
  m_currentMediaItem = seed;
  m_titleLabel->setText(seed.name);

  
  updateMetaRow(seed, formatEpisodeTag(seed));

  
  const bool shouldShowNumber = shouldShowDisplayNumber(seed);
  const QString displayNumber =
      shouldShowNumber ? extractDisplayNumber(seed) : QString();
  updateDisplayNumber(displayNumber);

  
  QString text = seed.overview;
  text.replace(QRegularExpression("<br\\s*/?>",
                                  QRegularExpression::CaseInsensitiveOption),
               "\n");
  text.replace("</p>", "\n\n");
  text.remove(QRegularExpression("<[^>]*>"));
  QTextDocument doc;
  doc.setHtml(text);
  QString cleanText = doc.toPlainText();
  cleanText.replace(QChar::LineSeparator, '\n');
  cleanText.remove(QRegularExpression("<[^>]*>"));
  m_cleanOverviewText = cleanText;
  m_lastOverviewWidth = -1;
  updateOverviewElidedText();

  
  if (!seed.taglines.isEmpty()) {
    m_taglineLabel->setText(seed.taglines.first());
    m_taglineLabel->show();
  } else {
    m_taglineLabel->hide();
  }

  
  m_isFavorite = seed.isFavorite();
  m_actionWidget->setFavoriteState(m_isFavorite);
  m_actionWidget->setPlayedState(seed.userData.played);

  
  
  
  
  if (seed.type == "Series") {
    m_actionWidget->setSeriesLoadingMode();
  } else {
    m_actionWidget->setupNormalMode(seed);
  }

  
  
  
  
  
  if (!seed.mediaSources.isEmpty()) {
    m_actionWidget->setSources(seed.mediaSources, 0);
    if (!seed.mediaSources.first().mediaStreams.isEmpty()) {
      m_actionWidget->setStreams(seed.mediaSources.first());
    }
    m_appliedSourcesFingerprint = computeSourcesFingerprint(seed.mediaSources);
  } else {
    m_actionWidget->setSources(QList<MediaSourceInfo>{}, 0);
    m_actionWidget->setStreams(MediaSourceInfo{});
    m_appliedSourcesFingerprint =
        computeSourcesFingerprint(QList<MediaSourceInfo>{});
  }
  m_actionWidget->refreshExtPlayerButton();

  
  
  
  buildTagButtons(seed.genres);

  
  
  
  
  
  
  QList<MediaSourceInfo> seedDefaultSource;
  if (!seed.mediaSources.isEmpty())
    seedDefaultSource.append(seed.mediaSources.first());
  m_bottomInfoWidget->setInfo(seed, seedDefaultSource);
  m_bottomInfoWidget->setVisible(!m_deferBottomInfoReveal);
  if (m_deferBottomInfoReveal) {
    showReserveWidget(m_bottomInfoReserveWidget,
                      reserveHeightFor(m_bottomInfoWidget, 220));
  } else {
    hideReserveWidget(m_bottomInfoReserveWidget);
  }
  m_appliedBottomInfoFingerprint =
      computeBottomInfoFingerprint(seed, seedDefaultSource);

  
  
  m_currentBackdropPix = QPixmap();
  updateBackdrop();

  
  
  
  
  
  QCoro::connect(executeLoadImages(QPointer<DetailView>(this), m_core, seed,
                                   false),
                 this, []() {});
}





void DetailView::buildTagButtons(const QStringList &genres) {
  if (!m_tagsWidget || !m_tagsLayout)
    return;

  
  if (m_tagsLayout->count() == genres.size()) {
    bool same = true;
    for (int i = 0; i < genres.size(); ++i) {
      QLayoutItem *layoutItem = m_tagsLayout->itemAt(i);
      QWidget *w = layoutItem ? layoutItem->widget() : nullptr;
      auto *btn = qobject_cast<QPushButton *>(w);
      if (!btn || btn->text() != genres[i]) {
        same = false;
        break;
      }
    }
    if (same)
      return;
  }

  m_tagsWidget->setUpdatesEnabled(false);
  clearLayout(m_tagsLayout);
  for (const QString &genre : genres) {
    auto *tagBtn = new DetailTagButton(genre, m_tagsWidget);
    connect(tagBtn, &QPushButton::clicked, this,
            [this, genre]() { Q_EMIT navigateToFilteredView("Genre", genre); });
    m_tagsLayout->addWidget(tagBtn);
  }
  m_tagsWidget->setUpdatesEnabled(true);
  updateTagLayoutHeight();
  QTimer::singleShot(0, this, [this]() { updateTagLayoutHeight(); });
}

void DetailView::applyCastSection(const MediaItem &item) {
  if (!m_castWidget)
    return;

  const QString fp = castFingerprint(item);
  if (!fp.isEmpty() && fp == m_appliedCastFingerprint)
    return;

  if (item.people.isEmpty()) {
    applyReservedSectionItems(m_castSectionReserveWidget, m_castWidget, {});
    m_appliedCastFingerprint = fp;
    return;
  }

  QList<MediaItem> castItems;
  castItems.reserve(item.people.size());
  for (const auto &person : item.people) {
    MediaItem fakeItem;
    fakeItem.id = person.id;
    fakeItem.name = person.name;
    fakeItem.images.primaryTag = person.primaryImageTag;
    
    QStringList personParts;
    if (!person.type.isEmpty()) {
      
      static const QHash<QString, const char *> typeMap = {
          {"Actor", QT_TR_NOOP("Actor")},
          {"Director", QT_TR_NOOP("Director")},
          {"Writer", QT_TR_NOOP("Writer")},
          {"Producer", QT_TR_NOOP("Producer")},
          {"Composer", QT_TR_NOOP("Composer")},
          {"Conductor", QT_TR_NOOP("Conductor")},
          {"GuestStar", QT_TR_NOOP("GuestStar")},
          {"Editor", QT_TR_NOOP("Editor")},
          {"Lyricist", QT_TR_NOOP("Lyricist")},
      };
      auto it = typeMap.constFind(person.type);
      personParts << (it != typeMap.constEnd() ? tr(it.value())
                                               : person.type);
    }
    if (!person.role.isEmpty())
      personParts << person.role;
    fakeItem.overview = personParts.join(" · ");
    fakeItem.type = "Person";
    castItems.append(fakeItem);
  }

  applyReservedSectionItems(m_castSectionReserveWidget, m_castWidget,
                            castItems);
  m_appliedCastFingerprint = fp;
}

void DetailView::applyCollectionGalleryLayout(
    const QList<MediaItem> &collections) {
  int landscapeSignals = 0;
  int portraitSignals = 0;

  const auto hasLandscapeArtwork = [](const MediaItem &item) {
    const double primaryAspectRatio = item.images.primaryImageAspectRatio;
    if (primaryAspectRatio > 1.05)
      return true;
    if (primaryAspectRatio > 0.0)
      return false;

    if (!item.images.primaryTag.isEmpty())
      return false;

    return !item.images.thumbTag.isEmpty() ||
           !item.images.backdropTag.isEmpty() ||
           !item.images.parentThumbTag.isEmpty() ||
           !item.images.parentBackdropTag.isEmpty();
  };

  for (const MediaItem &collection : collections) {
    if (hasLandscapeArtwork(collection)) {
      ++landscapeSignals;
    } else if (!collection.images.primaryTag.isEmpty() ||
               collection.images.primaryImageAspectRatio > 0.0) {
      ++portraitSignals;
    }
  }

  const bool useLandscapeCards =
      landscapeSignals > 0 && landscapeSignals > portraitSignals;

  if (useLandscapeCards) {
    m_collectionWidget->setCardStyle(MediaCardDelegate::LibraryTile);
    m_collectionWidget->setGalleryHeight(230);
  } else {
    m_collectionWidget->setCardStyle(MediaCardDelegate::Poster);
    m_collectionWidget->setGalleryHeight(300);
  }

  qDebug() << "[DetailView] Collection gallery layout"
           << "itemCount=" << collections.size()
           << "landscapeSignals=" << landscapeSignals
           << "portraitSignals=" << portraitSignals
           << "style="
           << (useLandscapeCards ? "LibraryTile" : "Poster");
}







QCoro::Task<void>
DetailView::executeFetchSecondaries(QPointer<DetailView> safeThis,
                                    QEmbyCore *core, QString targetId,
                                    QString itemType) {
  if (!safeThis)
    co_return;

  
  
  if (itemType == "Series") {
    if (!safeThis->m_hasManualSeriesSelection &&
        safeThis->m_hasCachedSeriesPlayableItem &&
        safeThis->m_cachedSeriesPlayableItem.type == "Episode" &&
        !safeThis->m_cachedSeriesPlayableItem.id.isEmpty()) {
      safeThis->applySeriesPlayableItemToUi(
          safeThis->m_cachedSeriesPlayableItem);
      qDebug() << "[DetailView][cache-ui] Applied cached series playable item"
               << "seriesId=" << targetId
               << "episodeId=" << safeThis->m_cachedSeriesPlayableItem.id;
    }
    qDebug() << "[DetailView][network] Fetch series next-up"
             << "seriesId=" << targetId
             << "applyToUi=" << !safeThis->m_hasManualSeriesSelection;
    co_await safeThis->fetchSeriesNextUp(
        targetId, !safeThis->m_hasManualSeriesSelection);
    if (!safeThis || safeThis->m_currentItemId != targetId)
      co_return;

    
    qDebug() << "[DetailView][network] Fetch series seasons"
             << "seriesId=" << targetId;
    auto seasons = co_await core->mediaService()->getSeasons(targetId);
    if (!safeThis || safeThis->m_currentItemId != targetId)
      co_return;

    bool seasonsUnchanged = false;
    if (safeThis->m_appliedCachedSeriesSeasonsToUi) {
      seasonsUnchanged = co_await mediaItemListsEqualAsync(
          safeThis->m_cachedSeriesSeasons, seasons);
      if (!safeThis || safeThis->m_currentItemId != targetId)
        co_return;
    }
    safeThis->m_seriesSeasons = seasons;
    safeThis->m_cachedSeriesSeasons = seasons;
    safeThis->m_hasCachedSeriesSeasons = true;

    
    
    int targetSeasonIdx = 0;
    bool selectedSeasonResolved = false;
    if (safeThis->m_hasManualSeriesSelection &&
        !safeThis->m_manualSelectedSeasonId.isEmpty()) {
      for (int i = 0; i < seasons.size(); ++i) {
        if (seasons[i].id == safeThis->m_manualSelectedSeasonId) {
          targetSeasonIdx = i;
          selectedSeasonResolved = true;
          break;
        }
      }
    }
    if (!selectedSeasonResolved &&
        safeThis->m_hasManualSeriesSelection &&
        safeThis->m_manualSelectedSeasonIndex >= 0 &&
        safeThis->m_manualSelectedSeasonIndex < seasons.size()) {
      targetSeasonIdx = safeThis->m_manualSelectedSeasonIndex;
      selectedSeasonResolved = true;
    }
    if (!selectedSeasonResolved &&
        safeThis->m_hasManualSeriesSelection &&
        safeThis->m_currentSeasonIndex >= 0 &&
        safeThis->m_currentSeasonIndex < seasons.size()) {
      targetSeasonIdx = safeThis->m_currentSeasonIndex;
      selectedSeasonResolved = true;
    }
    int playableParentIdx = safeThis->m_currentPlayableItem.parentIndexNumber;
    if (!selectedSeasonResolved &&
        !safeThis->m_hasManualSeriesSelection && playableParentIdx >= 0) {
      for (int i = 0; i < seasons.size(); ++i) {
        if (seasons[i].indexNumber == playableParentIdx) {
          targetSeasonIdx = i;
          break;
        }
      }
    }
    if (!seasons.isEmpty())
      targetSeasonIdx = qBound(0, targetSeasonIdx, seasons.size() - 1);
    safeThis->m_currentSeasonIndex = targetSeasonIdx;

    
    if (!seasons.isEmpty() && safeThis->m_episodeWidget) {
      safeThis->updateSeasonSwitcher(targetSeasonIdx);

      const QString playableItemId =
          safeThis->m_hasManualSeriesSelection &&
                  !safeThis->m_manualSelectedEpisodeId.isEmpty()
              ? safeThis->m_manualSelectedEpisodeId
              : safeThis->m_currentPlayableItem.id;
      co_await safeThis->loadEpisodesForSeason(
          targetSeasonIdx, playableItemId, !playableItemId.isEmpty(),
          safeThis->m_hasManualSeriesSelection);
    } else if (safeThis->m_episodeWidget) {
      applyReservedSectionItems(safeThis->m_episodeSectionReserveWidget,
                                safeThis->m_episodeWidget, {});
    }
    if (!safeThis || safeThis->m_currentItemId != targetId)
      co_return;

    
    if (safeThis->m_seasonWidget && !seasonsUnchanged) {
      safeThis->m_seasonWidget->setTitle(tr("Seasons"));
      safeThis->m_seasonWidget->setCardStyle(MediaCardDelegate::Poster);
      safeThis->m_seasonWidget->setGalleryHeight(300);
      applyReservedSectionItems(safeThis->m_seasonSectionReserveWidget,
                                safeThis->m_seasonWidget, seasons);
    }
  }

  
  if (safeThis->m_currentItemId != targetId)
    co_return;
  qDebug() << "[DetailView][ui] Apply cast section"
           << "itemId=" << targetId
           << "afterSeriesSections=" << (itemType == "Series");
  safeThis->applyCastSection(safeThis->m_currentMediaItem);
  if (safeThis->m_deferBottomInfoReveal) {
    safeThis->m_deferBottomInfoReveal = false;
    hideReserveWidget(safeThis->m_bottomInfoReserveWidget);
    if (safeThis->m_bottomInfoWidget)
      safeThis->m_bottomInfoWidget->show();
  }
  if (!safeThis)
    co_return;

  
  
  
  try {
    qDebug() << "[DetailView][network] Fetch similar items"
             << "itemId=" << targetId;
    QList<MediaItem> similar =
        co_await core->mediaService()->getSimilarItems(targetId, 15);
    if (!safeThis || safeThis->m_currentItemId != targetId)
      co_return;

    bool similarUnchanged = false;
    if (safeThis->m_appliedCachedSimilarItemsToUi) {
      similarUnchanged = co_await mediaItemListsEqualAsync(
          safeThis->m_cachedSimilarItems, similar);
      if (!safeThis || safeThis->m_currentItemId != targetId)
        co_return;
    }
    safeThis->m_cachedSimilarItems = similar;
    safeThis->m_hasCachedSimilarItems = true;
    if (!similarUnchanged) {
      applyReservedSectionItems(safeThis->m_similarSectionReserveWidget,
                                safeThis->m_similarWidget, similar);
    }
  } catch (...) {
    if (safeThis && safeThis->m_currentItemId == targetId &&
        !safeThis->m_appliedCachedSimilarItemsToUi) {
      applyReservedSectionItems(safeThis->m_similarSectionReserveWidget,
                                safeThis->m_similarWidget, {});
    }
  }
  if (!safeThis)
    co_return;

  
  
  try {
    qDebug() << "[DetailView][network] Fetch item collections"
             << "itemId=" << targetId;
    QList<MediaItem> collections =
        co_await core->mediaService()->getItemCollections(targetId);
    if (!safeThis || safeThis->m_currentItemId != targetId)
      co_return;

    bool collectionsUnchanged = false;
    if (safeThis->m_appliedCachedCollectionsToUi) {
      collectionsUnchanged = co_await mediaItemListsEqualAsync(
          safeThis->m_cachedCollections, collections);
      if (!safeThis || safeThis->m_currentItemId != targetId)
        co_return;
    }
    safeThis->m_cachedCollections = collections;
    safeThis->m_hasCachedCollections = true;
    if (!collectionsUnchanged) {
      safeThis->applyCollectionGalleryLayout(collections);
      applyReservedSectionItems(safeThis->m_collectionSectionReserveWidget,
                                safeThis->m_collectionWidget, collections);
    }
  } catch (...) {
    if (safeThis && safeThis->m_currentItemId == targetId &&
        !safeThis->m_appliedCachedCollectionsToUi) {
      applyReservedSectionItems(safeThis->m_collectionSectionReserveWidget,
                                safeThis->m_collectionWidget, {});
    }
  }
  if (!safeThis)
    co_return;

  
  try {
    qDebug() << "[DetailView][network] Fetch additional parts"
             << "itemId=" << targetId;
    QList<MediaItem> additionalParts =
        co_await core->mediaService()->getAdditionalParts(targetId);
    if (!safeThis || safeThis->m_currentItemId != targetId)
      co_return;

    bool additionalPartsUnchanged = false;
    if (safeThis->m_appliedCachedAdditionalPartsToUi) {
      additionalPartsUnchanged = co_await mediaItemListsEqualAsync(
          safeThis->m_cachedAdditionalParts, additionalParts);
      if (!safeThis || safeThis->m_currentItemId != targetId)
        co_return;
    }
    safeThis->m_cachedAdditionalParts = additionalParts;
    safeThis->m_hasCachedAdditionalParts = true;
    if (!additionalPartsUnchanged) {
      applyReservedSectionItems(safeThis->m_additionalPartsSectionReserveWidget,
                                safeThis->m_additionalPartsWidget,
                                additionalParts);
    }
  } catch (...) {
    if (safeThis && safeThis->m_currentItemId == targetId &&
        !safeThis->m_appliedCachedAdditionalPartsToUi) {
      applyReservedSectionItems(
          safeThis->m_additionalPartsSectionReserveWidget,
          safeThis->m_additionalPartsWidget, {});
    }
  }

  if (safeThis && safeThis->m_currentItemId == targetId)
    safeThis->persistDetailCacheSnapshot(QStringLiteral("secondaries"));
}

QCoro::Task<void> DetailView::fetchSeriesNextUp(const QString &targetId,
                                                bool applyToUi) {
  QPointer<DetailView> safeThis(this);
  try {
    MediaItem playableItem;
    qDebug() << "[DetailView][network] Fetch next-up"
             << "seriesId=" << targetId;
    auto nextUp = co_await m_core->mediaService()->getNextUp(targetId);

    if (!nextUp.isEmpty())
      playableItem = nextUp.first();
    else {
      qDebug() << "[DetailView][network] Fetch seasons for next-up fallback"
               << "seriesId=" << targetId;
      auto seasons = co_await m_core->mediaService()->getSeasons(targetId);
      if (!seasons.isEmpty()) {
        qDebug() << "[DetailView][network] Fetch episodes for next-up fallback"
                 << "seriesId=" << targetId
                 << "seasonId=" << seasons.first().id;
        auto episodes = co_await m_core->mediaService()->getEpisodes(
            targetId, seasons.first().id);
        if (!episodes.isEmpty())
          playableItem = episodes.first();
      }
    }

    if (safeThis && safeThis->m_currentItemId == targetId &&
        !playableItem.id.isEmpty()) {
      safeThis->m_cachedSeriesPlayableItem = playableItem;
      safeThis->m_hasCachedSeriesPlayableItem = true;

      if (!applyToUi || safeThis->m_hasManualSeriesSelection) {
        qDebug() << "[DetailView][network] Updated server next-up cache without "
                    "changing manual selection"
                 << "seriesId=" << targetId
                 << "episodeId=" << playableItem.id
                 << "applyToUi=" << applyToUi
                 << "manualSelection="
                 << safeThis->m_hasManualSeriesSelection;
        safeThis->persistDetailCacheSnapshot(
            QStringLiteral("series-server-next-up"));
        co_return;
      }

      co_await safeThis->applySeriesPlayableItem(playableItem);
    }
  } catch (...) {
  }
}

void DetailView::applySeriesPlayableItemToUi(const MediaItem &playableItem,
                                             bool scrollToEpisode) {
  if (playableItem.id.isEmpty() || m_currentMediaItem.type != "Series")
    return;

  const QString playableFingerprint =
      DetailCacheUtils::fingerprint(playableItem);
  const bool playableUnchanged =
      !m_appliedSeriesPlayableFingerprint.isEmpty() &&
      playableFingerprint == m_appliedSeriesPlayableFingerprint;
  m_currentPlayableItem = playableItem;
  const QString episodeTag = formatEpisodeTag(playableItem);

  if (!playableUnchanged) {
    const QString actionTag =
        episodeTag.isEmpty() ? playableItem.name : episodeTag;
    m_actionWidget->setupSeriesMode(playableItem, actionTag);
    updateMetaRow(m_currentMediaItem, episodeTag);

    m_actionWidget->setSources(playableItem.mediaSources, 0);
    m_appliedSourcesFingerprint =
        computeSourcesFingerprint(playableItem.mediaSources);

    QList<MediaSourceInfo> selectedSources;
    if (!playableItem.mediaSources.isEmpty()) {
      int sourceIndex = m_actionWidget->currentSourceIndex();
      if (sourceIndex >= playableItem.mediaSources.size())
        sourceIndex = 0;

      const MediaSourceInfo &selectedSource =
          playableItem.mediaSources[sourceIndex];
      m_actionWidget->setStreams(selectedSource);
      selectedSources.append(selectedSource);
    } else {
      m_actionWidget->setStreams(MediaSourceInfo{});
    }

    if (!selectedSources.isEmpty()) {
      const QString bottomInfoFingerprint =
          computeBottomInfoFingerprint(playableItem, selectedSources);
      if (bottomInfoFingerprint != m_appliedBottomInfoFingerprint) {
        m_bottomInfoWidget->setInfo(playableItem, selectedSources);
        m_appliedBottomInfoFingerprint = bottomInfoFingerprint;
        m_bottomInfoWidget->setVisible(!m_deferBottomInfoReveal);
        if (m_deferBottomInfoReveal) {
          showReserveWidget(m_bottomInfoReserveWidget,
                            reserveHeightFor(m_bottomInfoWidget, 220));
        } else {
          hideReserveWidget(m_bottomInfoReserveWidget);
        }
      } else {
        m_bottomInfoWidget->setVisible(!m_deferBottomInfoReveal);
      }
    }

    m_appliedSeriesPlayableFingerprint = playableFingerprint;
  }

  m_actionWidget->refreshExtPlayerButton();
  m_actionWidget->setPlayedState(playableItem.userData.played);
  if (m_episodeWidget) {
    m_episodeWidget->gallery()->setHighlightedItemId(playableItem.id);
    if (scrollToEpisode)
      m_episodeWidget->gallery()->scrollToItemId(playableItem.id);
  }

  qDebug() << "[DetailView] Apply series playable item"
           << "seriesId=" << m_currentItemId << "episodeId=" << playableItem.id
           << "episodeTag=" << episodeTag
           << "sourceCount=" << playableItem.mediaSources.size();
}

QCoro::Task<void> DetailView::applySeriesPlayableItem(MediaItem playableItem,
                                                      bool scrollToEpisode) {
  if (playableItem.id.isEmpty() || m_currentMediaItem.type != "Series")
    co_return;

  QPointer<DetailView> safeThis(this);
  const QString seriesId = m_currentItemId;
  const QString playableItemId = playableItem.id;

  applySeriesPlayableItemToUi(playableItem, scrollToEpisode);
  rememberSeriesSelection(playableItem, QStringLiteral("series-selection"),
                          true);

  const bool needsPlaybackInfo =
      playableItem.mediaSources.isEmpty() ||
      playableItem.mediaSources.first().mediaStreams.isEmpty();
  if (!needsPlaybackInfo)
    co_return;

  try {
    PlaybackInfo info =
        co_await m_core->mediaService()->getPlaybackInfo(playableItemId);
    if (!safeThis || safeThis->m_currentItemId != seriesId ||
        safeThis->m_currentMediaItem.type != "Series" ||
        safeThis->m_currentPlayableItem.id != playableItemId)
      co_return;
    if (!info.mediaSources.isEmpty()) {
      playableItem.mediaSources = info.mediaSources;
      safeThis->applySeriesPlayableItemToUi(playableItem, false);
      safeThis->rememberSeriesSelection(
          playableItem, QStringLiteral("series-selection-playback-info"),
          true);
    }
  } catch (...) {
  }
}

QCoro::Task<void> DetailView::onVersionChanged(int index) {
  const bool usePlayableItem =
      m_currentMediaItem.type == "Series" && !m_currentPlayableItem.id.isEmpty();
  MediaItem actionItem = usePlayableItem ? m_currentPlayableItem
                                         : m_currentMediaItem;
  if (index < 0 || index >= actionItem.mediaSources.size())
    co_return;
  MediaSourceInfo source = actionItem.mediaSources[index];
  QPointer<DetailView> safeThis(this);
  const QString expectedPageId = m_currentItemId;
  const QString actionItemId = actionItem.id;

  if (source.mediaStreams.isEmpty()) {
    try {
      PlaybackInfo info =
          co_await m_core->mediaService()->getPlaybackInfo(actionItemId);
      if (!safeThis || safeThis->m_currentItemId != expectedPageId)
        co_return;
      if (!info.mediaSources.isEmpty()) {
        if (usePlayableItem) {
          if (safeThis->m_currentPlayableItem.id != actionItemId)
            co_return;
          safeThis->m_currentPlayableItem.mediaSources = info.mediaSources;
          actionItem = safeThis->m_currentPlayableItem;
        } else {
          safeThis->m_currentMediaItem.mediaSources = info.mediaSources;

          
          
          safeThis->m_currentPlayableItem.mediaSources = info.mediaSources;
          actionItem = safeThis->m_currentMediaItem;
        }

        int selectedIndex = index;
        if (selectedIndex >= actionItem.mediaSources.size())
          selectedIndex = 0;
        if (selectedIndex < actionItem.mediaSources.size()) {
          source = actionItem.mediaSources[selectedIndex];
        }
      }
    } catch (...) {
      co_return;
    }
  }
  if (!safeThis || source.mediaStreams.isEmpty())
    co_return;

  safeThis->m_actionWidget->setStreams(source);
  QList<MediaSourceInfo> singleSource;
  singleSource.append(source);
  const MediaItem infoItem =
      usePlayableItem ? safeThis->m_currentPlayableItem
                      : safeThis->m_currentMediaItem;
  safeThis->m_bottomInfoWidget->setInfo(infoItem, singleSource);
  hideReserveWidget(safeThis->m_bottomInfoReserveWidget);
}

QCoro::Task<void> DetailView::executePlay(MediaItem targetItem,
                                          long long startTicks) {
  if (targetItem.id.isEmpty())
    co_return;
  try {
    MediaItem actualItem = targetItem;
    if (actualItem.mediaSources.isEmpty()) {
      PlaybackInfo info =
          co_await m_core->mediaService()->getPlaybackInfo(actualItem.id);
      actualItem.mediaSources = info.mediaSources;
    }
    if (actualItem.mediaSources.isEmpty())
      co_return;

    int sourceIdx = 0;
    int selectedAudioIdx = -1;
    int selectedSubIdx = -1;
    const bool useUiSelection = isCurrentActionItem(actualItem.id);

    if (useUiSelection) {
      
      sourceIdx = m_actionWidget->currentSourceIndex();
      selectedAudioIdx = m_actionWidget->currentAudioIndex();
      selectedSubIdx = m_actionWidget->currentSubtitleIndex();
    } else {
      sourceIdx = MediaSourcePreferenceUtils::resolvePreferredMediaSourceIndex(
          actualItem.mediaSources,
          ConfigStore::instance()
              ->get<QString>(ConfigKeys::PlayerPreferredVersion)
              .trimmed());
    }

    if (sourceIdx >= actualItem.mediaSources.size())
      sourceIdx = 0;
    MediaSourceInfo modifiedSource = actualItem.mediaSources[sourceIdx];

    if (useUiSelection) {
      
      
      
      for (auto &stream : modifiedSource.mediaStreams) {
        if (stream.type == "Audio" && selectedAudioIdx >= 0)
          stream.isDefault = (stream.index == selectedAudioIdx);
        else if (stream.type == "Subtitle" && selectedSubIdx >= 0)
          stream.isDefault = (stream.index == selectedSubIdx);
      }
    } else {
      PlayerPreferenceUtils::applyPreferredStreamRules(
          modifiedSource,
          ConfigStore::instance()->get<QString>(ConfigKeys::PlayerAudioLang,
                                                "auto"),
          ConfigStore::instance()->get<QString>(ConfigKeys::PlayerSubLang,
                                                "auto"));
    }

    QString streamUrl =
        m_core->mediaService()->getStreamUrl(actualItem.id, modifiedSource.id);

    const QString playTitle =
        MediaItemUtils::playbackTitle(actualItem, m_currentMediaItem.name);

    
    PlaybackManager::instance()->startInternalPlayback(
        actualItem.id, playTitle, streamUrl, startTicks,
        QVariant::fromValue(modifiedSource));
  } catch (...) {
  }
}

QCoro::Task<void> DetailView::executePlaySeason(MediaItem seasonItem) {
  if (seasonItem.id.isEmpty() || m_currentItemId.isEmpty() || !m_core ||
      !m_core->mediaService())
    co_return;

  QPointer<DetailView> safeThis(this);
  const QString seriesId = m_currentItemId;
  const QString seasonId = seasonItem.id;

  try {
    QList<MediaItem> episodes =
        co_await m_core->mediaService()->getEpisodes(seriesId, seasonId);
    if (!safeThis || safeThis->m_currentItemId != seriesId)
      co_return;

    MediaItem targetEpisode = resolveSeasonPlaybackEpisode(episodes);
    if (targetEpisode.id.isEmpty())
      co_return;

    qDebug() << "[DetailView] Play season"
             << "seriesId=" << seriesId << "seasonId=" << seasonId
             << "episodeId=" << targetEpisode.id
             << "episodeTag=" << formatEpisodeTag(targetEpisode)
             << "episodeCount=" << episodes.size()
             << "startTicks="
             << targetEpisode.userData.playbackPositionTicks;

    co_await safeThis->applySeriesPlayableItem(targetEpisode, false);
    if (!safeThis || safeThis->m_currentItemId != seriesId)
      co_return;

    const MediaItem playbackItem =
        safeThis->m_currentPlayableItem.id == targetEpisode.id
            ? safeThis->m_currentPlayableItem
            : targetEpisode;
    co_await safeThis->executePlay(
        playbackItem, playbackItem.userData.playbackPositionTicks);
  } catch (...) {
  }
}

QCoro::Task<void> DetailView::executeExternalPlay(MediaItem targetItem,
                                                  QString playerPath) {
  if (targetItem.id.isEmpty() || playerPath.isEmpty())
    co_return;
  try {
    MediaItem actualItem = targetItem;
    if (actualItem.mediaSources.isEmpty()) {
      PlaybackInfo info =
          co_await m_core->mediaService()->getPlaybackInfo(actualItem.id);
      actualItem.mediaSources = info.mediaSources;
    }
    if (actualItem.mediaSources.isEmpty())
      co_return;

    
    int sourceIdx = 0;
    const bool useUiSelection = isCurrentActionItem(actualItem.id);
    if (useUiSelection) {
      sourceIdx = m_actionWidget->currentSourceIndex();
    }
    if (sourceIdx >= actualItem.mediaSources.size())
      sourceIdx = 0;
    MediaSourceInfo modifiedSource = actualItem.mediaSources[sourceIdx];

    if (useUiSelection) {
      int selectedAudioIdx = m_actionWidget->currentAudioIndex();
      int selectedSubIdx = m_actionWidget->currentSubtitleIndex();
      for (auto &stream : modifiedSource.mediaStreams) {
        if (stream.type == "Audio" && selectedAudioIdx >= 0)
          stream.isDefault = (stream.index == selectedAudioIdx);
        else if (stream.type == "Subtitle" && selectedSubIdx >= 0)
          stream.isDefault = (stream.index == selectedSubIdx);
      }
    } else {
      PlayerPreferenceUtils::applyPreferredStreamRules(
          modifiedSource,
          ConfigStore::instance()->get<QString>(ConfigKeys::PlayerAudioLang,
                                                "auto"),
          ConfigStore::instance()->get<QString>(ConfigKeys::PlayerSubLang,
                                                "auto"));
    }

    QString streamUrl =
        m_core->mediaService()->getStreamUrl(actualItem.id, modifiedSource.id);

    const QString playTitle =
        MediaItemUtils::playbackTitle(actualItem, m_currentMediaItem.name);

    long long startTicks = actualItem.userData.playbackPositionTicks;
    PlaybackManager::instance()->startExternalPlayback(
        playerPath, actualItem.id, playTitle, streamUrl, startTicks,
        QVariant::fromValue(modifiedSource));
  } catch (...) {
  }
}

void DetailView::updateBackdrop() {
  if (m_contentWidget)
    static_cast<DetailContentWidget *>(m_contentWidget)
        ->setBackdrop(m_currentBackdropPix);
}

void DetailView::updateTagLayoutHeight() {
  if (!m_tagsWidget || !m_tagsLayout)
    return;

  int targetWidth = m_tagsWidget->width();
  if (targetWidth <= 0 && m_textContainer) {
    targetWidth = m_textContainer->contentsRect().width();
  }

  if (targetWidth <= 0) {
    m_tagsWidget->updateGeometry();
    QTimer::singleShot(50, this, [this]() { updateTagLayoutHeight(); });
    return;
  }

  m_tagsLayout->invalidate();
  const int targetHeight = m_tagsLayout->heightForWidth(targetWidth);
  if (m_tagsWidget->minimumHeight() != targetHeight) {
    m_tagsWidget->setMinimumHeight(targetHeight);
  }
  m_tagsWidget->updateGeometry();

  if (m_textContainer) {
    m_textContainer->updateGeometry();
  }
}

void DetailView::resizeEvent(QResizeEvent *event) {
  QWidget::resizeEvent(event);
  if (m_overviewLabel && m_overviewLabel->width() > 10 &&
      qAbs(m_overviewLabel->width() - m_lastOverviewWidth) > 5) {
    m_lastOverviewWidth = m_overviewLabel->width();
    updateOverviewElidedText();
  }
  updateTagLayoutHeight();
  updateEpisodeJumpControl(m_currentSeasonEpisodes.size());
}

bool DetailView::eventFilter(QObject *obj, QEvent *event) {
  if (m_mainScrollArea && obj == m_mainScrollArea->viewport() &&
      event->type() == QEvent::Resize) {
    QResizeEvent *re = static_cast<QResizeEvent *>(event);
    int newWidth = re->size().width();
    if (m_contentWidget && newWidth > 100 &&
        m_contentWidget->maximumWidth() != newWidth) {
      m_contentWidget->setMaximumWidth(newWidth);
      QTimer::singleShot(0, this, [this]() {
        updateTagLayoutHeight();
        updateEpisodeJumpControl(m_currentSeasonEpisodes.size());
      });
    }
  }
  if (m_episodeWidget && m_episodeWidget->gallery() &&
      obj == m_episodeWidget->gallery()->listView()->viewport() &&
      event->type() == QEvent::Resize) {
    QTimer::singleShot(0, this, [this]() {
      updateEpisodeJumpControl(m_currentSeasonEpisodes.size());
    });
  }
  if (event->type() == QEvent::Wheel) {
    bool isHorizontalViewport =
        obj->parent() &&
        obj->parent()->property("isHorizontalListView").toBool();
    bool isMainViewport =
        (m_mainScrollArea && obj == m_mainScrollArea->viewport());
    if (isHorizontalViewport || isMainViewport) {
      QWheelEvent *we = static_cast<QWheelEvent *>(event);
      if (m_vScrollController) {
        m_vScrollController->scrollByWheelEvent(we, Qt::Vertical);
      }
      return true;
    }
  }
  return QWidget::eventFilter(obj, event);
}

void DetailView::showEvent(QShowEvent *event) {
  BaseView::showEvent(event);

  
  
  if (m_skipNextSilentRefresh) {
    m_skipNextSilentRefresh = false;
    return;
  }

  
  
  
  m_pendingDeferredFetchId.clear();

  if (!m_currentItemId.isEmpty() && m_core && m_core->mediaService()) {
    executeSilentRefresh(QPointer<DetailView>(this), m_core, m_currentItemId);
  }
}

void DetailView::clearLayout(QLayout *layout) {
  if (!layout)
    return;
  QLayoutItem *child;
  while ((child = layout->takeAt(0)) != nullptr) {
    if (child->widget()) {
      child->widget()->hide();
      child->widget()->setParent(nullptr);
      child->widget()->deleteLater();
    } else if (child->layout()) {
      clearLayout(child->layout());
    }
    delete child;
  }
}

QString DetailView::formatRunTime(long long ticks) {
  long long totalSeconds = ticks / 10000000;
  long long hours = totalSeconds / 3600;
  long long minutes = (totalSeconds % 3600) / 60;
  if (hours > 0)
    return QString(tr("%1 hr %2 min")).arg(hours).arg(minutes);
  return QString(tr("%1 min")).arg(minutes);
}

bool DetailView::shouldShowDisplayNumber(const MediaItem &item) const {
  if (item.type.compare("Movie", Qt::CaseInsensitive) != 0) {
    return false;
  }

  static const QList<QRegularExpression> adultMarkers = {
      QRegularExpression(R"((^|[^0-9])18\+?([^0-9]|$))",
                         QRegularExpression::CaseInsensitiveOption),
      QRegularExpression(R"(\b(?:R[-\s]?18\+?|NC[-\s]?17|JAV|AV)\b)",
                         QRegularExpression::CaseInsensitiveOption),
      QRegularExpression(QStringLiteral("(成人|无码|有码|無碼|有碼)"))};

  const auto containsAdultMarker = [](const QString &value) -> bool {
    const QString trimmedValue = value.trimmed();
    if (trimmedValue.isEmpty()) {
      return false;
    }

    for (const QRegularExpression &pattern : adultMarkers) {
      if (pattern.match(trimmedValue).hasMatch()) {
        return true;
      }
    }

    return false;
  };

  if (containsAdultMarker(item.officialRating)) {
    return true;
  }

  for (const QString &genre : item.genres) {
    if (containsAdultMarker(genre)) {
      return true;
    }
  }

  for (const QString &tag : item.tags) {
    if (containsAdultMarker(tag)) {
      return true;
    }
  }

  return false;
}

bool DetailView::isCurrentActionItem(const QString &itemId) const {
  if (itemId.isEmpty())
    return false;
  if (itemId == m_currentMediaItem.id)
    return true;
  return m_currentMediaItem.type == "Series" &&
         itemId == m_currentPlayableItem.id;
}

QStringList DetailView::buildNumberCandidates(const MediaItem &item) const {
  QStringList candidates;
  const auto appendCandidate = [&candidates](const QString &value) {
    const QString trimmedValue = value.trimmed();
    if (!trimmedValue.isEmpty() && !candidates.contains(trimmedValue)) {
      candidates.append(trimmedValue);
    }
  };

  for (const MediaSourceInfo &source : item.mediaSources) {
    appendCandidate(source.path);
  }

  appendCandidate(item.path);
  appendCandidate(item.name);
  appendCandidate(item.originalTitle);
  appendCandidate(item.sortName);

  for (const QString &tagline : item.taglines) {
    appendCandidate(tagline);
  }

  for (const QString &tag : item.tags) {
    appendCandidate(tag);
  }

  return candidates;
}

QString DetailView::extractDisplayNumber(const MediaItem &item) const {
  static const NumberExtractor extractor(true);
  const QStringList candidates = buildNumberCandidates(item);
  const QString displayNumber = extractor.extractBestNumber(candidates);

  qDebug() << "[DetailView] adult number extraction itemId=" << item.id
           << "officialRating=" << item.officialRating
           << "candidateCount=" << candidates.size()
           << "selected=" << displayNumber;

  return displayNumber;
}

void DetailView::updateDisplayNumber(const QString &number) {
  if (!m_numberButton || !m_metaRowWidget) {
    return;
  }

  const QString trimmedNumber = number.trimmed();
  const bool hasNumber = !trimmedNumber.isEmpty();
  m_numberButton->setVisible(hasNumber);
  m_numberButton->setText(trimmedNumber);
  m_numberButton->setToolTip(hasNumber ? tr("Click to copy number")
                                       : QString());
  m_metaRowWidget->setVisible(!m_metaLabel->text().isEmpty() || hasNumber);
}

void DetailView::copyDisplayedNumber() {
  if (!m_numberButton) {
    return;
  }

  const QString displayNumber = m_numberButton->text().trimmed();
  if (displayNumber.isEmpty()) {
    return;
  }

  if (QClipboard *clipboard = QGuiApplication::clipboard()) {
    clipboard->setText(displayNumber);
  }

  qDebug() << "[DetailView] copied display number" << displayNumber
           << "for itemId" << m_currentItemId;
  ModernToast::showMessage(tr("Number copied: %1").arg(displayNumber), 2000);
}

void DetailView::markManualSeriesSelection(const QString &reason) {
  if (m_currentMediaItem.type != "Series")
    return;

  if (!m_hasManualSeriesSelection) {
    qDebug() << "[DetailView] Manual series selection locked server auto-sync"
             << "seriesId=" << m_currentItemId << "reason=" << reason;
  }
  m_hasManualSeriesSelection = true;
}

void DetailView::rememberSeriesSelection(const MediaItem &episode,
                                         const QString &reason,
                                         bool persist) {
  if (m_currentMediaItem.type != "Series")
    return;

  int selectedSeasonIndex = -1;
  QString selectedSeasonId;
  bool hasSelectedSeason = false;
  if (episode.type == "Episode" && episode.parentIndexNumber >= 0) {
    for (int i = 0; i < m_seriesSeasons.size(); ++i) {
      if (m_seriesSeasons[i].indexNumber == episode.parentIndexNumber) {
        selectedSeasonIndex = i;
        selectedSeasonId = m_seriesSeasons[i].id;
        hasSelectedSeason = true;
        break;
      }
    }
  } else {
    selectedSeasonIndex = m_currentSeasonIndex;
    if (selectedSeasonIndex >= 0 &&
        selectedSeasonIndex < m_seriesSeasons.size()) {
      selectedSeasonId = m_seriesSeasons[selectedSeasonIndex].id;
      hasSelectedSeason = true;
    }
  }

  if (hasSelectedSeason) {
    if (persist) {
      m_cachedSeasonIndex = selectedSeasonIndex;
      m_cachedSeasonId = selectedSeasonId;
    } else {
      m_manualSelectedSeasonIndex = selectedSeasonIndex;
      m_manualSelectedSeasonId = selectedSeasonId;
    }
  }
  if (episode.type == "Episode" && !episode.id.isEmpty()) {
    if (persist) {
      m_cachedSeriesPlayableItem = episode;
      m_hasCachedSeriesPlayableItem = true;
    } else {
      m_manualSelectedEpisodeId = episode.id;
    }
  }

  qDebug() << "[DetailView] Remember series selection"
           << "seriesId=" << m_currentItemId
           << "seasonIndex="
           << (persist ? m_cachedSeasonIndex : m_manualSelectedSeasonIndex)
           << "seasonId="
           << (persist ? m_cachedSeasonId : m_manualSelectedSeasonId)
           << "episodeId="
           << (persist ? m_cachedSeriesPlayableItem.id
                       : m_manualSelectedEpisodeId)
           << "persist=" << persist << "reason=" << reason;

  if (persist)
    persistDetailCacheSnapshot(reason);
}

void DetailView::updateOverviewElidedText() {
  if (m_cleanOverviewText.isEmpty() || !m_overviewLabel)
    return;

  const int generation = ++m_overviewElideGeneration;
  QPointer<DetailView> safeThis(this);
  QTimer::singleShot(0, this, [safeThis, generation]() {
    if (!safeThis || generation != safeThis->m_overviewElideGeneration)
      return;

    int labelWidth = safeThis->m_overviewLabel->contentsRect().width();
    if (labelWidth <= 10 && safeThis->m_textContainer)
      labelWidth = safeThis->m_textContainer->contentsRect().width();
    if (labelWidth <= 10)
      return;

    QFontMetrics fm(safeThis->m_overviewLabel->font());
    int maxHeight = fm.lineSpacing() * 5 + 10;
    QTextDocument doc;
    doc.setDefaultFont(safeThis->m_overviewLabel->font());
    doc.setTextWidth(labelWidth);

    QString fullHtml = safeThis->m_cleanOverviewText.toHtmlEscaped();
    fullHtml.replace("\n", "<br>");
    doc.setHtml(fullHtml);

    if (doc.size().height() <= maxHeight) {
      if (safeThis->m_overviewLabel->text() != fullHtml)
        safeThis->m_overviewLabel->setText(fullHtml);
      return;
    }

    int low = 0, high = safeThis->m_cleanOverviewText.length(), best = 0;
    QString moreLink =
        safeThis->tr("... <a href='more' style='color:#3B82F6; "
                     "text-decoration:none; font-weight:bold;'>More</a>");
    while (low <= high) {
      int mid = low + (high - low) / 2;
      QString testHtml =
          safeThis->m_cleanOverviewText.left(mid).toHtmlEscaped();
      testHtml.replace("\n", "<br>");
      doc.setHtml(testHtml + moreLink);
      if (doc.size().height() <= maxHeight) {
        best = mid;
        low = mid + 1;
      } else {
        high = mid - 1;
      }
    }

    QString finalHtml =
        safeThis->m_cleanOverviewText.left(best).toHtmlEscaped();
    finalHtml.replace("\n", "<br>");
    const QString overviewHtml = finalHtml + moreLink;
    if (safeThis->m_overviewLabel->text() != overviewHtml)
      safeThis->m_overviewLabel->setText(overviewHtml);
  });
}

QCoro::Task<void> DetailView::updateUi(MediaItem item, bool isSilentRefresh) {
  m_currentMediaItem = item;
  if (!isSilentRefresh && item.type == "Series")
    m_deferBottomInfoReveal = true;
  m_titleLabel->setText(item.name);

  const QString metaEpisodeTag =
      item.type == "Series" && m_currentPlayableItem.type == "Episode"
          ? formatEpisodeTag(m_currentPlayableItem)
          : formatEpisodeTag(item);
  updateMetaRow(item, metaEpisodeTag);

  const bool shouldShowNumber = shouldShowDisplayNumber(item);
  const QString displayNumber =
      shouldShowNumber ? extractDisplayNumber(item) : QString();
  updateDisplayNumber(displayNumber);

  qDebug() << "[DetailView] updateUi itemId=" << item.id
           << "adultMovie=" << shouldShowNumber
           << "displayNumber=" << displayNumber;

  QString text = item.overview;
  text.replace(QRegularExpression("<br\\s*/?>",
                                  QRegularExpression::CaseInsensitiveOption),
               "\n");
  text.replace("</p>", "\n\n");
  text.remove(QRegularExpression("<[^>]*>"));
  QTextDocument doc;
  doc.setHtml(text);
  QString cleanText = doc.toPlainText();
  cleanText.replace(QChar::LineSeparator, '\n');
  cleanText.remove(QRegularExpression("<[^>]*>"));
  m_cleanOverviewText = cleanText;
  m_lastOverviewWidth = -1;
  updateOverviewElidedText();

  if (item.type == "Series") {
    const bool hasCurrentEpisode =
        m_currentPlayableItem.type == "Episode" &&
        !m_currentPlayableItem.id.isEmpty();
    if (!isSilentRefresh && !hasCurrentEpisode)
      m_actionWidget->setSeriesLoadingMode();
  } else {
    
    
    m_currentPlayableItem = item;
    m_actionWidget->setupNormalMode(item);
  }

  
  
  const QString newSourcesFingerprint =
      computeSourcesFingerprint(item.mediaSources);
  const bool sourcesUnchanged =
      !m_appliedSourcesFingerprint.isEmpty() &&
      newSourcesFingerprint == m_appliedSourcesFingerprint;
  const bool sourcesOwnedBySeriesEpisode =
      item.type == "Series" && m_currentPlayableItem.type == "Episode" &&
      !m_currentPlayableItem.id.isEmpty();
  if (!sourcesOwnedBySeriesEpisode && !sourcesUnchanged) {
    m_actionWidget->setSources(item.mediaSources, 0);
    m_appliedSourcesFingerprint = newSourcesFingerprint;
    if (item.mediaSources.isEmpty() ||
        item.mediaSources.first().mediaStreams.isEmpty()) {
      m_actionWidget->setStreams(MediaSourceInfo{});
    }
  }
  m_actionWidget->refreshExtPlayerButton();

  if (!item.taglines.isEmpty()) {
    m_taglineLabel->setText(item.taglines.first());
    m_taglineLabel->show();
  } else {
    m_taglineLabel->hide();
  }

  m_isFavorite = item.isFavorite();
  m_actionWidget->setFavoriteState(m_isFavorite);
  m_actionWidget->setPlayedState(item.userData.played);

  
  
  buildTagButtons(item.genres);

  QCoro::connect(executeLoadImages(QPointer<DetailView>(this), m_core, item,
                                   true),
                 this, []() {});

  QPointer<DetailView> safeThis(this);

  
  
  auto applyBottomInfo = [this, &item](const QList<MediaSourceInfo> &srcs) {
    const QString fp = computeBottomInfoFingerprint(item, srcs);
    if (fp == m_appliedBottomInfoFingerprint)
      return;
    m_bottomInfoWidget->setInfo(item, srcs);
    m_appliedBottomInfoFingerprint = fp;
    if (m_deferBottomInfoReveal) {
      showReserveWidget(m_bottomInfoReserveWidget,
                        reserveHeightFor(m_bottomInfoWidget, 220));
    }
  };

  if (sourcesOwnedBySeriesEpisode) {
    applySeriesPlayableItemToUi(m_currentPlayableItem);
  } else if (!item.mediaSources.isEmpty() &&
             !item.mediaSources.first().mediaStreams.isEmpty()) {
    int defaultIndex = m_actionWidget->currentSourceIndex();
    QList<MediaSourceInfo> defaultSource;
    if (defaultIndex < item.mediaSources.size()) {
      const MediaSourceInfo &dSrc = item.mediaSources[defaultIndex];
      
      
      if (!sourcesUnchanged)
        m_actionWidget->setStreams(dSrc);
      defaultSource.append(dSrc);
    }
    applyBottomInfo(defaultSource);
  } else {
    
    
    applyBottomInfo({});
    if (item.mediaType == "Video" || item.mediaType == "Audio" ||
        item.type == "Movie" || item.type == "Episode") {
      try {
        PlaybackInfo info =
            co_await m_core->mediaService()->getPlaybackInfo(item.id);
        if (!safeThis)
          co_return;
        if (item.id == safeThis->m_currentItemId &&
            !info.mediaSources.isEmpty()) {
          safeThis->m_currentMediaItem.mediaSources = info.mediaSources;

          const QString refreshedNumber =
              safeThis->shouldShowDisplayNumber(safeThis->m_currentMediaItem)
                  ? safeThis->extractDisplayNumber(safeThis->m_currentMediaItem)
                  : QString();
          safeThis->updateDisplayNumber(refreshedNumber);

          
          
          if (item.type != "Series") {
            safeThis->m_currentPlayableItem.mediaSources = info.mediaSources;
          }

          int idx = safeThis->m_actionWidget->currentSourceIndex();
          if (idx >= info.mediaSources.size())
            idx = 0;
          safeThis->m_actionWidget->setSources(info.mediaSources, idx);
          safeThis->m_appliedSourcesFingerprint =
              computeSourcesFingerprint(info.mediaSources);
          idx = safeThis->m_actionWidget->currentSourceIndex();
          if (idx >= safeThis->m_currentMediaItem.mediaSources.size())
            idx = 0;
          if (idx < safeThis->m_currentMediaItem.mediaSources.size()) {
            const MediaSourceInfo &singleSource =
                safeThis->m_currentMediaItem.mediaSources[idx];
            safeThis->m_actionWidget->setStreams(singleSource);
            QList<MediaSourceInfo> sList;
            sList.append(singleSource);
            
            const QString fp = computeBottomInfoFingerprint(
                safeThis->m_currentMediaItem, sList);
            if (fp != safeThis->m_appliedBottomInfoFingerprint) {
              safeThis->m_bottomInfoWidget->setInfo(
                  safeThis->m_currentMediaItem, sList);
              safeThis->m_appliedBottomInfoFingerprint = fp;
              if (safeThis->m_deferBottomInfoReveal) {
                showReserveWidget(
                    safeThis->m_bottomInfoReserveWidget,
                    reserveHeightFor(safeThis->m_bottomInfoWidget, 220));
              }
            }
          }
        }
      } catch (...) {
      }
    }
  }

  if (!safeThis)
    co_return;
  safeThis->m_bottomInfoWidget->setVisible(
      !safeThis->m_deferBottomInfoReveal);
  if (safeThis->m_deferBottomInfoReveal) {
    showReserveWidget(safeThis->m_bottomInfoReserveWidget,
                      reserveHeightFor(safeThis->m_bottomInfoWidget, 220));
  } else {
    hideReserveWidget(safeThis->m_bottomInfoReserveWidget);
  }
  if (!isSilentRefresh && safeThis)
    QMetaObject::invokeMethod(safeThis.data(), "scrollToTop",
                              Qt::QueuedConnection);
}

void DetailView::onOverviewMoreClicked(const QString &link) {
  if (link == "more") {
    OverviewDialog dialog(this);
    dialog.setMediaItem(m_currentMediaItem, m_currentPosterPix);
    dialog.exec();
  }
}

QCoro::Task<void>
DetailView::executeSilentRefresh(QPointer<DetailView> safeThis, QEmbyCore *core,
                                 QString itemId) {
  QString cacheServerId;
  QString cacheUserId;
  if (core && core->serverManager()) {
    const ServerProfile profile = core->serverManager()->activeProfile();
    cacheServerId = profile.id;
    cacheUserId = profile.userId;
  }

  try {
    MediaItem item = co_await core->mediaService()->getItemDetail(itemId);
    if (!cacheServerId.isEmpty() && !cacheUserId.isEmpty()) {
      const QString fp = co_await QtConcurrent::run(
          [item]() mutable { return DetailCacheUtils::fingerprint(item); });
      saveDetailCacheAsync(cacheServerId, cacheUserId, item, fp);
      if (safeThis && item.id == safeThis->m_currentItemId)
        safeThis->m_cachedDetailFingerprint = fp;
    }
    if (safeThis && item.id == safeThis->m_currentItemId) {
      co_await safeThis->updateUi(item, true);

      
      if (item.type == "Series") {
        co_await safeThis->fetchSeriesNextUp(
            itemId, !safeThis->m_hasManualSeriesSelection);
        if (!safeThis || safeThis->m_currentItemId != itemId)
          co_return;

        auto seasons = co_await core->mediaService()->getSeasons(itemId);
        if (!safeThis || safeThis->m_currentItemId != itemId)
          co_return;

        safeThis->m_seriesSeasons = seasons;
        safeThis->m_cachedSeriesSeasons = seasons;
        safeThis->m_hasCachedSeriesSeasons = true;

        
        
        bool selectedSeasonResolved = false;
        if (safeThis->m_hasManualSeriesSelection &&
            !safeThis->m_manualSelectedSeasonId.isEmpty()) {
          for (int i = 0; i < seasons.size(); ++i) {
            if (seasons[i].id == safeThis->m_manualSelectedSeasonId) {
              safeThis->m_currentSeasonIndex = i;
              selectedSeasonResolved = true;
              break;
            }
          }
        }
        if (!selectedSeasonResolved &&
            safeThis->m_hasManualSeriesSelection &&
            safeThis->m_manualSelectedSeasonIndex >= 0 &&
            safeThis->m_manualSelectedSeasonIndex < seasons.size()) {
          safeThis->m_currentSeasonIndex =
              safeThis->m_manualSelectedSeasonIndex;
          selectedSeasonResolved = true;
        }
        if (!selectedSeasonResolved &&
            safeThis->m_hasManualSeriesSelection &&
            safeThis->m_currentSeasonIndex >= 0 &&
            safeThis->m_currentSeasonIndex < seasons.size()) {
          selectedSeasonResolved = true;
        }
        int playableParentIdx =
            safeThis->m_currentPlayableItem.parentIndexNumber;
        if (!selectedSeasonResolved &&
            !safeThis->m_hasManualSeriesSelection && playableParentIdx >= 0) {
          for (int i = 0; i < seasons.size(); ++i) {
            if (seasons[i].indexNumber == playableParentIdx) {
              safeThis->m_currentSeasonIndex = i;
              break;
            }
          }
        }

        if (!seasons.isEmpty() && safeThis->m_episodeWidget) {
          const int idx =
              qBound(0, safeThis->m_currentSeasonIndex, seasons.size() - 1);
          safeThis->updateSeasonSwitcher(idx);

          const QString playableItemId =
              safeThis->m_hasManualSeriesSelection &&
                      !safeThis->m_manualSelectedEpisodeId.isEmpty()
                  ? safeThis->m_manualSelectedEpisodeId
                  : safeThis->m_currentPlayableItem.id;
          co_await safeThis->loadEpisodesForSeason(
              idx, playableItemId, !playableItemId.isEmpty(),
              safeThis->m_hasManualSeriesSelection);
        } else if (safeThis->m_episodeWidget) {
          applyReservedSectionItems(safeThis->m_episodeSectionReserveWidget,
                                    safeThis->m_episodeWidget, {});
        }
        if (!safeThis || safeThis->m_currentItemId != itemId)
          co_return;

        if (safeThis->m_seasonWidget) {
          safeThis->m_seasonWidget->setTitle(tr("Seasons"));
          safeThis->m_seasonWidget->setCardStyle(MediaCardDelegate::Poster);
          safeThis->m_seasonWidget->setGalleryHeight(300);
          applyReservedSectionItems(safeThis->m_seasonSectionReserveWidget,
                                    safeThis->m_seasonWidget, seasons);
        }
      }

      safeThis->applyCastSection(item);
      if (safeThis->m_deferBottomInfoReveal) {
        safeThis->m_deferBottomInfoReveal = false;
        hideReserveWidget(safeThis->m_bottomInfoReserveWidget);
        if (safeThis->m_bottomInfoWidget)
          safeThis->m_bottomInfoWidget->show();
      }
      safeThis->persistDetailCacheSnapshot(QStringLiteral("silent-refresh"));
    }
  } catch (...) {
  }
}

QCoro::Task<void> DetailView::executeLoadImages(QPointer<DetailView> safeThis,
                                                QEmbyCore *core,
                                                MediaItem item,
                                                bool allowPrimaryBackdropFallback) {
  bool adaptive =
      ConfigStore::instance()->get<bool>(ConfigKeys::AdaptiveImages, true);
  QString cacheServerId;
  QString cacheUserId;
  if (safeThis) {
    cacheServerId = safeThis->m_detailCacheServerId;
    cacheUserId = safeThis->m_detailCacheUserId;
  } else if (core && core->serverManager()) {
    const ServerProfile profile = core->serverManager()->activeProfile();
    cacheServerId = profile.id;
    cacheUserId = profile.userId;
  }

  
  
  QString posterType = QStringLiteral("Primary");
  QString posterTag = item.images.primaryTag;
  QString posterId = item.id;
  if (posterTag.isEmpty() && adaptive) {
    auto best = item.images.bestPoster();
    posterTag = best.first;
    posterType = best.second;
    if (item.images.isParentTag(posterTag)) {
      posterId = item.images.parentImageItemId.isEmpty()
                     ? item.seriesId
                     : item.images.parentImageItemId;
    }
  }
  const int posterMaxWidth =
      posterType == QStringLiteral("Primary") ? 400 : 800;

  QString backdropType = QStringLiteral("Backdrop");
  QString backdropTag = item.images.backdropTag;
  QString backdropId = item.id;
  if (backdropTag.isEmpty() && adaptive) {
    if (allowPrimaryBackdropFallback) {
      auto best = item.images.bestBackdrop();
      backdropTag = best.first;
      backdropType = best.second;
    } else {
      if (!item.images.thumbTag.isEmpty()) {
        backdropTag = item.images.thumbTag;
        backdropType = QStringLiteral("Thumb");
      } else if (!item.images.parentBackdropTag.isEmpty()) {
        backdropTag = item.images.parentBackdropTag;
        backdropType = QStringLiteral("Backdrop");
      } else if (!item.images.parentThumbTag.isEmpty()) {
        backdropTag = item.images.parentThumbTag;
        backdropType = QStringLiteral("Thumb");
      }
    }
    if (item.images.isParentTag(backdropTag)) {
      backdropId = item.images.parentImageItemId.isEmpty()
                       ? item.seriesId
                       : item.images.parentImageItemId;
    }
  }

  const QString logoId = item.id;
  const QString logoType = QStringLiteral("Logo");
  const QString logoTag = item.images.logoTag;
  constexpr int logoMaxWidth = 400;

  const CachedDetailImages cachedImages = co_await QtConcurrent::run(
      [cacheServerId, cacheUserId, ownerItemId = item.id, posterId,
       posterType, posterTag, posterMaxWidth, backdropId, backdropType,
       backdropTag, logoId, logoType, logoTag, logoMaxWidth]() mutable {
        CachedDetailImages result;
        if (!posterTag.isEmpty()) {
          result.poster = DetailCacheUtils::loadImage(
              cacheServerId, cacheUserId, ownerItemId,
              QStringLiteral("poster"), posterId, posterType, posterTag,
              posterMaxWidth);
        }
        if (!backdropTag.isEmpty()) {
          result.backdrop = DetailCacheUtils::loadImage(
              cacheServerId, cacheUserId, ownerItemId,
              QStringLiteral("backdrop"), backdropId, backdropType,
              backdropTag, 1920);
        }
        if (!logoTag.isEmpty()) {
          result.logo = DetailCacheUtils::loadImage(
              cacheServerId, cacheUserId, ownerItemId, QStringLiteral("logo"),
              logoId, logoType, logoTag, logoMaxWidth);
        }
        return result;
      });
  if (!safeThis || safeThis->m_currentItemId != item.id)
    co_return;

  if (cachedImages.poster.has_value()) {
    safeThis->m_currentPosterPix =
        QPixmap::fromImage(cachedImages.poster.value());
    safeThis->m_posterLabel->setPixmap(safeThis->m_currentPosterPix);
    qDebug() << "[DetailView] Detail poster image cache hit"
             << "itemId=" << item.id << "imageId=" << posterId
             << "type=" << posterType;
  }

  if (cachedImages.backdrop.has_value()) {
    safeThis->m_currentBackdropPix =
        QPixmap::fromImage(cachedImages.backdrop.value());
    safeThis->updateBackdrop();
    qDebug() << "[DetailView] Detail backdrop image cache hit"
             << "itemId=" << item.id << "imageId=" << backdropId
             << "type=" << backdropType;
  }

  if (cachedImages.logo.has_value()) {
    safeThis->m_logoLabel->setPixmap(
        QPixmap::fromImage(cachedImages.logo.value()));
    FadeHelper::fadeIn(safeThis->m_logoLabel,
                       AnimationTokens::DurationMs::kNormal);
    qDebug() << "[DetailView] Detail logo image cache hit"
             << "itemId=" << item.id;
  }

  
  if (!posterTag.isEmpty()) {
    try {
      QPixmap pix = co_await core->mediaService()->fetchImage(
          posterId, posterType, posterTag, posterMaxWidth);
      if (safeThis && safeThis->m_currentItemId == item.id && !pix.isNull()) {
        safeThis->m_currentPosterPix = pix;

        
        
        
        const QSize posterSize(250, 375);
        const QString currentItemId = item.id;
        QImage src = pix.toImage();

        auto *watcher = new QFutureWatcher<QImage>(safeThis.data());
        QObject::connect(
            watcher, &QFutureWatcher<QImage>::finished, safeThis.data(),
            [safeThis, watcher, currentItemId, cacheServerId, cacheUserId,
             posterId, posterType, posterTag, posterMaxWidth]() {
              if (safeThis && safeThis->m_currentItemId == currentItemId) {
                const QImage result = watcher->result();
                if (!result.isNull()) {
                  safeThis->m_posterLabel->setPixmap(
                      QPixmap::fromImage(result));
                  saveDetailImageAsync(cacheServerId, cacheUserId,
                                       currentItemId,
                                       QStringLiteral("poster"), posterId,
                                       posterType, posterTag, posterMaxWidth,
                                       result);
                }
              }
              watcher->deleteLater();
            });
        watcher->setFuture(QtConcurrent::run([src, posterSize]() -> QImage {
          QImage scaled =
              src.scaled(posterSize, Qt::KeepAspectRatioByExpanding,
                         Qt::SmoothTransformation);
          const int cropX = (scaled.width() - posterSize.width()) / 2;
          const int cropY = (scaled.height() - posterSize.height()) / 2;
          QImage cropped =
              scaled.copy(cropX, cropY, posterSize.width(), posterSize.height());

          
          QImage rounded(posterSize, QImage::Format_ARGB32_Premultiplied);
          rounded.fill(Qt::transparent);
          QPainter p(&rounded);
          p.setRenderHint(QPainter::Antialiasing);
          QPainterPath path;
          path.addRoundedRect(
              QRectF(0, 0, posterSize.width(), posterSize.height()), 12, 12);
          p.setClipPath(path);
          p.drawImage(0, 0, cropped);
          p.end();
          return rounded;
        }));
      }
    } catch (...) {
    }
  }

  
  if (!backdropTag.isEmpty()) {
    try {
      QPixmap pix = co_await core->mediaService()->fetchImage(
          backdropId, backdropType, backdropTag, 1920);
      if (safeThis && safeThis->m_currentItemId == item.id && !pix.isNull()) {
        safeThis->m_currentBackdropPix = pix;
        safeThis->updateBackdrop();
        saveDetailImageAsync(cacheServerId, cacheUserId, item.id,
                             QStringLiteral("backdrop"), backdropId,
                             backdropType, backdropTag, 1920, pix.toImage());
      }
    } catch (...) {
    }
  }

  
  
  if (!logoTag.isEmpty()) {
    try {
      QPixmap pix =
          co_await core->mediaService()->fetchImage(logoId, logoType, logoTag,
                                                    logoMaxWidth);
      if (safeThis && safeThis->m_currentItemId == item.id && !pix.isNull()) {
        const QString currentItemId = item.id;
        QImage src = pix.toImage();

        auto *watcher = new QFutureWatcher<QImage>(safeThis.data());
        QObject::connect(
            watcher, &QFutureWatcher<QImage>::finished, safeThis.data(),
            [safeThis, watcher, currentItemId, cacheServerId, cacheUserId,
             logoId, logoType, logoTag, logoMaxWidth]() {
              if (safeThis &&
                  safeThis->m_currentItemId == currentItemId) {
                const QImage result = watcher->result();
                if (!result.isNull()) {
                  safeThis->m_logoLabel->setPixmap(
                      QPixmap::fromImage(result));
                  FadeHelper::fadeIn(safeThis->m_logoLabel,
                                     AnimationTokens::DurationMs::kNormal);
                  saveDetailImageAsync(
                      cacheServerId, cacheUserId, currentItemId,
                      QStringLiteral("logo"), logoId, logoType, logoTag,
                      logoMaxWidth, result);
                }
              }
              watcher->deleteLater();
            });
        watcher->setFuture(QtConcurrent::run([src]() -> QImage {
          return src.scaled(250, 100, Qt::KeepAspectRatio,
                            Qt::SmoothTransformation);
        }));
      }
    } catch (...) {
    }
  }
}

void DetailView::onMediaItemUpdated(const MediaItem &item) {
  
  if (m_currentItemId == item.id && m_core && !m_skipSilentRefresh) {
    QCoro::connect(
        executeSilentRefresh(QPointer<DetailView>(this), m_core, item.id), this,
        []() {});
  }

  
  if (item.type == "Season" && !m_currentSeasonEpisodes.isEmpty()) {
    bool belongsToSeries = false;
    for (const MediaItem &season : m_seriesSeasons) {
      if (season.id == item.id) {
        belongsToSeries = true;
        break;
      }
    }
    if (belongsToSeries) {
      for (MediaItem &ep : m_currentSeasonEpisodes) {
        if (ep.parentIndexNumber == item.indexNumber)
          ep.userData.played = item.userData.played;
      }
      m_episodeWidget->setItems(m_currentSeasonEpisodes);
    }
  }

  
  if (item.type == "Episode" && !m_currentSeasonEpisodes.isEmpty() &&
      !m_seriesSeasons.isEmpty()) {
    
    for (MediaItem &ep : m_currentSeasonEpisodes) {
      if (ep.id == item.id) {
        ep.userData.played = item.userData.played;
        break;
      }
    }
    
    const int seasonIndex = item.parentIndexNumber;
    if (seasonIndex >= 0) {
      for (MediaItem &season : m_seriesSeasons) {
        if (season.indexNumber == seasonIndex) {
          int total = 0, played = 0;
          for (const MediaItem &ep : m_currentSeasonEpisodes) {
            if (ep.parentIndexNumber == seasonIndex) {
              total++;
              if (ep.userData.played)
                played++;
            }
          }
          const bool allPlayed = (total > 0 && played == total);
          if (season.userData.played != allPlayed) {
            season.userData.played = allPlayed;
            m_seasonWidget->updateItem(season);
          }
          break;
        }
      }
    }
  }

  
  if (m_currentPlayableItem.id == item.id) {
    m_currentPlayableItem.userData.played = item.userData.played;
    m_actionWidget->setPlayedState(item.userData.played);
  }
  if (m_currentMediaItem.id == item.id) {
    m_currentMediaItem.userData.played = item.userData.played;
    m_actionWidget->setPlayedState(item.userData.played);
  }

  if (m_seasonWidget)
    m_seasonWidget->updateItem(item);
  if (m_episodeWidget)
    m_episodeWidget->updateItem(item);
  if (m_castWidget)
    m_castWidget->updateItem(item);
  if (m_additionalPartsWidget)
    m_additionalPartsWidget->updateItem(item);
  if (m_collectionWidget)
    m_collectionWidget->updateItem(item);
  if (m_similarWidget)
    m_similarWidget->updateItem(item);
}

void DetailView::beginOptimisticPlayedUpdate() { m_skipSilentRefresh = true; }

void DetailView::endOptimisticPlayedUpdate() { m_skipSilentRefresh = false; }

void DetailView::updateSeasonSwitcher(int currentIndex) {
  if (!m_seasonSwitcher)
    return;

  QSignalBlocker blocker(m_seasonSwitcher);
  m_seasonSwitcher->clear();

  for (const MediaItem &season : m_seriesSeasons)
    m_seasonSwitcher->addItem(season.name, "");

  if (!m_seriesSeasons.isEmpty()) {
    const int idx = qBound(0, currentIndex, m_seriesSeasons.size() - 1);
    m_seasonSwitcher->setCurrentIndex(idx);
  }

  m_seasonSwitcher->setVisible(m_seriesSeasons.size() > 1);
  m_seasonSwitcher->adjustSize();
  if (m_episodeJumpEdit) {
    const int switcherHeight =
        qMax(m_seasonSwitcher->height(), m_seasonSwitcher->sizeHint().height());
    m_episodeJumpEdit->setFixedHeight(switcherHeight);
  }
  updateEpisodeHeaderControlsVisibility();
}

void DetailView::updateEpisodeHeaderControlsVisibility() {
  if (!m_episodeHeaderControls)
    return;

  const bool showSeasonSwitcher =
      m_seasonSwitcher && !m_seasonSwitcher->isHidden();
  const bool showEpisodeJump =
      m_episodeJumpEdit && !m_episodeJumpEdit->isHidden();
  m_episodeHeaderControls->setVisible(showSeasonSwitcher || showEpisodeJump);
  m_episodeHeaderControls->adjustSize();
  m_episodeHeaderControls->updateGeometry();
}

void DetailView::updateEpisodeJumpControl(int episodeCount) {
  if (!m_episodeJumpEdit) {
    return;
  }

  const int visibleCardCapacity = episodeGalleryVisibleCardCapacity();
  const bool showJump =
      episodeCount > 0 && visibleCardCapacity > 0 &&
      episodeCount > visibleCardCapacity;
  if (showJump) {
    int explicitMaxEpisodeNumber = 0;
    for (const MediaItem &episode : m_currentSeasonEpisodes)
      explicitMaxEpisodeNumber = qMax(explicitMaxEpisodeNumber,
                                      episode.indexNumber);

    const int maxEpisodeNumber =
        explicitMaxEpisodeNumber > 0 ? explicitMaxEpisodeNumber : episodeCount;
    const QString rangeText = tr("1-%1").arg(maxEpisodeNumber);
    m_episodeJumpEdit->setPlaceholderText(rangeText);
    m_episodeJumpEdit->setToolTip(
        tr("Jump to episode number (1-%1)").arg(maxEpisodeNumber));
    if (m_episodeJumpValidator)
      m_episodeJumpValidator->setTop(maxEpisodeNumber);
    m_episodeJumpEdit->setMaxLength(
        qMax(1, QString::number(maxEpisodeNumber).length()));

    const int textWidth =
        m_episodeJumpEdit->fontMetrics().horizontalAdvance(rangeText);
    m_episodeJumpEdit->setFixedWidth(qBound(64, textWidth + 22, 92));
  } else {
    m_episodeJumpEdit->clear();
    m_episodeJumpEdit->setPlaceholderText(tr("Ep #"));
    m_episodeJumpEdit->setToolTip(tr("Jump to episode number"));
    if (m_episodeJumpValidator)
      m_episodeJumpValidator->setTop(9999);
    m_episodeJumpEdit->setMaxLength(4);
    m_episodeJumpEdit->setFixedWidth(64);
  }

  m_episodeJumpEdit->setVisible(showJump);
  updateEpisodeHeaderControlsVisibility();
}

int DetailView::episodeGalleryVisibleCardCapacity() const {
  if (!m_episodeWidget || !m_episodeWidget->gallery())
    return 0;

  QListView *listView = m_episodeWidget->gallery()->listView();
  if (!listView || !listView->viewport())
    return 0;

  int cardWidth = m_episodeTileWidth;
  if (cardWidth <= 0 && listView->model() && listView->model()->rowCount() > 0) {
    const QSize itemSize =
        listView->sizeHintForIndex(listView->model()->index(0, 0));
    cardWidth = itemSize.width();
  }
  if (cardWidth <= 0)
    return 0;

  const int viewportWidth = listView->viewport()->width();
  if (viewportWidth <= 0)
    return 0;

  return qMax(1, viewportWidth / cardWidth);
}

MediaItem DetailView::episodeForJumpNumber(int episodeNumber) const {
  if (episodeNumber <= 0)
    return MediaItem{};

  bool hasExplicitEpisodeNumbers = false;
  for (const MediaItem &episode : m_currentSeasonEpisodes) {
    if (episode.indexNumber > 0)
      hasExplicitEpisodeNumbers = true;
    if (episode.indexNumber == episodeNumber)
      return episode;
  }

  if (hasExplicitEpisodeNumbers)
    return MediaItem{};

  const int row = episodeNumber - 1;
  if (row >= 0 && row < m_currentSeasonEpisodes.size())
    return m_currentSeasonEpisodes.at(row);

  return MediaItem{};
}

void DetailView::submitEpisodeJump() {
  if (!m_episodeJumpEdit || m_episodeJumpEdit->isHidden() ||
      m_currentSeasonEpisodes.isEmpty()) {
    return;
  }

  const QString text = m_episodeJumpEdit->text().trimmed();
  if (text.isEmpty())
    return;

  bool ok = false;
  const int episodeNumber = text.toInt(&ok);
  if (!ok)
    return;

  const MediaItem targetEpisode = episodeForJumpNumber(episodeNumber);
  if (targetEpisode.id.isEmpty()) {
    qDebug() << "[DetailView] Episode jump target not found"
             << "seriesId=" << m_currentItemId
             << "seasonIndex=" << m_currentSeasonIndex
             << "episodeNumber=" << episodeNumber
             << "episodeCount=" << m_currentSeasonEpisodes.size();
    ModernToast::showMessage(tr("Episode %1 not found").arg(episodeNumber),
                             1600);
    m_episodeJumpEdit->selectAll();
    return;
  }

  qDebug() << "[DetailView] Episode jump"
           << "seriesId=" << m_currentItemId
           << "seasonIndex=" << m_currentSeasonIndex
           << "episodeNumber=" << episodeNumber
           << "episodeId=" << targetEpisode.id;

  m_episodeJumpEdit->clear();
  markManualSeriesSelection(QStringLiteral("episode-jump"));
  QCoro::connect(applySeriesPlayableItem(targetEpisode, true), this, []() {});
}

QCoro::Task<void> DetailView::loadEpisodesForSeason(int idx,
                                                    QString highlightEpisodeId,
                                                    bool scrollToHighlight,
                                                    bool manualSelection) {
  if (idx < 0 || idx >= m_seriesSeasons.size() || !m_episodeWidget)
    co_return;

  m_currentSeasonIndex = idx;
  const QString seasonId = m_seriesSeasons[idx].id;
  if (seasonId.isEmpty())
    co_return;
  if (manualSelection)
    markManualSeriesSelection(QStringLiteral("season-selection"));
  rememberSeriesSelection(MediaItem{}, QStringLiteral("season-selection"),
                          !manualSelection);

  bool showedCachedEpisodes = false;
  QList<MediaItem> shownCachedEpisodes;
  if (m_hasCachedSeasonEpisodes && m_cachedSeasonIndex == idx &&
      m_cachedSeasonId == seasonId &&
      episodesBelongToSeason(m_cachedSeasonEpisodes, m_seriesSeasons[idx])) {
    shownCachedEpisodes = m_cachedSeasonEpisodes;
    if (!m_appliedCachedSeasonEpisodesToUi) {
      m_currentSeasonEpisodes = shownCachedEpisodes;
      applyReservedSectionItems(m_episodeSectionReserveWidget, m_episodeWidget,
                                shownCachedEpisodes);
      updateEpisodeJumpControl(shownCachedEpisodes.size());
      if (!highlightEpisodeId.isEmpty()) {
        m_episodeWidget->gallery()->setHighlightedItemId(highlightEpisodeId);
        if (scrollToHighlight) {
          m_episodeWidget->gallery()->scrollToItemId(highlightEpisodeId);
        }
      }
      m_appliedCachedSeasonEpisodesToUi = true;
    }
    showedCachedEpisodes = true;
    qDebug() << "[DetailView][cache-ui] Applied cached season episodes"
             << "seriesId=" << m_currentItemId << "seasonId=" << seasonId
             << "seasonIndex=" << idx
             << "episodeCount=" << shownCachedEpisodes.size();
  } else {
    m_currentSeasonEpisodes.clear();
    updateEpisodeJumpControl(0);
  }

  if (!m_core || !m_core->mediaService())
    co_return;

  QPointer<DetailView> safeThis(this);
  const QString seriesId = m_currentItemId;
  QEmbyCore *core = m_core;

  try {
    qDebug() << "[DetailView][network] Fetch season episodes"
             << "seriesId=" << seriesId << "seasonId=" << seasonId
             << "seasonIndex=" << idx;
    QList<MediaItem> episodes =
        co_await core->mediaService()->getEpisodes(seriesId, seasonId);

    if (!safeThis || safeThis->m_currentItemId != seriesId ||
        safeThis->m_currentSeasonIndex != idx)
      co_return;

    bool episodesUnchanged = false;
    if (showedCachedEpisodes) {
      episodesUnchanged =
          co_await mediaItemListsEqualAsync(shownCachedEpisodes, episodes);
      if (!safeThis || safeThis->m_currentItemId != seriesId ||
          safeThis->m_currentSeasonIndex != idx)
        co_return;
    }

    safeThis->m_currentSeasonEpisodes = episodes;
    if (!safeThis->m_hasManualSeriesSelection) {
      safeThis->m_cachedSeasonEpisodes = episodes;
      safeThis->m_cachedSeasonIndex = idx;
      safeThis->m_cachedSeasonId = seasonId;
      safeThis->m_hasCachedSeasonEpisodes = true;
    } else {
      qDebug() << "[DetailView] Skip persisting manually selected season "
                  "episodes"
               << "seriesId=" << seriesId << "seasonId=" << seasonId
               << "seasonIndex=" << idx;
    }
    if (!manualSelection && !highlightEpisodeId.isEmpty() &&
        safeThis->m_currentPlayableItem.id != highlightEpisodeId) {
      for (const MediaItem &episode : episodes) {
        if (episode.id == highlightEpisodeId) {
          safeThis->applySeriesPlayableItemToUi(episode);
          break;
        }
      }
    }
    if (!episodesUnchanged) {
      applyReservedSectionItems(safeThis->m_episodeSectionReserveWidget,
                                safeThis->m_episodeWidget, episodes);
    }
    safeThis->updateEpisodeJumpControl(episodes.size());

    qDebug() << "[DetailView][network] Loaded season episodes"
             << "seriesId=" << seriesId << "seasonId=" << seasonId
             << "seasonIndex=" << idx << "episodeCount=" << episodes.size()
             << "fromCache=" << showedCachedEpisodes
             << "unchanged=" << episodesUnchanged
             << "visibleCardCapacity="
             << safeThis->episodeGalleryVisibleCardCapacity()
             << "jumpVisible="
             << (safeThis->m_episodeJumpEdit &&
                 !safeThis->m_episodeJumpEdit->isHidden());

    if (!highlightEpisodeId.isEmpty()) {
      safeThis->m_episodeWidget->gallery()->setHighlightedItemId(
          highlightEpisodeId);
      if (scrollToHighlight) {
        safeThis->m_episodeWidget->gallery()->scrollToItemId(
            highlightEpisodeId);
      }
    }
    safeThis->persistDetailCacheSnapshot(QStringLiteral("episodes"));
  } catch (...) {
    if (safeThis && safeThis->m_currentItemId == seriesId &&
        safeThis->m_currentSeasonIndex == idx) {
      if (!showedCachedEpisodes) {
        safeThis->m_currentSeasonEpisodes.clear();
        safeThis->updateEpisodeJumpControl(0);
        applyReservedSectionItems(safeThis->m_episodeSectionReserveWidget,
                                  safeThis->m_episodeWidget, {});
      }
      qDebug() << "[DetailView] Failed to load season episodes"
               << "seriesId=" << seriesId << "seasonId=" << seasonId
               << "seasonIndex=" << idx
               << "keptCache=" << showedCachedEpisodes;
    }
  }
}


QCoro::Task<void> DetailView::switchToSeason(int idx, bool manualSelection) {
  co_await loadEpisodesForSeason(idx, QString(), false, manualSelection);
}