MatchLiveTv/backend/app/helpers/admin_helper.rb

module AdminHelper
  def format_euros(cents, precision: 2)
    return I18n.t("admin.common.dash") if cents.nil?

    format("%.*f €", precision, cents.to_f / 100.0)
  end

  def format_hours(hours)
    return I18n.t("admin.common.dash") if hours.nil? || hours.to_f <= 0

    total_minutes = (hours.to_f * 60).round
    format_duration_minutes(total_minutes)
  end

  def admin_month_label(month)
    I18n.l(month, format: "%B %Y")
  end

  def format_bytes(bytes)
    return "—" if bytes.nil?

    units = %w[B KB MB GB TB]
    size = bytes.to_f
    unit = units.shift
    while size >= 1024 && units.any?
      size /= 1024
      unit = units.shift
    end
    "#{size.round(size >= 10 ? 0 : 1)} #{unit}"
  end

  def format_duration_minutes(minutes)
    return "0 min" if minutes.to_i <= 0

    hours = minutes / 60
    mins = minutes % 60
    hours.positive? ? "#{hours}h #{mins}m" : "#{mins} min"
  end

  def admin_session_watch_links(session)
    links = []
    if session.matchlivetv_platform?
      links << { label: I18n.t("admin.common.live_page"), url: session.watch_page_url }
    end
    youtube = session.youtube_watch_url
    links << { label: "YouTube", url: youtube } if youtube.present?
    links
  end

  def admin_session_ingest_badge_class(role_or_node)
    role = role_or_node.respond_to?(:role) ? role_or_node.role : role_or_node
    case role.to_s
    when "home" then "badge--ingest-home"
    when "lab" then "badge--ingest-lab"
    when "cloud" then "badge--ingest-cloud"
    else "badge--paused"
    end
  end

  def admin_session_ingest_role_label(role_or_node)
    role = role_or_node.respond_to?(:role) ? role_or_node.role : role_or_node
    I18n.t("admin.sessions.ingest.role.#{role}", default: role.to_s.humanize)
  end

  def admin_session_status_badge_class(status)
    case status.to_s
    when "live" then "badge--live"
    when "connecting", "reconnecting" then "badge--connecting"
    when "paused", "idle" then "badge--paused"
    when "ended" then "badge--ended"
    when "error" then "badge--error"
    else "badge--paused"
    end
  end

  def admin_datetime(time, with_seconds: false)
    return I18n.t("admin.common.dash") if time.blank?

    format = with_seconds ? "%d/%m/%Y %H:%M:%S" : "%d/%m/%Y %H:%M"
    time.in_time_zone.strftime(format)
  end

  def admin_session_duration_label(session)
    secs = session.total_duration_secs.to_i
    if secs <= 0 && session.started_at
      end_time = session.ended_at || (session.terminal? ? session.updated_at : Time.current)
      secs = (end_time - session.started_at).to_i if end_time
    end
    return I18n.t("admin.common.dash") if secs <= 0

    hours = secs / 3600
    mins = (secs % 3600) / 60
    rem = secs % 60
    if hours.positive?
      format("%dh %02dm %02ds", hours, mins, rem)
    elsif mins.positive?
      format("%dm %02ds", mins, rem)
    else
      "#{rem}s"
    end
  end

  def admin_session_client_os_label(session)
    case session.client_os.to_s
    when "android" then "Android"
    when "ios" then "iOS"
    else I18n.t("admin.common.dash")
    end
  end

  def admin_session_client_summary(session)
    parts = []
    parts << admin_session_client_os_label(session) if session.client_os.present?
    if session.app_version.present?
      ver = session.app_version
      ver = "#{ver} (#{session.app_build})" if session.app_build.present?
      parts << "app #{ver}"
    end
    device = [session.device_manufacturer, session.device_model].compact_blank.join(" ")
    parts << device if device.present?
    parts << "OS #{session.os_version}" if session.os_version.present?
    parts << session.carrier if session.carrier.present?
    parts.presence&.join(" · ") || I18n.t("admin.common.dash")
  end

  def admin_format_event_meta(metadata)
    return content_tag(:span, I18n.t("admin.common.dash"), class: "muted") if metadata.blank?

    pairs = metadata.to_h
    return content_tag(:span, I18n.t("admin.common.dash"), class: "muted") if pairs.empty?

    content_tag(:dl, class: "admin-event-meta") do
      safe_join(
        pairs.map do |key, value|
          content_tag(:div, class: "admin-event-meta__row") do
            content_tag(:dt, key.to_s) +
              content_tag(:dd, admin_event_meta_value(value))
          end
        end
      )
    end
  end

  def admin_event_meta_value(value)
    case value
    when Hash, Array
      content_tag(:code, value.to_json)
    when TrueClass, FalseClass
      value ? "true" : "false"
    when NilClass
      I18n.t("admin.common.dash")
    else
      value.to_s
    end
  end

  def admin_regia_expires_label(iso_time)
    return if iso_time.blank?

    Time.zone.parse(iso_time).strftime("%d/%m/%Y %H:%M")
  rescue ArgumentError, TypeError
    nil
  end

  def announcement_status_badge(item)
    case item.status
    when "published" then item.severity == "critical" ? "live" : "ready"
    when "archived" then "paused"
    else "connecting"
    end
  end

  def announcement_window_label(item)
    start_label = item.starts_at&.in_time_zone&.strftime("%d/%m %H:%M")
    end_label = item.ends_at&.in_time_zone&.strftime("%d/%m %H:%M")
    if start_label && end_label
      "#{start_label} → #{end_label}"
    elsif start_label
      I18n.t("admin.announcements.window.from", time: start_label)
    elsif end_label
      I18n.t("admin.announcements.window.until", time: end_label)
    else
      I18n.t("admin.announcements.window.always")
    end
  end

  def announcement_channels_label(item)
    labels = item.selected_channels.map { |key| I18n.t("admin.announcements.channels.#{key}") }
    labels.presence&.join(" · ") || I18n.t("admin.common.dash")
  end

  def admin_concurrency_violation_lookback_count
    @admin_concurrency_violation_lookback_count ||= StreamConcurrencyViolation.lookback.count
  end
end