Riduce reload MediaMTX in live e allinea ingest mobile al preset qualità.

Evita patch recording ripetute che distruggevano i muxer HLS (500 ops) e fa encoderare 1080p/720p con codec e bitrate coerenti al wizard.

Co-authored-by: Cursor <cursoragent@cursor.com>

.gitignore

@@ -20,6 +20,9 @@ infra/certs/
 infra/recordings/
 infra/.env
 infra/.env.production.generated
+infra/garage/dev-credentials.env
+infra/garage/prod-credentials.env
+infra/garage/garage.prod.toml
 
 # OS
 .DS_Store

README.md

@@ -2,15 +2,15 @@
 
 Piattaforma mobile-first per streaming di partite sportive giovanili — MVP su **Match Live TV** (HLS sul nostro sito); YouTube/Facebook/Twitch come integrazioni premium.
 
-**Slogan:** *Lo streaming che non muore*
+**Slogan:** *Ogni partita, ogni evento, per i tuoi tifosi.*
 
 ## Struttura monorepo
 
 ```
-├── backend/     # Rails 7.2 API + Action Cable + Sidekiq
-├── mobile/      # Flutter app (Camera + Regia)
-├── infra/       # Docker Compose, MediaMTX, Nginx, Kamal
-└── docs/        # Documentazione
+├── backend/        # Rails 7.2 API + Action Cable + Sidekiq
+├── native/android/ # App Android nativa (Kotlin + Compose)
+├── infra/          # Docker Compose, MediaMTX, Nginx, Kamal
+└── docs/           # Documentazione
 ```
 
 ## Deploy produzione (server 192.168.1.146)
@@ -45,26 +45,32 @@ email: coach@matchlivetv.test
 password: password123
 ```
 
-## Mobile
+## App Android nativa
 
 ```bash
-cd mobile
-flutter pub get
-flutter run
+./scripts/build_native_android_apk_prod.sh
+adb install -r native/android/app/build/outputs/apk/release/app-release.apk
 ```
 
-Configura `API_BASE_URL` in `lib/core/config.dart` (default `http://10.0.2.2:3000` per emulatore Android).
+API produzione: `https://www.matchlivetv.it` (override con `-PAPI_BASE_URL=...` in Gradle).
+
+Vedi [native/android/README.md](native/android/README.md).
 
 ## Architettura
 
-- Video (MVP): Phone → MediaMTX (RTMP) → HLS su `matchlivetv.*` (pagina `/live/:session_id`)
-- Video (premium): stesso ingest + relay ffmpeg verso YouTube
+Documentazione completa: **[docs/ARCHITECTURE.md](docs/ARCHITECTURE.md)** (rete, edge nginx, flussi video, ops).
+
+In sintesi:
+
+- Video live: Phone → MediaMTX (RTMP) → HLS via edge `/hls/` (non Puma)
+- Video replay: Rails auth → redirect `/media/` → Garage (non Puma)
+- Video premium: stesso ingest + relay ffmpeg verso YouTube
 - Controllo: Phone ↔ Action Cable ↔ Rails ↔ PostgreSQL
 - Disconnessioni: MediaMTX `alwaysAvailable` slate + timeout 5 min (Sidekiq)
 
-### Mobile produzione
+### App Android produzione
 
 ```bash
-./scripts/run_mobile_android_prod.sh
-# API: https://matchlivetv.eminux.it
+./scripts/build_native_android_apk_prod.sh
+# API: https://www.matchlivetv.it
 ```

backend/Dockerfile

@@ -1,7 +1,7 @@
 FROM ruby:3.3-bookworm
 
 RUN apt-get update -qq && \
-    apt-get install -y --no-install-recommends build-essential libpq-dev curl ffmpeg && \
+    apt-get install -y --no-install-recommends build-essential libpq-dev curl ffmpeg librsvg2-bin fonts-dejavu-core && \
     rm -rf /var/lib/apt/lists/*
 
 WORKDIR /app

backend/Gemfile

@@ -17,7 +17,10 @@ gem "attr_encrypted"
 gem "google-apis-youtube_v3"
 gem "faraday"
 gem "stripe"
+gem "aws-sdk-s3", "~> 1.0", require: false
 gem "kamal", require: false
+gem "sentry-ruby"
+gem "sentry-rails"
 
 group :development, :test do
   gem "debug", platforms: %i[ mri windows ], require: "debug/prelude"

backend/Gemfile.lock

@@ -81,6 +81,25 @@ GEM
     ast (2.4.3)
     attr_encrypted (4.2.0)
       encryptor (~> 3.0.0)
+    aws-eventstream (1.4.0)
+    aws-partitions (1.1256.0)
+    aws-sdk-core (3.251.0)
+      aws-eventstream (~> 1, >= 1.3.0)
+      aws-partitions (~> 1, >= 1.992.0)
+      aws-sigv4 (~> 1.9)
+      base64
+      bigdecimal
+      jmespath (~> 1, >= 1.6.1)
+      logger
+    aws-sdk-kms (1.129.0)
+      aws-sdk-core (~> 3, >= 3.248.0)
+      aws-sigv4 (~> 1.5)
+    aws-sdk-s3 (1.225.0)
+      aws-sdk-core (~> 3, >= 3.248.0)
+      aws-sdk-kms (~> 1)
+      aws-sigv4 (~> 1.5)
+    aws-sigv4 (1.12.1)
+      aws-eventstream (~> 1, >= 1.0.2)
     base64 (0.3.0)
     bcrypt (3.1.22)
     bcrypt_pbkdf (1.1.2)
@@ -158,6 +177,7 @@ GEM
       prism (>= 1.3.0)
       rdoc (>= 4.0.0)
       reline (>= 0.4.2)
+    jmespath (1.6.2)
     json (2.19.5)
     jwt (3.2.0)
       base64
@@ -361,6 +381,13 @@ GEM
       rubocop-rails (>= 2.30)
     ruby-progressbar (1.13.0)
     securerandom (0.4.1)
+    sentry-rails (6.6.2)
+      railties (>= 5.2.0)
+      sentry-ruby (~> 6.6.2)
+    sentry-ruby (6.6.2)
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      logger
     sidekiq (8.1.5)
       connection_pool (>= 3.0.0)
       json (>= 2.16.0)
@@ -416,6 +443,7 @@ PLATFORMS
 DEPENDENCIES
   aasm
   attr_encrypted
+  aws-sdk-s3 (~> 1.0)
   bcrypt (~> 3.1.7)
   bootsnap
   brakeman
@@ -435,6 +463,8 @@ DEPENDENCIES
   redis (>= 4.0.1)
   rspec-rails
   rubocop-rails-omakase
+  sentry-rails
+  sentry-ruby
   sidekiq
   stripe
   tzinfo-data

backend/app/channels/application_cable/connection.rb

@@ -1,8 +1,14 @@
 module ApplicationCable
   class Connection < ActionCable::Connection::Base
-    identified_by :current_user
+    identified_by :current_user, :regia_session
 
     def connect
+      if (regia_token = request.params[:regia_token].presence)
+        self.regia_session = Sessions::RegiaAccess.find_session_by_token(regia_token)
+        reject_unauthorized_connection unless regia_session
+        return
+      end
+
       payload = JsonWebToken.decode(token_from_header)
       self.current_user = User.find_by(id: payload[:user_id]) if payload
       reject_unauthorized_connection unless current_user

backend/app/channels/concerns/cable_broadcastable.rb

@@ -3,7 +3,7 @@ module CableBroadcastable
 
   class_methods do
     def broadcast_message(session, data)
-      broadcast_to(session, method: "receive_message", data: data)
+      broadcast_to(session, data)
     end
   end
 end

backend/app/channels/session_channel.rb

@@ -1,19 +1,31 @@
 class SessionChannel < ApplicationCable::Channel
   include CableBroadcastable
   def subscribed
-    session = StreamSession.joins(match: :team)
-                           .merge(current_user.teams)
-                           .find(params[:session_id])
+    session = resolve_session
+    reject unless session && session.id.to_s == params[:session_id].to_s
+
     stream_for session
     session.device_states.find_or_create_by!(device_role: params[:device_role] || "controller")
   end
 
+  def resolve_session
+    if connection.regia_session
+      connection.regia_session
+    else
+      StreamSession.joins(match: :team)
+                   .merge(connection.current_user.manageable_teams)
+                   .find_by(id: params[:session_id])
+    end
+  end
+
   def unsubscribed
     stop_all_streams
   end
 
   def receive(data)
-    session = StreamSession.find(params[:session_id])
+    session = resolve_session
+    return unless session
+
     handle_message(session, data)
   end
 
@@ -41,20 +53,13 @@ class SessionChannel < ApplicationCable::Channel
       Sessions::Stop.new(session).call
     when "pause_stream"
       Sessions::Pause.new(session).call
+    when "resume_stream"
+      Sessions::Resume.new(session).call
     end
   end
 
   def update_score(session, data)
-    score = session.score_state || session.create_score_state!
-    score.update!(
-      home_sets: data["home_sets"] || score.home_sets,
-      away_sets: data["away_sets"] || score.away_sets,
-      home_points: data["home_points"] || score.home_points,
-      away_points: data["away_points"] || score.away_points,
-      current_set: data["current_set"] || score.current_set,
-      set_partials: data.key?("set_partials") ? data["set_partials"] : score.set_partials
-    )
-    SessionChannel.broadcast_message(session, score.as_cable_payload)
+    Scoring::SyncState.new(session: session, payload: data).call
   end
 
   def update_timeout(session, data)

backend/app/controllers/admin/auth_controller.rb

@@ -0,0 +1,25 @@
+module Admin
+  class AuthController < Admin::BaseController
+    skip_before_action :require_admin_login, only: %i[new create]
+
+    def new
+      redirect_to admin_root_path if admin_logged_in?
+    end
+
+    def create
+      account = AdminAccount.find_by(username: params[:username]&.strip)
+      if account&.authenticate(params[:password])
+        session[:admin_account_id] = account.id
+        redirect_to session.delete(:admin_return_to) || admin_root_path, notice: "Accesso effettuato"
+      else
+        flash.now[:alert] = "Username o password non validi"
+        render :new, status: :unauthorized
+      end
+    end
+
+    def destroy
+      reset_session
+      redirect_to admin_login_path, notice: "Disconnesso"
+    end
+  end
+end

backend/app/controllers/admin/base_controller.rb

@@ -1,6 +1,32 @@
 module Admin
   class BaseController < ActionController::Base
     layout "admin"
-    protect_from_forgery with: :null_session
+    protect_from_forgery with: :exception
+
+    before_action :require_admin_login
+
+    include ::AdminHelper
+    helper ApplicationHelper
+    helper RecordingsArchiveHelper
+    helper_method :current_admin_account, :admin_logged_in?
+
+    private
+
+    def require_admin_login
+      return if admin_logged_in?
+
+      session[:admin_return_to] = request.fullpath unless request.path == admin_login_path
+      redirect_to admin_login_path, alert: "Accedi per continuare"
+    end
+
+    def current_admin_account
+      return unless session[:admin_account_id]
+
+      @current_admin_account ||= AdminAccount.find_by(id: session[:admin_account_id])
+    end
+
+    def admin_logged_in?
+      current_admin_account.present?
+    end
   end
 end

backend/app/controllers/admin/billing_controller.rb

@@ -0,0 +1,33 @@
+module Admin
+  class BillingController < BaseController
+    def index
+      @pending_payments = pending_scope.recent
+      @completed_payments = Billing::Payment.with_invoice_pdf.includes(:club, :invoice).recent.limit(40)
+      @filter_club = Club.find_by(id: params[:club_id]) if params[:club_id].present?
+      @clubs = Club.order(:name)
+    end
+
+    def attach_pdf
+      payment = Billing::Payment.find(params[:payment_id])
+      Billing::AttachPaymentInvoice.call(payment: payment, pdf: params[:pdf])
+      redirect_to admin_billing_path(billing_redirect_params(payment)),
+                  notice: "Fattura caricata e inviata a #{payment.club.billing_email}."
+    rescue Billing::AttachPaymentInvoice::Error, Billing::IssueInvoice::Error => e
+      payment ||= Billing::Payment.find_by(id: params[:payment_id])
+      redirect_to admin_billing_path(payment ? billing_redirect_params(payment) : {}),
+                  alert: e.message
+    end
+
+    private
+
+    def pending_scope
+      scope = Billing::Payment.awaiting_invoice_pdf.includes(:club, invoice: { pdf_attachment: :blob })
+      scope = scope.where(club_id: params[:club_id]) if params[:club_id].present?
+      scope
+    end
+
+    def billing_redirect_params(payment)
+      { club_id: payment.club_id, anchor: "payment-#{payment.id}" }.compact
+    end
+  end
+end

backend/app/controllers/admin/billing_invoices_controller.rb

@@ -0,0 +1,84 @@
+module Admin
+  class BillingInvoicesController < BaseController
+    before_action :set_club
+    before_action :set_invoice, only: %i[edit update]
+
+    def index
+      redirect_to admin_billing_path(club_id: @club.id)
+    end
+
+    def new
+      redirect_to admin_billing_path(club_id: @club.id), alert: "Carica il PDF dalla lista «Pagamenti da fatturare»."
+    end
+
+    def create
+      @invoice = @club.billing_invoices.build(invoice_params)
+      @invoice.source = "manual"
+      @invoice.status = "draft"
+
+      if @invoice.save
+        redirect_to edit_admin_club_billing_invoice_path(@club, @invoice),
+                    notice: "Bozza creata. Carica il PDF dalla pagina Fatturazione o qui sotto."
+      else
+        @payment = @invoice.billing_payment
+        flash.now[:alert] = @invoice.errors.full_messages.join(", ")
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    def edit
+      @payment = @invoice.billing_payment
+    end
+
+    def update
+      @invoice.assign_attributes(invoice_params.except(:pdf))
+
+      if issuing?
+        Billing::IssueInvoice.call(invoice: @invoice, pdf: params.dig(:billing_invoice, :pdf))
+        redirect_to admin_billing_path(club_id: @club.id),
+                    notice: "Fattura #{@invoice.number} emessa e inviata a #{@club.billing_email}."
+      elsif @invoice.save
+        redirect_to admin_billing_path(club_id: @club.id), notice: "Fattura #{@invoice.number} aggiornata."
+      else
+        @payment = @invoice.billing_payment
+        flash.now[:alert] = @invoice.errors.full_messages.join(", ")
+        render :edit, status: :unprocessable_entity
+      end
+    rescue Billing::IssueInvoice::Error => e
+      @payment = @invoice.billing_payment
+      flash.now[:alert] = e.message
+      render :edit, status: :unprocessable_entity
+    end
+
+    private
+
+    def set_club
+      @club = Club.find(params[:club_id])
+    end
+
+    def set_invoice
+      @invoice = @club.billing_invoices.find(params[:id])
+    end
+
+    def issuing?
+      params[:commit].to_s == "Emetti e invia via email"
+    end
+
+    def invoice_params
+      params.require(:billing_invoice).permit(
+        :number,
+        :issued_on,
+        :amount_cents,
+        :amount_euros,
+        :currency,
+        :billing_payment_id,
+        :notes,
+        :pdf
+      ).tap do |p|
+        if p[:amount_euros].present?
+          p[:amount_cents] = (p.delete(:amount_euros).to_f * 100).round
+        end
+      end
+    end
+  end
+end

backend/app/controllers/admin/club_recordings_controller.rb

@@ -0,0 +1,15 @@
+module Admin
+  class ClubRecordingsController < BaseController
+    include Recordings::ClubArchiveActions
+
+    private
+
+    def archive_namespace
+      :admin
+    end
+
+    def authorize_recording_management!
+      # Admin può gestire tutti i replay della società senza vincoli di ruolo utente.
+    end
+  end
+end

backend/app/controllers/admin/clubs_controller.rb

@@ -0,0 +1,46 @@
+module Admin
+  class ClubsController < BaseController
+    before_action :set_club, only: %i[show grant_comped revoke_comped]
+
+    def index
+      @clubs = Club.includes(:teams, subscription: %i[plan admin_comped_by])
+                   .order(:name)
+    end
+
+    def show
+      @subscription = @club.subscription || @club.build_subscription(plan: Plan["free"], status: "active")
+      @plans = Plan.ordered.reject { |p| p.slug == "free" }
+      @teams = @club.teams.order(:name)
+    end
+
+    def grant_comped
+      Billing::AdminCompedSubscription.grant(
+        club: @club,
+        plan_slug: params.require(:plan_slug),
+        reason: params[:reason],
+        admin: current_admin_account
+      )
+      redirect_back_or_club notice: "Abbonamento omaggio #{Plan[params[:plan_slug]].name} attivato per #{@club.name}."
+    rescue Billing::AdminCompedSubscription::Error, ActiveRecord::RecordInvalid => e
+      redirect_back_or_club alert: e.message
+    end
+
+    def revoke_comped
+      Billing::AdminCompedSubscription.revoke(club: @club, admin: current_admin_account)
+      redirect_back_or_club notice: "Abbonamento omaggio revocato per #{@club.name}."
+    rescue Billing::AdminCompedSubscription::Error => e
+      redirect_back_or_club alert: e.message
+    end
+
+    private
+
+    def set_club
+      @club = Club.find(params[:id])
+    end
+
+    def redirect_back_or_club(notice: nil, alert: nil)
+      target = params[:return_to].presence || admin_club_path(@club)
+      redirect_to target, notice: notice, alert: alert
+    end
+  end
+end

backend/app/controllers/admin/dashboard_controller.rb

@@ -1,8 +1,34 @@
 module Admin
   class DashboardController < Admin::BaseController
     def index
-      @teams = Team.includes(:matches).order(:name)
-      @active_sessions = StreamSession.where(status: %w[live reconnecting connecting]).includes(:match)
+      @stats = DashboardStats.new.call
+      @host = HostMetrics.new.sample!
+      @active_sessions = StreamSession
+        .where(status: DashboardStats::ACTIVE_STATUSES)
+        .includes(match: :team)
+        .order(started_at: :desc)
+      @teams = Team.includes(:matches).order(:name).limit(8)
+    end
+
+    def metrics
+      host = HostMetrics.new.sample!
+      stats = DashboardStats.new.call
+      render json: {
+        host: host,
+        stats: stats,
+        ops_summary: ops_summary,
+        at: Time.current.iso8601
+      }
+    end
+
+    private
+
+    def ops_summary
+      {
+        open_critical: Ops::Incident.critical_open.count,
+        open_warning: Ops::Incident.open.where(severity: "warning").count,
+        open_total: Ops::Incident.open.count
+      }
     end
   end
 end

backend/app/controllers/admin/ops_controller.rb

@@ -0,0 +1,37 @@
+module Admin
+  class OpsController < Admin::BaseController
+    def index
+      @open_incidents = Ops::Incident.open.recent.limit(50)
+      @resolved_incidents = Ops::Incident.where(status: "resolved").since(30.days.ago).recent.limit(30)
+      @summary = ops_summary
+    end
+
+    def acknowledge
+      incident = Ops::Incident.find(params[:id])
+      incident.acknowledge!
+      redirect_to admin_ops_path, notice: "Incidente preso in carico"
+    end
+
+    def resolve
+      incident = Ops::Incident.find(params[:id])
+      incident.resolve!
+      redirect_to admin_ops_path, notice: "Incidente risolto"
+    end
+
+    def mute
+      incident = Ops::Incident.find(params[:id])
+      incident.mute!(duration: 24.hours)
+      redirect_to admin_ops_path, notice: "Notifiche sospese per 24 ore"
+    end
+
+    private
+
+    def ops_summary
+      {
+        open_critical: Ops::Incident.critical_open.count,
+        open_warning: Ops::Incident.open.where(severity: "warning").count,
+        open_total: Ops::Incident.open.count
+      }
+    end
+  end
+end

backend/app/controllers/admin/passwords_controller.rb

@@ -0,0 +1,30 @@
+module Admin
+  class PasswordsController < Admin::BaseController
+    def edit
+    end
+
+    def update
+      unless current_admin_account.authenticate(params[:current_password])
+        flash.now[:alert] = "Password attuale non corretta"
+        return render :edit, status: :unprocessable_entity
+      end
+
+      if params[:password].blank? || params[:password].length < 8
+        flash.now[:alert] = "La nuova password deve avere almeno 8 caratteri"
+        return render :edit, status: :unprocessable_entity
+      end
+
+      if params[:password] != params[:password_confirmation]
+        flash.now[:alert] = "Le password non coincidono"
+        return render :edit, status: :unprocessable_entity
+      end
+
+      if current_admin_account.update(password: params[:password])
+        redirect_to admin_root_path, notice: "Password aggiornata"
+      else
+        flash.now[:alert] = current_admin_account.errors.full_messages.to_sentence
+        render :edit, status: :unprocessable_entity
+      end
+    end
+  end
+end

backend/app/controllers/admin/sessions_controller.rb

@@ -8,5 +8,36 @@ module Admin
       @session = StreamSession.find(params[:id])
       @events = @session.stream_events.recent.limit(50)
     end
+
+    def stop
+      @session = StreamSession.find(params[:id])
+      if @session.terminal?
+        redirect_to admin_session_path(@session), alert: "Sessione già terminata (#{@session.status})."
+        return
+      end
+
+      Sessions::Stop.new(@session).call
+      redirect_to admin_session_path(@session), notice: "Sessione terminata."
+    rescue StandardError => e
+      Rails.logger.error("[admin] stop session #{@session.id}: #{e.class} #{e.message}")
+      redirect_to admin_session_path(@session), alert: "Errore durante la chiusura: #{e.message}"
+    end
+
+    def regia_link
+      @session = StreamSession.find(params[:id])
+      if @session.terminal?
+        redirect_to admin_session_path(@session), alert: "Sessione terminata: impossibile generare il link regia."
+        return
+      end
+
+      access = Sessions::RegiaAccess.new(@session)
+      token = access.issue_token!
+      redirect_to admin_session_path(@session),
+                  notice: "Link regia generato.",
+                  flash: {
+                    regia_url: access.url(token),
+                    regia_expires_at: @session.regia_token_expires_at&.iso8601
+                  }
+    end
   end
 end

backend/app/controllers/admin/teams_controller.rb

@@ -1,7 +1,7 @@
 module Admin
   class TeamsController < Admin::BaseController
     def index
-      @teams = Team.all.order(:name)
+      redirect_to admin_clubs_path, status: :moved_permanently
     end
 
     def show

backend/app/controllers/admin/youtube_controller.rb

@@ -0,0 +1,13 @@
+module Admin
+  class YoutubeController < Admin::BaseController
+    def platform
+      if ENV["YOUTUBE_CLIENT_ID"].blank?
+        redirect_to admin_root_path, alert: "Configura YOUTUBE_CLIENT_ID e YOUTUBE_CLIENT_SECRET in .env"
+        return
+      end
+
+      state = Youtube::OauthState.for_platform(admin_id: current_admin_account.id)
+      redirect_to Youtube::OauthUrl.build(state: state), allow_other_host: true
+    end
+  end
+end

backend/app/controllers/api/v1/base_controller.rb

@@ -2,9 +2,17 @@ module Api
   module V1
     class BaseController < ApplicationController
       rescue_from Teams::EntitlementError, with: :render_entitlement_error
+      rescue_from Youtube::BroadcastService::Error, with: :render_youtube_error
 
       private
 
+      def render_youtube_error(error)
+        render json: {
+          error: "YouTube: #{error.message}",
+          error_code: "youtube_api_error"
+        }, status: :unprocessable_entity
+      end
+
       def render_entitlement_error(error)
         render json: {
           error: error.message,

backend/app/controllers/api/v1/invitations_controller.rb

@@ -0,0 +1,52 @@
+module Api
+  module V1
+    class InvitationsController < BaseController
+      skip_before_action :authenticate_request!, only: :show
+
+      def show
+        invitation = find_pending_invitation
+        unless invitation
+          return render json: { valid: false, error: "Invito non valido o scaduto" }, status: :not_found
+        end
+
+        render json: {
+          valid: true,
+          email: invitation.email,
+          team_id: invitation.team_id,
+          team_name: invitation.team.name,
+          club_name: invitation.team.club.name,
+          staff_kind: invitation.staff_kind,
+          expires_at: invitation.expires_at
+        }
+      end
+
+      def accept
+        invitation = find_pending_invitation
+        return render json: { error: "Invito non valido o scaduto" }, status: :not_found unless invitation
+
+        if current_user.email.downcase != invitation.email.downcase
+          return render json: {
+            error: "Questo invito è per #{invitation.email}. Accedi con quell'indirizzo email.",
+            invited_email: invitation.email
+          }, status: :unprocessable_entity
+        end
+
+        invitation.accept!(current_user)
+        render json: {
+          team_id: invitation.team_id,
+          team_name: invitation.team.name,
+          message: "Sei entrato in #{invitation.team.name} come responsabile trasmissione."
+        }
+      end
+
+      private
+
+      def find_pending_invitation
+        token = params[:token].to_s
+        return nil if token.blank?
+
+        TeamInvitation.pending.find_by(token_digest: Digest::SHA256.hexdigest(token))
+      end
+    end
+  end
+end

backend/app/controllers/api/v1/matches_controller.rb

@@ -1,18 +1,26 @@
 module Api
   module V1
     class MatchesController < BaseController
+      include Api::UrlHelper
+      include BrandingAttachments
+
       before_action :set_team, only: %i[index create]
       before_action :set_match, only: %i[show update destroy]
 
       def index
         matches = @team.matches
           .includes(:team, :stream_sessions)
-          .order(scheduled_at: :desc)
+          .order(Arel.sql("scheduled_at ASC NULLS LAST"), created_at: :desc)
+          .select(&:coach_hub_visible?)
         render json: matches.map { |m| match_json(m) }
       end
 
       def create
-        match = @team.matches.create!(match_params)
+        attrs = match_params.to_h
+        attrs["sport_key"] = @team.sport_key
+        normalize_scoring_rules!(attrs)
+        match = @team.matches.create!(attrs)
+        attach_opponent_logo(match)
         render json: match_json(match), status: :created
       end
 
@@ -21,7 +29,11 @@ module Api
       end
 
       def update
-        @match.update!(match_params)
+        attrs = match_params.to_h
+        normalize_scoring_rules!(attrs)
+        normalize_opponent_color!(attrs)
+        @match.update!(attrs)
+        attach_opponent_logo(@match)
         render json: match_json(@match)
       end
 
@@ -40,45 +52,86 @@ module Api
       private
 
       def set_team
-        @team = current_user.teams.find(params[:team_id])
+        @team = current_user.streamable_teams.find { |t| t.id == params[:team_id] }
+        raise ActiveRecord::RecordNotFound unless @team
       end
 
       def set_match
-        @match = Match.joins(:team).merge(current_user.teams).find(params[:id])
+        team_ids = current_user.streamable_teams.map(&:id)
+        @match = Match.includes(:team).where(team_id: team_ids).find(params[:id])
       end
 
       def match_params
-        params.require(:match).permit(
-          :opponent_name, :location, :scheduled_at, :sport, :sets_to_win,
-          :category, :phase, roster_numbers: [],
-          scoring_rules: %i[points_per_set points_deciding_set min_point_lead]
+        p = params.require(:match).permit(
+          :opponent_name, :location, :scheduled_at, :sport, :sport_key, :sets_to_win,
+          :category, :opponent_primary_color, :overlay_kind,
+          scoring_rules: {}
         )
+        if p[:sport].present? && p[:sport_key].blank?
+          p[:sport_key] = p.delete(:sport)
+        end
+        p[:overlay_kind] = nil if p.key?(:overlay_kind) && p[:overlay_kind].blank?
+        p
+      end
+
+      def normalize_scoring_rules!(attrs)
+        return unless attrs.key?("scoring_rules")
+
+        rules = attrs["scoring_rules"]
+        attrs["scoring_rules"] = {} if rules.blank?
+        if attrs["sets_to_win"].present? && attrs["scoring_rules"].is_a?(Hash)
+          attrs["scoring_rules"]["sets_to_win"] ||= attrs["sets_to_win"]
+        end
+      end
+
+      def normalize_opponent_color!(attrs)
+        return unless attrs.key?("opponent_primary_color")
+
+        attrs["opponent_primary_color"] = normalize_hex_color(
+          attrs["opponent_primary_color"],
+          Match::DEFAULT_OPPONENT_COLOR
+        )
+      end
+
+      def attach_opponent_logo(match)
+        file = params[:opponent_logo_file]
+        match.opponent_logo_file.attach(file) if file.present?
       end
 
       def match_json(match, detail: false)
         active = active_session_for(match)
+        team = match.team
         {
           id: match.id,
           team_id: match.team_id,
-          team_name: match.team.name,
+          team_name: team.name,
           opponent_name: match.opponent_name,
           location: match.location,
           scheduled_at: match.scheduled_at,
-          sport: match.sport,
+          sport: match.sport_key,
+          sport_key: match.sport_key,
+          sport_label: match.sport_label,
+          board_type: match.effective_board_type,
+          overlay_kind: match.overlay_kind,
+          effective_overlay_kind: match.effective_overlay_kind,
           sets_to_win: match.sets_to_win,
           scoring_rules: match.scoring_rules.presence,
-          roster_numbers: match.roster_numbers,
+          effective_scoring_rules: match.effective_scoring_rules,
           category: match.category,
-          phase: match.phase,
+          home_primary_color: team.effective_primary_color,
+          home_secondary_color: team.effective_secondary_color,
+          home_logo_url: api_absolute_url(team.effective_logo_url),
+          opponent_primary_color: match.effective_opponent_primary_color,
+          opponent_logo_url: api_absolute_url(match.opponent_logo_url),
           active_session_id: active&.id,
-          active_session_status: active&.status
+          active_session_status: active&.status,
+          stream_completed: match.stream_completed?,
+          coach_hub_visible: match.coach_hub_visible?
         }
       end
 
       def active_session_for(match)
-        match.stream_sessions
-             .order(created_at: :desc)
-             .find { |s| !%w[ended error].include?(s.status) }
+        match.active_stream_session
       end
     end
   end

backend/app/controllers/api/v1/recordings_controller.rb

@@ -0,0 +1,111 @@
+module Api
+  module V1
+    class RecordingsController < BaseController
+      before_action :set_recording
+
+      def update
+        authorize_manage!
+        attrs = recording_update_attrs
+        privacy_changed = attrs.key?(:privacy_status) && attrs[:privacy_status] != @recording.privacy_status
+        @recording.update!(attrs)
+        Recordings::SyncYoutubePrivacyJob.perform_async(@recording.id) if privacy_changed && @recording.youtube_video_id.present?
+        render json: recording_json(@recording)
+      end
+
+      def destroy
+        authorize_manage!
+        Recordings::Delete.new(@recording).call
+        head :no_content
+      end
+
+      def download
+        url = Recordings::DownloadUrl.new(@recording, viewer: current_user).call
+        render json: { download_url: url, expires_in_seconds: MatchLiveTv.replay_download_url_ttl_seconds }
+      rescue Recordings::DownloadUrl::NotAllowed
+        render json: { error: "Download non disponibile per il tuo piano", error_code: "download_not_allowed" },
+               status: :forbidden
+      rescue ArgumentError => e
+        render json: { error: e.message }, status: :unprocessable_entity
+      end
+
+      def publish_youtube
+        authorize_manage!
+        ent = @recording.team.entitlements
+        unless ent.premium_full? && ent.youtube_enabled?
+          return render json: { error: "Republicazione YouTube con Premium Full" }, status: :forbidden
+        end
+
+        Recordings::PublishToYoutubeJob.perform_async(@recording.id)
+        render json: { queued: true, message: "Pubblicazione su YouTube in corso" }
+      end
+
+      private
+
+      def set_recording
+        team_ids = current_user.manageable_teams.map(&:id)
+        @recording = Recording.not_deleted
+                              .includes(stream_session: :match)
+                              .where(team_id: team_ids)
+                              .find(params[:id])
+      end
+
+      def authorize_manage!
+        team = @recording.team
+        return if team.club.owned_by?(current_user)
+        return if current_user.manageable_teams.exists?(id: team.id)
+
+        render json: { error: "Non autorizzato" }, status: :forbidden
+      end
+
+      def recording_update_attrs
+        p = params.require(:recording).permit(:privacy_status, :title)
+        p = p.to_h
+        p[:privacy_status] = "unlisted" if p[:privacy_status] == "private"
+        if params.dig(:recording, :metadata).present?
+          p[:metadata] = @recording.metadata.merge(
+            params[:recording][:metadata].to_unsafe_h.stringify_keys
+          )
+        end
+        p
+      end
+
+      def recording_json(recording)
+        session = recording.stream_session
+        match = session.match
+        ent = recording.team.entitlements
+        {
+          id: recording.id,
+          session_id: session.id,
+          match_id: match.id,
+          title: recording.title_or_default,
+          opponent_name: match.opponent_name,
+          team_name: match.team.name,
+          team_id: recording.team_id,
+          status: recording.status,
+          status_label: recording.status_label,
+          privacy_status: recording.privacy_status,
+          ended_at: session.ended_at,
+          recorded_at: recording.recorded_at_or_fallback,
+          duration_secs: recording.duration_secs,
+          duration_label: recording.duration_label,
+          byte_size: recording.byte_size,
+          byte_size_label: recording.byte_size_label,
+          view_count: recording.view_count,
+          views_label: recording.views_label,
+          replay_url: recording.replay_url,
+          playback_url: recording.playback_stream_url,
+          thumbnail_url: recording.thumbnail_url,
+          download_enabled: ent.phone_download_enabled?,
+          youtube_video_id: recording.youtube_video_id,
+          youtube_watch_url: recording.youtube_watch_url,
+          youtube_publish_enabled: ent.premium_full? && ent.youtube_enabled?,
+          source_platform: recording.source_platform,
+          source_platform_label: recording.source_platform_label,
+          expires_at: recording.expires_at,
+          days_until_expiry: recording.days_until_expiry,
+          metadata: recording.metadata
+        }
+      end
+    end
+  end
+end

backend/app/controllers/api/v1/sports_controller.rb

@@ -0,0 +1,9 @@
+module Api
+  module V1
+    class SportsController < BaseController
+      def index
+        render json: ::Sports::Catalog.as_api_list
+      end
+    end
+  end
+end

backend/app/controllers/api/v1/stream_sessions_controller.rb

@@ -4,7 +4,8 @@ module Api
       before_action :set_session, except: :create
 
       def create
-        match = Match.joins(:team).merge(current_user.teams).find(params[:match_id])
+        team_ids = current_user.streamable_teams.map(&:id)
+        match = Match.where(team_id: team_ids).find(params[:match_id])
         session = Sessions::Create.new(user: current_user, match: match, params: session_params).call
         render json: session_json(session), status: :created
       end
@@ -28,6 +29,30 @@ module Api
         render json: session_json(@session)
       end
 
+      def resume
+        Sessions::Resume.new(@session).call
+        render json: session_json(@session)
+      end
+
+      def score
+        Scoring::SyncState.new(session: @session, payload: score_sync_params).call
+        render json: session_json(@session, detail: true)
+      end
+
+      def score_action
+        action = params[:score_action].presence
+        raise ArgumentError, "Azione mancante" if action.blank?
+
+        result = Scoring::ApplyAction.new(session: @session, action: action).call
+        render json: session_json(@session, detail: true).merge(
+          set_won: result.set_won,
+          match_won: result.match_won,
+          winner: result.winner&.to_s
+        )
+      rescue ArgumentError => e
+        render json: { error: e.message }, status: :unprocessable_entity
+      end
+
       def events
         events = @session.stream_events.recent.limit(100)
         render json: events.map { |e| event_json(e) }
@@ -45,6 +70,7 @@ module Api
           fps: params[:fps],
           last_seen_at: Time.current
         )
+        sync_publisher_when_streaming!(params[:fps].to_f)
         SessionChannel.broadcast_message(@session, state.as_cable_payload)
         head :no_content
       end
@@ -66,6 +92,15 @@ module Api
         }
       end
 
+      def regia_link
+        access = Sessions::RegiaAccess.new(@session)
+        token = access.issue_token!
+        render json: {
+          regia_url: access.url(token),
+          expires_at: @session.regia_token_expires_at
+        }
+      end
+
       def claim_pairing
         token = params.require(:pairing_token)
         digest = Digest::SHA256.hexdigest(token)
@@ -79,13 +114,31 @@ module Api
       end
 
       def network_test
+        upload_mbps = params[:upload_mbps].to_f
+        preset = Sessions::SelectQuality.call(upload_mbps: upload_mbps)
+        @session.update!(
+          quality_preset: preset[:id],
+          target_bitrate: preset[:target_bitrate],
+          target_fps: preset[:target_fps]
+        )
         @session.stream_events.create!(
           event_type: "network_test",
-          metadata: params.permit(:download_mbps, :upload_mbps, :latency_ms, :network_type).to_h,
+          metadata: params.permit(:download_mbps, :upload_mbps, :latency_ms, :network_type)
+            .to_h.merge(
+              "quality_preset" => preset[:id],
+              "target_bitrate" => preset[:target_bitrate]
+            ),
           occurred_at: Time.current
         )
-        ready = params[:upload_mbps].to_f >= (@session.target_bitrate / 1_000_000.0 * 0.8)
-        render json: { ready: ready, target_upload_mbps: @session.target_bitrate / 1_000_000.0 }
+        target_upload = preset[:target_bitrate] / 1_000_000.0
+        ready = upload_mbps >= (target_upload * Sessions::SelectQuality::UPLOAD_HEADROOM)
+        render json: {
+          ready: ready,
+          target_upload_mbps: target_upload,
+          quality_preset: preset[:id],
+          target_bitrate: preset[:target_bitrate],
+          target_fps: preset[:target_fps]
+        }
       end
 
       def youtube_stats
@@ -101,13 +154,22 @@ module Api
       private
 
       def set_session
-        @session = StreamSession.joins(match: :team)
-                                .merge(current_user.teams)
+        team_ids = current_user.streamable_teams.map(&:id)
+        @session = StreamSession.joins(:match)
+                                .where(matches: { team_id: team_ids })
                                 .find(params[:id])
       end
 
       def session_params
-        params.permit(:platform, :privacy_status, :quality_preset, :target_bitrate, :target_fps)
+        params.permit(:platform, :privacy_status, :quality_preset, :target_bitrate, :target_fps, :youtube_channel)
+      end
+
+      def score_sync_params
+        params.permit(
+          :home_sets, :away_sets, :home_points, :away_points, :current_set,
+          :clock_secs, :clock_running, :period, :home_score, :away_score, :overtime,
+          set_partials: %i[set home away]
+        )
       end
 
       def session_json(session, detail: false)
@@ -118,8 +180,11 @@ module Api
           platform: session.platform,
           rtmp_ingest_url: session.rtmp_ingest_url,
           hls_playback_url: session.hls_playback_url,
-          watch_page_url: session.watch_page_url,
+          watch_page_url: session.matchlivetv_platform? ? session.watch_page_url : nil,
+          share_url: session.share_url,
+          youtube_watch_url: session.youtube_watch_url,
           youtube_broadcast_id: session.youtube_broadcast_id,
+          youtube_ready: session.youtube_ready?,
           privacy_status: session.privacy_status,
           quality_preset: session.quality_preset,
           target_bitrate: session.target_bitrate,
@@ -141,6 +206,19 @@ module Api
           occurred_at: event.occurred_at
         }
       end
+
+      # L'app invia fps ogni ~10s; poll status.json per allineare stato sessione e relay YouTube.
+      def sync_publisher_when_streaming!(fps)
+        return if fps < 1
+        return if @session.terminal? || @session.paused?
+        return unless @session.platform == "youtube"
+        return unless @session.status.in?(%w[connecting live reconnecting])
+
+        Mediamtx::PublisherSync.new(@session).call
+        if @session.platform == "youtube" && @session.status.in?(%w[live connecting reconnecting])
+          Mediamtx::PublisherSync.schedule_youtube_pipeline!(@session, force: false)
+        end
+      end
     end
   end
 end

backend/app/controllers/api/v1/teams_controller.rb

@@ -1,31 +1,38 @@
 module Api
   module V1
     class TeamsController < BaseController
+      include Api::UrlHelper
+      include BrandingAttachments
+
       def index
-        teams = current_user.teams.includes(:matches)
+        teams = current_user.streamable_teams
         render json: teams.map { |t| team_json(t) }
       end
 
       def show
-        team = current_user.teams.find(params[:id])
+        team = current_user.manageable_teams.find(params[:id])
         render json: team_json(team, detail: true)
       end
 
       def create
-        if current_user.user_teams.where(role: "owner").count >= 1
+        if current_user.owned_clubs.exists?
           return render json: {
-            error: "Puoi gestire una sola squadra. Usa il sito per inviti o contattaci."
+            error: "Registra o gestisci la società dal sito web per aggiungere squadre."
           }, status: :unprocessable_entity
         end
 
-        team = Team.create!(team_params)
-        UserTeam.create!(user: current_user, team: team, role: "owner")
-        Billing::AssignPlan.call(team: team, plan_slug: "free")
+        sport_key = ::Sports::Catalog.normalize_key(team_params[:sport_key] || team_params[:sport] || "pallavolo")
+        club = Club.create!(name: team_params[:name], sport: sport_key,
+                            primary_color: "#e53935", secondary_color: "#ffffff")
+        ClubMembership.create!(user: current_user, club: club, role: "owner")
+        team = club.teams.create!(name: team_params[:name], sport_key: sport_key)
+        Billing::AssignPlan.call(club: club, plan_slug: "free")
         render json: team_json(team), status: :created
       end
 
       def recordings
-        team = current_user.teams.find(params[:id])
+        team = current_user.streamable_teams.find { |t| t.id.to_s == params[:id].to_s }
+        raise ActiveRecord::RecordNotFound unless team
         unless team.entitlements.can_access_recordings?
           return render json: {
             error: "Archivio gare disponibile con Premium Light o Full",
@@ -34,18 +41,24 @@ module Api
           }, status: :forbidden
         end
 
-        recs = team.recordings.ready.includes(stream_session: :match).order(created_at: :desc).limit(50)
+        recs = team.recordings.not_deleted
+                    .where(status: %w[ready processing])
+                    .where("expires_at IS NULL OR expires_at > ?", Time.current)
+                    .includes(stream_session: :match)
+                    .order(recorded_at: :desc, created_at: :desc)
+                    .limit(50)
         render json: recs.map { |r| recording_json(r) }
       end
 
       def update
-        team = current_user.teams.find(params[:id])
+        team = current_user.manageable_teams.find(params[:id])
         team.update!(team_params)
+        attach_team_logo(team)
         render json: team_json(team)
       end
 
       def add_member
-        team = current_user.teams.find(params[:id])
+        team = current_user.manageable_teams.find(params[:id])
         team.entitlements.assert_can_invite!
         member = User.find(params[:user_id])
         UserTeam.find_or_create_by!(user: member, team: team) { |ut| ut.role = "member" }
@@ -53,7 +66,7 @@ module Api
       end
 
       def remove_member
-        team = current_user.teams.find(params[:id])
+        team = current_user.manageable_teams.find(params[:id])
         ut = team.user_teams.find_by!(user_id: params[:user_id], role: "member")
         ut.destroy!
         head :no_content
@@ -62,17 +75,48 @@ module Api
       private
 
       def team_params
-        params.require(:team).permit(:name, :sport, :logo_url)
+        p = params.require(:team).permit(:name, :sport, :sport_key, :logo_url, :primary_color, :secondary_color)
+        if p[:sport].present? && p[:sport_key].blank?
+          p[:sport_key] = p.delete(:sport)
+        end
+        p
+        if p[:primary_color].present?
+          p[:primary_color] = normalize_hex_color(p[:primary_color], p[:primary_color])
+        end
+        if p[:secondary_color].present?
+          p[:secondary_color] = normalize_hex_color(p[:secondary_color], p[:secondary_color])
+        end
+        p
+      end
+
+      def attach_team_logo(team)
+        file = params[:logo_file]
+        team.logo_file.attach(file) if file.present?
       end
 
       def team_json(team, detail: false)
         ent = team.entitlements
+        yt = Youtube::TeamStatus.new(team)
+        resolver = Youtube::CredentialResolver.new(team)
         data = {
           id: team.id,
           name: team.name,
-          sport: team.sport,
-          logo_url: team.logo_url,
-          youtube_connected: team.youtube_credential.present?,
+          sport: team.sport_key,
+          sport_key: team.sport_key,
+          sport_label: team.sport_label,
+          board_type: team.effective_board_type,
+          logo_url: api_absolute_url(team.effective_logo_url),
+          primary_color: team.effective_primary_color,
+          secondary_color: team.effective_secondary_color,
+          club_id: team.club_id,
+          club_name: team.club.name,
+          youtube_connected: yt.connected?,
+          youtube_selectable: yt.selectable?,
+          youtube_channel_title: yt.channel_title,
+          youtube_uses_platform_channel: yt.uses_platform_channel?,
+          youtube_platform_available: resolver.platform_available?,
+          youtube_team_channel_available: resolver.team_channel_available?,
+          youtube_team_channel_title: team.club.youtube_credential&.channel_title,
           plan_slug: ent.plan.slug,
           plan_name: ent.plan.name,
           premium_active: ent.premium_active?,
@@ -83,16 +127,17 @@ module Api
           staff_manage_url: ent.staff_manage_url,
           max_staff: ent.max_staff,
           max_staff_transmission: ent.max_staff_transmission,
-          max_staff_regia: ent.max_staff_regia,
           staff_used: ent.staff_count,
           staff_transmission_used: ent.staff_count_for("transmission"),
-          staff_regia_used: ent.staff_count_for("regia"),
           concurrent_streams_used: ent.concurrent_streams_used,
           concurrent_streams_limit: ent.concurrent_streams_limit,
           recordings_enabled: ent.can_access_recordings?,
           phone_download_enabled: ent.phone_download_enabled?,
           youtube_enabled: ent.youtube_enabled?,
-          youtube_mode: ent.plan.youtube_mode
+          youtube_mode: ent.plan.youtube_mode,
+          staff_role: current_user.staff_role_for(team),
+          can_stream: current_user.can_stream_for?(team),
+          can_connect_youtube: team.club.owned_by?(current_user) && ent.premium_full? && ent.youtube_enabled?
         }
         if detail
           data[:members] = team.user_teams.includes(:user).where.not(role: "owner").map do |ut|
@@ -105,16 +150,37 @@ module Api
       def recording_json(recording)
         session = recording.stream_session
         match = session.match
+        ent = recording.team.entitlements
         {
           id: recording.id,
           session_id: session.id,
           match_id: match.id,
+          title: recording.title_or_default,
           opponent_name: match.opponent_name,
           team_name: match.team.name,
+          status: recording.status,
+          status_label: recording.status_label,
+          privacy_status: recording.privacy_status,
           ended_at: session.ended_at,
+          recorded_at: recording.recorded_at_or_fallback,
+          duration_secs: recording.duration_secs,
+          duration_label: recording.duration_label,
+          byte_size: recording.byte_size,
+          byte_size_label: recording.byte_size_label,
           replay_url: recording.replay_url,
-          download_url: recording.replay_url,
-          expires_at: recording.expires_at
+          playback_url: recording.playback_stream_url,
+          thumbnail_url: recording.thumbnail_url,
+          download_enabled: ent.phone_download_enabled?,
+          view_count: recording.view_count,
+          views_label: recording.views_label,
+          youtube_video_id: recording.youtube_video_id,
+          youtube_watch_url: recording.youtube_watch_url,
+          youtube_publish_enabled: ent.premium_full? && ent.youtube_enabled?,
+          source_platform: recording.source_platform,
+          source_platform_label: recording.source_platform_label,
+          expires_at: recording.expires_at,
+          days_until_expiry: recording.days_until_expiry,
+          metadata: recording.metadata
         }
       end
     end

backend/app/controllers/api/v1/youtube_controller.rb

@@ -2,24 +2,21 @@ module Api
   module V1
     class YoutubeController < BaseController
       def authorize
-        team = current_user.teams.find(params[:team_id])
-        team.entitlements.assert_can_connect_youtube!
-        url = Youtube::OauthUrl.build(team_id: team.id, redirect_uri: ENV.fetch("YOUTUBE_REDIRECT_URI"))
-        render json: { authorization_url: url }
-      end
+        team = current_user.streamable_teams.find { |t| t.id.to_s == params[:team_id].to_s }
+        raise ActiveRecord::RecordNotFound unless team
+        unless team.club.owned_by?(current_user)
+          return render json: { error: "Solo il titolare della società può collegare YouTube" }, status: :forbidden
+        end
 
-      def callback
-        team = current_user.teams.find(params[:state])
-        tokens = Youtube::OauthExchange.call(params[:code])
-        cred = team.youtube_credential || team.build_youtube_credential
-        cred.update!(
-          access_token: tokens[:access_token],
-          refresh_token: tokens[:refresh_token],
-          expires_at: Time.current + tokens[:expires_in].seconds,
-          channel_id: tokens[:channel_id],
-          channel_title: tokens[:channel_title]
+        team.entitlements.assert_can_connect_youtube!
+        return_app = ActiveModel::Type::Boolean.new.cast(params[:return_app])
+        state = Youtube::OauthState.for_team(
+          team_id: team.id,
+          user_id: current_user.id,
+          return_app: return_app
         )
-        redirect_to "/admin/teams/#{team.id}?youtube=connected"
+        url = Youtube::OauthUrl.build(state: state, redirect_uri: ENV.fetch("YOUTUBE_REDIRECT_URI"))
+        render json: { authorization_url: url, return_app: return_app }
       end
     end
   end

backend/app/controllers/concerns/api/url_helper.rb

@@ -0,0 +1,16 @@
+module Api
+  module UrlHelper
+    extend ActiveSupport::Concern
+
+    private
+
+    def api_absolute_url(path_or_url)
+      return nil if path_or_url.blank?
+      return path_or_url if path_or_url.match?(/\Ahttps?:\/\//i)
+
+      base = request.base_url
+      path = path_or_url.start_with?("/") ? path_or_url : "/#{path_or_url}"
+      "#{base}#{path}"
+    end
+  end
+end

backend/app/controllers/concerns/branding_attachments.rb

@@ -0,0 +1,16 @@
+module BrandingAttachments
+  extend ActiveSupport::Concern
+
+  private
+
+  def attach_branding_logo(record)
+    file = params.dig(:branding, :logo_file)
+    record.logo_file.attach(file) if file.present?
+  end
+
+  def normalize_hex_color(value, fallback)
+    v = value.to_s.strip
+    v = "##{v}" if v.match?(/\A[0-9A-Fa-f]{6}\z/)
+    v.match?(Brandable::HEX_COLOR) ? v : fallback
+  end
+end

backend/app/controllers/concerns/mediamtx_playback.rb

@@ -0,0 +1,34 @@
+module MediamtxPlayback
+  extend ActiveSupport::Concern
+
+  private
+
+  def mediamtx_paths_index
+    @mediamtx_paths_index ||= Mediamtx::Client.new.list_paths.index_by { |i| i["name"] }
+  end
+
+  def mediamtx_path_info(session, path_name: mediamtx_playback_path_name(session))
+    mediamtx_paths_index[path_name]
+  end
+
+  def mediamtx_playback_path_name(session)
+    session.effective_hls_path_name
+  end
+
+  # Player HLS: path grezzo MediaMTX (live/match_{uuid}).
+  def mediamtx_stream_playable?(session)
+    return false if session.terminal?
+
+    mediamtx_path_has_output?(session)
+  end
+
+  def mediamtx_path_has_output?(session)
+    info = mediamtx_path_info(session)
+    info && (info["ready"] || info["available"] || info["online"])
+  end
+
+  def mediamtx_publisher_online?(session)
+    info = mediamtx_paths_index[session.mediamtx_path_name]
+    info && info["online"]
+  end
+end

backend/app/controllers/concerns/recordings/club_archive_actions.rb

@@ -0,0 +1,123 @@
+module Recordings
+  module ClubArchiveActions
+    extend ActiveSupport::Concern
+    include RecordingsArchiveHelper
+
+    included do
+      before_action :set_club
+      before_action :set_recording, only: %i[update destroy publish_youtube]
+    end
+
+    def index
+      load_archive
+    end
+
+    def update
+      if admin_expiry_update_requested?
+        apply_admin_expiry_update!
+        return
+      end
+
+      permitted = recording_update_params
+      attrs = {}
+      privacy = permitted[:privacy_status]
+      attrs[:privacy_status] = privacy if privacy.in?(Recording::PRIVACY_STATUSES)
+      title = permitted[:title]
+      attrs[:title] = title if title.present?
+      privacy_changed = attrs.key?(:privacy_status) && attrs[:privacy_status] != @recording.privacy_status
+      @recording.update!(attrs)
+      Recordings::SyncYoutubePrivacyJob.perform_async(@recording.id) if privacy_changed && @recording.youtube_video_id.present?
+      redirect_to archive_index_path, notice: "Replay aggiornato"
+    rescue ActiveRecord::RecordInvalid => e
+      redirect_to archive_index_path, alert: e.record.errors.full_messages.join(", ")
+    rescue Recordings::ExtendExpiry::Error => e
+      redirect_to archive_index_path, alert: e.message
+    end
+
+    def destroy
+      Recordings::Delete.new(@recording).call
+      redirect_to archive_index_path, notice: "Replay eliminato"
+    end
+
+    def publish_youtube
+      ent = @recording.team.entitlements
+      unless ent.premium_full? && ent.youtube_enabled?
+        redirect_to archive_index_path, alert: "Republicazione YouTube con Premium Full"
+        return
+      end
+
+      Recordings::PublishToYoutubeJob.perform_async(@recording.id)
+      redirect_to archive_index_path, notice: "Pubblicazione su YouTube avviata"
+    end
+
+    private
+
+    def load_archive
+      archive = Recordings::ClubArchive.new(@club, params: params)
+      @stats = archive.stats
+      @recordings = archive.recordings
+      @teams = archive.teams
+      @filter_team_id = archive.filter_team_id
+      @filter_status = archive.filter_status
+      @archive_paths = recordings_archive_paths(@club, namespace: archive_namespace)
+      @archive_filter_params = archive.filter_params
+    end
+
+    def archive_index_path
+      archive_paths.index + archive_query_string
+    end
+
+    def archive_query_string
+      q = @archive_filter_params.presence
+      return "" if q.blank?
+
+      "?#{q.to_query}"
+    end
+
+    def archive_paths
+      @archive_paths ||= recordings_archive_paths(@club, namespace: archive_namespace)
+    end
+
+    def set_club
+      @club = Club.find(params[:club_id])
+    end
+
+    def set_recording
+      @recording = Recording.for_club(@club).not_deleted.find(params[:id])
+      authorize_recording_management!
+    end
+
+    def authorize_recording_management!
+      # overridden in Public::ClubRecordingsController
+    end
+
+    def archive_namespace
+      raise NotImplementedError
+    end
+
+    def recording_update_params
+      params.require(:recording).permit(:privacy_status, :title, :expires_at, :extend_days)
+    end
+
+    def admin_expiry_update_requested?
+      return false unless archive_namespace == :admin
+
+      permitted = recording_update_params
+      permitted[:extend_days].present? || permitted[:expires_at].present?
+    end
+
+    def apply_admin_expiry_update!
+      permitted = recording_update_params
+      extender = Recordings::ExtendExpiry.new(@recording)
+
+      if permitted[:extend_days].present?
+        extender.by_days(permitted[:extend_days])
+        redirect_to archive_index_path, notice: "Scadenza replay prolungata di #{permitted[:extend_days].to_i} giorni"
+      else
+        expires_at = Time.zone.parse(permitted[:expires_at].to_s)&.end_of_day
+        extender.to_time(expires_at)
+        redirect_to archive_index_path, notice: "Scadenza replay aggiornata"
+      end
+    end
+  end
+end

backend/app/controllers/hls_proxy_controller.rb

@@ -1,38 +1,98 @@
 class HlsProxyController < ActionController::Base
-  # Proxy pubblico verso MediaMTX HLS (NPM inoltra tutto a Rails :3000).
+  # Proxy pubblico verso MediaMTX HLS.
+  # Dev: tutto passa da Rails (/hls/*).
+  # Prod: edge inoltra /hls/ a MediaMTX; il redirect cookie di MediaMTX punta a
+  # /live/match_{uuid}/… che deve essere gestito da #live_match (fallback).
   def show
-    upstream_path = params[:path].to_s
+    proxy_mediamtx_path(params[:path].to_s)
+  end
+
+  def live_match
+    session_id = params[:session_id].to_s
+    return head :not_found unless session_id.match?(/\A[0-9a-f-]{36}\z/i)
+
+    segments = params[:segments].presence || "index.m3u8"
+    proxy_mediamtx_path("live/match_#{session_id}/#{segments}")
+  end
+
+  private
+
+  def proxy_mediamtx_path(upstream_path)
     return head :not_found if upstream_path.blank?
 
     upstream = "#{MatchLiveTv.mediamtx_hls_url}/#{upstream_path}"
     upstream = "#{upstream}?#{request.query_string}" if request.query_string.present?
     cookie = request.headers["Cookie"].presence || "cookieCheck=1"
-    response = hls_conn.get(upstream) { |req| req.headers["Cookie"] = cookie }
 
-    if response.status == 302
-      location = response.headers["location"].to_s
-      follow_url = if location.start_with?("http")
-                     location
-                   else
-                     "#{MatchLiveTv.mediamtx_hls_url.sub(%r{/$}, "")}#{location}"
-                   end
-      set_cookie = response.headers["set-cookie"].to_s
-      cookie = set_cookie.presence || cookie
-      response = hls_conn.get(follow_url) { |req| req.headers["Cookie"] = cookie }
+    5.times do
+      response = hls_conn.get(upstream) { |req| req.headers["Cookie"] = cookie }
+
+      if response.status.in?([301, 302, 307, 308])
+        location = response.headers["location"].to_s
+        cookie = cookie_from_set_header(response.headers["set-cookie"]).presence || cookie
+        upstream = resolve_upstream_url(location)
+        next
+      end
+
+      return render_proxied_response(response)
     end
 
-    response.headers.each do |key, value|
-      next if %w[transfer-encoding connection].include?(key.downcase)
-
-      headers[key] = value
-    end
-    render body: response.body, status: response.status
+    head :bad_gateway
   rescue Faraday::Error => e
     Rails.logger.warn("[HlsProxy] #{upstream_path}: #{e.message}")
     head :bad_gateway
   end
 
-  private
+  def resolve_upstream_url(location)
+    return location if location.start_with?("http://", "https://")
+
+    base = MatchLiveTv.mediamtx_hls_url.sub(%r{/$}, "")
+    location.start_with?("/") ? "#{base}#{location}" : "#{base}/#{location}"
+  end
+
+  def render_proxied_response(response)
+    body = response.body.to_s
+    content_type = response.headers["content-type"].to_s
+
+    if m3u8_playlist?(content_type, body)
+      public_hls_base = "#{request.base_url}/hls"
+      body = body.gsub(%r{(?<=["'(\s])/live/(match_[0-9a-f-]{36}/)}, "/hls/live/\\1")
+      body = body.gsub(%r{\A/live/(match_[0-9a-f-]{36}/)}, "/hls/live/\\1")
+    end
+
+    response.headers.each do |key, value|
+      next if %w[transfer-encoding connection content-length content-encoding].include?(key.downcase)
+
+      if key.downcase == "location"
+        headers[key] = rewrite_public_location(value)
+      else
+        headers[key] = value
+      end
+    end
+
+    render body: body, status: response.status, content_type: content_type.presence
+  end
+
+  def rewrite_public_location(location)
+    loc = location.to_s
+    if loc.start_with?("/live/match_")
+      return loc.sub(%r{\A/live/}, "/hls/")
+    end
+    if loc.include?("/live/match_")
+      return loc.gsub(%r{/(live/match_[0-9a-f-]{36}/)}, "/hls/live/\\1")
+    end
+    loc
+  end
+
+  def m3u8_playlist?(content_type, body)
+    return true if content_type.include?("mpegurl") || content_type.include?("m3u8")
+
+    body.lstrip.start_with?("#EXTM3U")
+  end
+
+  def cookie_from_set_header(set_cookie_header)
+    set_cookie_header.to_s[/cookieCheck=[^;]+/]
+  end
 
   def hls_conn
     @hls_conn ||= Faraday.new do |f|

backend/app/controllers/ops/health_controller.rb

@@ -0,0 +1,28 @@
+module Ops
+  class HealthController < ActionController::API
+    before_action :authorize_deep_health!
+
+    def show
+      summary = Ops::HealthChecks.new.summary
+      status_code = case summary[:status]
+                    when "ok" then :ok
+                    when "degraded" then :service_unavailable
+                    else :service_unavailable
+                    end
+
+      render json: summary, status: status_code
+    end
+
+    private
+
+    def authorize_deep_health!
+      token = ENV["OPS_HEALTH_TOKEN"].presence
+      return if token.blank?
+
+      provided = request.headers["X-Ops-Token"].presence || params[:token].presence
+      return head :unauthorized if provided.blank?
+
+      head :unauthorized unless ActiveSupport::SecurityUtils.secure_compare(provided, token)
+    end
+  end
+end

backend/app/controllers/public/club_billing_controller.rb

@@ -0,0 +1,93 @@
+module Public
+  class ClubBillingController < WebBaseController
+    before_action :require_login!
+    before_action :set_club
+    before_action :require_club_owner_for_club!
+
+    def profile
+    end
+
+    def update_profile
+      @club.assign_attributes(billing_profile_params)
+      if @club.save(context: :billing_profile)
+        if premium_checkout_return_params.present? && @club.billing_profile_complete?
+          redirect_to public_club_checkout_path(
+            @club,
+            plan: premium_checkout_return_params[:plan],
+            interval: premium_checkout_return_params[:interval]
+          ), notice: "Dati salvati. Procedi con il pagamento."
+        else
+          redirect_to public_club_billing_path(@club), notice: "Dati di fatturazione aggiornati."
+        end
+      else
+        flash.now[:alert] = @club.errors.full_messages.join(", ")
+        render :profile, status: :unprocessable_entity
+      end
+    end
+
+    def cancel_subscription
+      unless MatchLiveTv.stripe_enabled?
+        redirect_to public_club_billing_path(@club), alert: "Stripe non configurato."
+        return
+      end
+
+      Billing::Stripe::CancelSubscription.call(club: @club)
+      sub = @club.subscription.reload
+      date = sub.current_period_end ? helpers.l_local(sub.current_period_end.to_date) : "fine periodo"
+      redirect_to public_club_billing_path(@club),
+                  notice: "Abbonamento disdetto. Resta attivo fino al #{date}; da quel giorno passerai al piano Free."
+    rescue ArgumentError, RuntimeError => e
+      redirect_to public_club_billing_path(@club), alert: e.message
+    rescue ::Stripe::StripeError => e
+      redirect_to public_club_billing_path(@club), alert: "Errore Stripe: #{e.message}"
+    end
+
+    def download_invoice
+      invoice = @club.billing_invoices.find(params[:invoice_id])
+      unless invoice.pdf.attached?
+        redirect_to public_club_billing_path(@club), alert: "PDF fattura non disponibile."
+        return
+      end
+
+      redirect_to rails_blob_path(invoice.pdf, disposition: "attachment"), allow_other_host: true
+    end
+
+    private
+
+    def set_club
+      @club = current_user.owned_clubs.find(params[:id])
+    end
+
+    def require_club_owner_for_club!
+      require_club_owner!(@club)
+    end
+
+    def premium_checkout_return_params
+      plan = params[:plan].presence_in(%w[premium_light premium_full])
+      return nil if plan.blank?
+
+      {
+        plan: plan,
+        interval: params[:interval].presence || Billing::Stripe::PriceCatalog::DEFAULT_INTERVAL
+      }
+    end
+
+    def billing_profile_params
+      params.require(:club).permit(
+        :billing_entity_type,
+        :billing_legal_name,
+        :billing_vat_number,
+        :billing_fiscal_code,
+        :billing_email,
+        :billing_phone,
+        :billing_address_line,
+        :billing_city,
+        :billing_province,
+        :billing_postal_code,
+        :billing_country,
+        :billing_recipient_code,
+        :billing_pec
+      )
+    end
+  end
+end

backend/app/controllers/public/club_matches_controller.rb

@@ -0,0 +1,85 @@
+module Public
+  class ClubMatchesController < WebBaseController
+    before_action :require_login!
+    before_action :set_club
+    before_action :load_schedulable_teams
+    before_action :require_any_schedulable_team!
+
+    def new
+      @match = default_match_for_form
+      @selected_team = resolve_selected_team
+    end
+
+    def create
+      @selected_team = @schedulable_teams.find { |t| t.id.to_s == params[:team_id].to_s }
+      unless @selected_team
+        @match = default_match_for_form
+        flash.now[:alert] = "Seleziona una squadra valida."
+        return render :new, status: :unprocessable_entity
+      end
+
+      @match = @selected_team.matches.create!(
+        match_params.merge(sport: @selected_team.sport, sets_to_win: 3)
+      )
+      redirect_to public_live_index_path(club_id: @club.id),
+                  notice: "Partita programmata: #{@selected_team.name} vs #{@match.opponent_name}."
+    rescue ActiveRecord::RecordInvalid => e
+      @match = @selected_team.matches.build(match_params)
+      flash.now[:alert] = e.record.errors.full_messages.join(", ")
+      render :new, status: :unprocessable_entity
+    end
+
+    private
+
+    def set_club
+      @club = Club.find(params[:club_id])
+    end
+
+    def load_schedulable_teams
+      @schedulable_teams = current_user.schedulable_teams_for(@club)
+      @club_admin = @club.owned_by?(current_user)
+    end
+
+    def require_any_schedulable_team!
+      return if @schedulable_teams.any?
+
+      redirect_to public_live_index_path(club_id: @club.id),
+                  alert: "Non hai permessi per programmare partite in questa società."
+    end
+
+    def resolve_selected_team
+      if params[:team_id].present?
+        @schedulable_teams.find { |t| t.id.to_s == params[:team_id].to_s }
+      end || @schedulable_teams.first
+    end
+
+    def default_match_for_form
+      team = resolve_selected_team
+      Match.new(
+        sport: team&.sport || @club.sport,
+        sets_to_win: 3,
+        scheduled_at: default_scheduled_at
+      )
+    end
+
+    def match_params
+      p = params.require(:match).permit(:opponent_name, :location, :scheduled_at)
+      p[:scheduled_at] = parse_scheduled_at(p[:scheduled_at]) if p[:scheduled_at].present?
+      p
+    end
+
+    def parse_scheduled_at(value)
+      raw = value.to_s.strip
+      return nil if raw.blank?
+
+      Time.zone.strptime(raw, "%Y-%m-%dT%H:%M")
+    rescue ArgumentError
+      Time.zone.parse(raw)
+    end
+
+    def default_scheduled_at
+      t = Time.current + 2.hours
+      Time.zone.local(t.year, t.month, t.day, t.hour, 0, 0)
+    end
+  end
+end

backend/app/controllers/public/club_recordings_controller.rb

@@ -0,0 +1,28 @@
+module Public
+  class ClubRecordingsController < WebBaseController
+    include Recordings::ClubArchiveActions
+    helper RecordingsArchiveHelper
+
+    before_action :require_login!
+    before_action :require_club_recording_manager!
+
+    private
+
+    def archive_namespace
+      :public
+    end
+
+    def authorize_recording_management!
+      return if Recordings::AccessPolicy.new(@recording, viewer: current_user).manage_allowed?
+
+      raise ActiveRecord::RecordNotFound
+    end
+
+    def require_club_recording_manager!
+      return if current_user.owned_clubs.exists?(id: @club.id)
+      return if current_user.manageable_teams.joins(:club).exists?(clubs: { id: @club.id })
+
+      redirect_to public_clubs_path, alert: "Non autorizzato"
+    end
+  end
+end

backend/app/controllers/public/clubs_controller.rb

@@ -0,0 +1,246 @@
+module Public
+  class ClubsController < WebBaseController
+    include BrandingAttachments
+
+    before_action :require_login!
+    before_action :set_club, only: %i[show edit update billing checkout portal youtube_connect youtube_disconnect]
+    before_action :require_billing_profile_for_premium_checkout!, only: :checkout
+
+    def new
+      redirect_to public_club_path(current_user.primary_club) if current_user.primary_club
+    end
+
+    def create
+      if current_user.owned_clubs.exists?
+        redirect_to public_club_path(current_user.primary_club), alert: "Hai già registrato una società"
+        return
+      end
+
+      club = Club.new(club_params)
+      attach_branding_logo(club)
+      club.save!
+
+      ClubMembership.create!(user: current_user, club: club, role: "owner")
+
+      first_team_name = params.dig(:first_team, :name).presence || "Prima squadra"
+      club.teams.create!(
+        name: first_team_name,
+        sport: club.sport
+      )
+
+      plan = params[:plan].presence_in(%w[free premium_light premium_full]) || "free"
+      Billing::AssignPlan.call(club: club, plan_slug: plan)
+
+      if plan.in?(%w[premium_light premium_full]) && MatchLiveTv.stripe_enabled?
+        unless club.billing_profile_complete?
+          redirect_to public_club_billing_profile_path(club, plan: plan, interval: checkout_interval_param),
+                      alert: "Completa i dati di fatturazione prima di attivare un piano premium."
+          return
+        end
+
+        interval = checkout_interval_param
+        redirect_to public_club_checkout_path(club, plan: plan, interval: interval)
+      else
+        redirect_to public_club_path(club), notice: "Società e prima squadra create."
+      end
+    rescue ActiveRecord::RecordInvalid => e
+      flash.now[:alert] = e.record.errors.full_messages.join(", ")
+      render :new, status: :unprocessable_entity
+    end
+
+    def show
+      require_club_owner!(@club)
+      apply_checkout_flash!
+      @entitlements_team = @club.teams.first
+      @entitlements = @entitlements_team&.entitlements
+      @teams = @club.teams.order(:name)
+      @replay_stats = Recordings::ClubStats.new(@club).call if @entitlements&.can_access_recordings?
+    end
+
+    def edit
+      require_club_owner!(@club)
+    end
+
+    def update
+      require_club_owner!(@club)
+      @club.assign_attributes(club_params)
+      attach_branding_logo(@club)
+      @club.save!
+      redirect_to public_club_path(@club), notice: "Società aggiornata."
+    rescue ActiveRecord::RecordInvalid => e
+      flash.now[:alert] = e.record.errors.full_messages.join(", ")
+      render :edit, status: :unprocessable_entity
+    end
+
+    def billing
+      require_club_owner!(@club)
+      sync_checkout_return!
+      finalize_subscription_if_due!
+      @subscription = @club.subscription&.reload
+      apply_checkout_flash!
+      @team = @club.teams.first!
+      @entitlements = @team.entitlements
+      @plans = Plan.ordered
+      @payments = @club.billing_payments.recent.includes(:invoice).limit(50)
+    end
+
+    def checkout
+      require_club_owner!(@club)
+      if @club.subscription&.admin_comped?
+        redirect_to public_club_billing_path(@club),
+                    alert: "Il piano è un abbonamento omaggio gestito da Match Live TV. Per passare a un abbonamento a pagamento contatta il supporto."
+        return
+      end
+
+      unless MatchLiveTv.stripe_enabled?
+        redirect_to public_club_billing_path(@club), alert: "Pagamenti non ancora configurati sul server"
+        return
+      end
+
+      plan_slug = params[:plan].presence_in(%w[premium_light premium_full]) || "premium_light"
+      interval = checkout_interval_param
+      target_plan = Plan[plan_slug]
+      sub = @club.subscription
+
+      if sub&.stripe_subscription_id.present? && sub.active? &&
+         sub.plan.slug == plan_slug && sub.billing_interval == interval && !sub.plan_change_pending?
+        redirect_to public_club_billing_path(@club),
+                    notice: "Sei già su #{target_plan.name} (#{Billing::Stripe::PriceCatalog.label(plan_slug: plan_slug, interval: interval)})."
+        return
+      end
+
+      if sub&.plan_change_pending? && sub.pending_plan&.slug == plan_slug &&
+         sub.pending_billing_interval == interval
+        when_label = sub.current_period_end.present? ? I18n.l(sub.current_period_end, format: :long) : "il prossimo rinnovo"
+        redirect_to public_club_billing_path(@club),
+                    notice: "Il passaggio a #{target_plan.name} è già programmato dal #{when_label}."
+        return
+      end
+
+      if sub&.stripe_subscription_id.present? && sub.active?
+        result = Billing::Stripe::ChangePlan.call(club: @club, plan_slug: plan_slug, interval: interval)
+        redirect_to public_club_billing_path(@club),
+                    notice: Billing::Stripe::PlanChangeMessages.flash_notice(
+                      result,
+                      current_plan: sub.plan
+                    )
+      else
+        url = Billing::Stripe::CheckoutSession.new(
+          club: @club, user: current_user, plan_slug: plan_slug, interval: interval
+        ).url
+        redirect_to url, allow_other_host: true
+      end
+    rescue ArgumentError => e
+      redirect_to public_club_billing_path(@club), alert: e.message
+    rescue ::Stripe::StripeError => e
+      Rails.logger.warn("[Stripe checkout] #{e.message}")
+      redirect_to public_club_billing_path(@club), alert: "Errore Stripe: #{e.message}"
+    end
+
+    def youtube_connect
+      require_club_owner!(@club)
+      entitlements = @club.teams.first!.entitlements
+      entitlements.assert_can_connect_youtube!
+
+      if ENV["YOUTUBE_CLIENT_ID"].blank?
+        redirect_to public_club_path(@club), alert: "YouTube OAuth non configurato sul server"
+        return
+      end
+
+      return_app = params[:return_app] == "1"
+      state = Youtube::OauthState.for_club(
+        club_id: @club.id,
+        user_id: current_user.id,
+        return_app: return_app
+      )
+      redirect_to Youtube::OauthUrl.build(state: state), allow_other_host: true
+    rescue Teams::EntitlementError => e
+      redirect_to public_club_path(@club), alert: e.message
+    end
+
+    def youtube_disconnect
+      require_club_owner!(@club)
+      @club.youtube_credential&.destroy!
+      redirect_to public_club_path(@club), notice: "Canale YouTube della società scollegato"
+    end
+
+    def portal
+      require_club_owner!(@club)
+      unless MatchLiveTv.stripe_enabled?
+        redirect_to public_club_billing_path(@club), alert: "Portale pagamenti non configurato"
+        return
+      end
+
+      url = Billing::Stripe::CheckoutSession.new(club: @club, user: current_user).portal_url
+      redirect_to url, allow_other_host: true
+    end
+
+    private
+
+    def set_club
+      @club = current_user.owned_clubs.find(params[:id])
+    end
+
+    def club_params
+      p = params.require(:club).permit(
+        :name, :sport, :logo_url, :primary_color, :secondary_color,
+        :billing_entity_type, :billing_legal_name, :billing_vat_number, :billing_fiscal_code,
+        :billing_email, :billing_phone, :billing_address_line, :billing_city, :billing_province,
+        :billing_postal_code, :billing_country, :billing_recipient_code, :billing_pec
+      )
+      p[:primary_color] = normalize_hex_color(p[:primary_color], "#e53935")
+      p[:secondary_color] = normalize_hex_color(p[:secondary_color], "#ffffff")
+      p[:sport] = Sports::Catalog.normalize_key(p[:sport]) if p[:sport].present?
+      p
+    end
+
+    def require_billing_profile_for_premium_checkout!
+      require_club_owner!(@club)
+      plan_slug = params[:plan].presence_in(%w[premium_light premium_full])
+      return if plan_slug.blank?
+      return if @club.billing_profile_complete?
+
+      redirect_to public_club_billing_profile_path(
+        @club,
+        plan: plan_slug,
+        interval: params[:interval].presence
+      ), alert: "Completa i dati di fatturazione prima di attivare un piano premium."
+    end
+
+    def checkout_interval_param
+      Billing::Stripe::PriceCatalog.normalize_interval(params[:interval])
+    rescue ArgumentError
+      Billing::Stripe::PriceCatalog::DEFAULT_INTERVAL
+    end
+
+    def finalize_subscription_if_due!
+      return unless MatchLiveTv.stripe_enabled?
+
+      Billing::Stripe::FinalizeSubscription.call(club: @club)
+    rescue ::Stripe::StripeError => e
+      Rails.logger.warn("[Stripe finalize subscription] #{e.message}")
+    end
+
+    def sync_checkout_return!
+      return unless params[:checkout] == "success"
+      return unless MatchLiveTv.stripe_enabled?
+
+      Billing::Stripe::CheckoutSync.call(
+        club: @club,
+        session_id: params[:session_id].presence
+      )
+    rescue ::Stripe::StripeError => e
+      Rails.logger.warn("[Stripe checkout sync] #{e.message}")
+    end
+
+    def apply_checkout_flash!
+      case params[:checkout]
+      when "success"
+        plan_name = @subscription&.plan&.name || "premium"
+        flash.now[:notice] = "Pagamento completato! Piano attivo: #{plan_name}."
+      when "canceled"
+        flash.now[:alert] = "Pagamento annullato. Nessun addebito è stato effettuato."
+      end
+    end
+  end
+end

backend/app/controllers/public/invitations_controller.rb

@@ -18,7 +18,7 @@ module Public
           return
         end
         invitation.accept!(current_user)
-        redirect_to public_team_dashboard_path(invitation.team), notice: "Sei entrato nella squadra!"
+        redirect_to public_team_details_path(invitation.team), notice: "Sei entrato nella squadra!"
       else
         session[:pending_invite_token] = params[:token]
         redirect_to public_signup_path, notice: "Registrati con #{invitation.email} per accettare l'invito"

backend/app/controllers/public/live_controller.rb

@@ -1,47 +1,86 @@
 module Public
   class LiveController < SiteBaseController
+    include MediamtxPlayback
+
     layout "marketing_live"
 
     ACTIVE_STATUSES = %w[live connecting reconnecting].freeze
 
     def index
       @query = params[:q].to_s.strip
-      @sessions = StreamSession
+      @club = Club.find_by(id: params[:club_id]) if params[:club_id].present?
+      team_ids = @club&.teams&.pluck(:id)
+
+      sessions = StreamSession
         .broadcasting
-        .includes(:score_state, match: :team)
+        .publicly_listed
+        .where(platform: "matchlivetv")
+        .includes(:score_state, match: { team: :club })
+      sessions = sessions.joins(:match).where(matches: { team_id: team_ids }) if team_ids.present?
+
+      @sessions = sessions
         .search_by_team_or_opponent(@query)
         .order(Arel.sql("started_at DESC NULLS LAST"), created_at: :desc)
 
+      # Solo dirette già in onda: le partite «programmate» restano visibili anche se c’è sessione idle.
+      broadcasting_match_ids = StreamSession.broadcasting.select(:match_id)
+      upcoming = Match.scheduled_for_live.includes(team: :club)
+      upcoming = upcoming.where(team_id: team_ids) if team_ids.present?
+
+      @upcoming_matches = upcoming
+        .search_teams_or_opponents(@query)
+        .where.not(id: broadcasting_match_ids)
+        .order(scheduled_at: :asc)
+        .limit(50)
+
       @online_paths = Mediamtx::Client.new.online_path_names
+
+      return unless logged_in? && @club
+
+      @schedulable_teams = current_user.schedulable_teams_for(@club)
+      @can_schedule_match = @schedulable_teams.any?
     end
 
     def show
-      @session = StreamSession.includes(match: :team).find(params[:id])
+      @session = StreamSession.includes(match: { team: :club }).find(params[:id])
+      @session = Mediamtx::PublisherSync.new(@session).call unless @session.terminal?
       @match = @session.match
       @stream_closed = @session.terminal?
-      @on_air = !@stream_closed && mediamtx_online?(@session)
+      @on_air = !@stream_closed && (
+        mediamtx_stream_playable?(@session) ||
+        @session.status.in?(%w[connecting live reconnecting paused])
+      )
+      @publisher_online = !@stream_closed && mediamtx_publisher_online?(@session)
     end
 
     def status
-      session = StreamSession.includes(match: :team).find(params[:id])
+      # Mai cache: il tabellone deve restare allineato con l'app (poll ogni ~1,5s).
+      response.headers["Cache-Control"] = "no-store, no-cache, must-revalidate"
+      response.headers["Pragma"] = "no-cache"
+
+      session = StreamSession.includes(match: { team: :club }).find(params[:id])
+      session = Mediamtx::PublisherSync.new(session).call unless session.terminal?
       closed = session.terminal?
+      publisher_online = !closed && mediamtx_publisher_online?(session)
+      playable = !closed && mediamtx_stream_playable?(session)
       render json: {
         status: session.status,
+        paused: session.paused?,
         stream_closed: closed,
-        live: !closed && (session.live? || mediamtx_online?(session)),
-        on_air: !closed && mediamtx_online?(session),
+        live: !closed && (
+          session.live? || session.paused? || session.connecting? || session.reconnecting? ||
+          mediamtx_publisher_online?(session)
+        ),
+        on_air: playable || (!closed && session.status.in?(%w[connecting live reconnecting paused])),
+        publisher_online: publisher_online,
+        awaiting_signal: !closed && !mediamtx_path_has_output?(session),
+        showing_cover: !closed && mediamtx_path_has_output?(session) &&
+          (session.paused? || !mediamtx_publisher_online?(session)),
         ended_at: session.ended_at,
         home_name: session.match.team.name,
         away_name: session.match.opponent_name,
         score: session.score_state&.as_cable_payload
       }
     end
-
-    private
-
-    def mediamtx_online?(session)
-      @online_paths_cache ||= Mediamtx::Client.new.online_path_names
-      @online_paths_cache.include?(session.mediamtx_path_name)
-    end
   end
 end

backend/app/controllers/public/matches_controller.rb

@@ -0,0 +1,100 @@
+module Public
+  class MatchesController < WebBaseController
+    before_action :require_login!
+    before_action :set_team
+    before_action :require_can_schedule!
+    before_action :set_match, only: %i[edit update destroy]
+
+    def index
+      @matches = @team.matches
+        .includes(:stream_sessions)
+        .order(Arel.sql("scheduled_at ASC NULLS LAST"), created_at: :desc)
+      @can_manage = @team.club.owned_by?(current_user)
+    end
+
+    def new
+      @match = @team.matches.build(
+        sport: @team.sport,
+        sets_to_win: 3,
+        scheduled_at: default_scheduled_at
+      )
+    end
+
+    def create
+      @match = @team.matches.create!(
+        match_params.merge(sport: @team.sport, sets_to_win: match_params[:sets_to_win].presence || 3)
+      )
+      redirect_to public_team_matches_path(@team),
+                  notice: "Partita programmata: #{@match.opponent_name}. Avvia lo streaming dall’app quando sei in palestra."
+    rescue ActiveRecord::RecordInvalid => e
+      @match = @team.matches.build(match_params)
+      flash.now[:alert] = e.record.errors.full_messages.join(", ")
+      render :new, status: :unprocessable_entity
+    end
+
+    def edit
+    end
+
+    def update
+      @match.update!(match_params)
+      redirect_to public_team_matches_path(@team), notice: "Partita aggiornata."
+    rescue ActiveRecord::RecordInvalid => e
+      flash.now[:alert] = e.record.errors.full_messages.join(", ")
+      render :edit, status: :unprocessable_entity
+    end
+
+    def destroy
+      active = active_session_for(@match)
+      if active&.resumable?
+        redirect_to public_team_matches_path(@team),
+                    alert: "Chiudi la diretta prima di eliminare questa partita."
+        return
+      end
+
+      @match.destroy!
+      redirect_to public_team_matches_path(@team), notice: "Partita eliminata."
+    end
+
+    private
+
+    def set_team
+      @team = current_user.manageable_teams.find(params[:team_id])
+      @club = @team.club
+    end
+
+    def require_can_schedule!
+      return if current_user.can_schedule_for?(@team)
+
+      redirect_to public_team_details_path(@team),
+                  alert: "Solo un responsabile trasmissione o il titolare della società possono programmare le partite."
+    end
+
+    def set_match
+      @match = @team.matches.find(params[:id])
+    end
+
+    def match_params
+      p = params.require(:match).permit(:opponent_name, :location, :scheduled_at, :sport, :sets_to_win)
+      p[:scheduled_at] = parse_scheduled_at(p[:scheduled_at]) if p[:scheduled_at].present?
+      p
+    end
+
+    def parse_scheduled_at(value)
+      raw = value.to_s.strip
+      return nil if raw.blank?
+
+      Time.zone.strptime(raw, "%Y-%m-%dT%H:%M")
+    rescue ArgumentError
+      Time.zone.parse(raw)
+    end
+
+    def default_scheduled_at
+      t = Time.current + 2.hours
+      Time.zone.local(t.year, t.month, t.day, t.hour, 0, 0)
+    end
+
+    def active_session_for(match)
+      match.active_stream_session
+    end
+  end
+end

backend/app/controllers/public/pages_controller.rb

@@ -8,6 +8,20 @@ module Public
 
     def pricing
       @plans = Plan.ordered
+      load_club_billing_context_for_pricing
+    end
+
+    private
+
+    def load_club_billing_context_for_pricing
+      return unless logged_in?
+
+      @club = current_user.primary_club
+      return unless @club
+
+      @subscription = @club.subscription
+      @team = @club.teams.order(:name).first
+      @entitlements = @team&.entitlements
     end
 
     def privacy
@@ -15,5 +29,14 @@ module Public
 
     def terms
     end
+
+    def cookies
+    end
+
+    def faq
+    end
+
+    def pallavolo
+    end
   end
 end

backend/app/controllers/public/password_resets_controller.rb

@@ -0,0 +1,52 @@
+module Public
+  class PasswordResetsController < WebBaseController
+    def new
+    end
+
+    def create
+      user = User.find_by(email: params[:email]&.downcase&.strip)
+      if user
+        token = user.generate_password_reset!
+        UserMailer.password_reset(user, token).deliver_now
+      end
+
+      redirect_to public_login_path,
+                  notice: "Se l'email è registrata, riceverai a breve un link per reimpostare la password."
+    end
+
+    def edit
+      @user = User.find_by_password_reset_token(params[:token])
+      if @user.nil? || @user.password_reset_expired?
+        redirect_to new_public_password_reset_path,
+                    alert: "Link non valido o scaduto. Richiedi un nuovo reset password."
+        return
+      end
+      @token = params[:token]
+    end
+
+    def update
+      @user = User.find_by_password_reset_token(params[:token])
+      if @user.nil? || @user.password_reset_expired?
+        redirect_to new_public_password_reset_path,
+                    alert: "Link non valido o scaduto. Richiedi un nuovo reset password."
+        return
+      end
+
+      if params[:password].blank? || params[:password].length < 8
+        flash.now[:alert] = "La password deve avere almeno 8 caratteri"
+        @token = params[:token]
+        return render :edit, status: :unprocessable_entity
+      end
+
+      if params[:password] != params[:password_confirmation]
+        flash.now[:alert] = "Le password non coincidono"
+        @token = params[:token]
+        return render :edit, status: :unprocessable_entity
+      end
+
+      @user.update!(password: params[:password])
+      @user.clear_password_reset!
+      redirect_to public_login_path, notice: "Password aggiornata. Ora puoi accedere."
+    end
+  end
+end

backend/app/controllers/public/regia_controller.rb

@@ -0,0 +1,93 @@
+module Public
+  class RegiaController < SiteBaseController
+    include Public::LiveHelper
+    include Public::RegiaHelper
+    include MediamtxPlayback
+
+    layout "regia"
+
+    protect_from_forgery with: :null_session
+    skip_before_action :verify_authenticity_token, only: %i[score pause resume stop]
+
+    before_action :set_session_from_token
+
+    def show
+      @match = @session.match
+      @team = @match.team
+      @score = @session.score_state || Scoring::Engine.ensure_score_for(@session)
+      @rules = Scoring::Rules.from_match(@match)
+      @stream_closed = @session.terminal?
+      @on_air = !@stream_closed && (
+        mediamtx_stream_playable?(@session) ||
+        @session.status.in?(%w[connecting live reconnecting paused])
+      )
+      @regia_share_url = request.original_url
+      @regia_share_title = "Regia — #{@team.name} vs #{@match.opponent_name}"
+      @live_share_url = @session.share_url
+      @live_share_title = "#{@team.name} vs #{@match.opponent_name} — Diretta Match Live TV"
+    end
+
+    def status
+      render json: status_payload
+    end
+
+    def score
+      cmd = params[:cmd].presence || params[:score_action].presence
+      result = Scoring::ApplyAction.new(session: @session, action: cmd).call
+      @session.reload
+      render json: status_payload.merge(
+        set_won: result.set_won,
+        match_won: result.match_won,
+        winner: result.winner&.to_s
+      )
+    rescue ArgumentError => e
+      render json: { error: e.message }, status: :unprocessable_entity
+    end
+
+    def pause
+      Sessions::Pause.new(@session).call
+      render json: status_payload
+    end
+
+    def resume
+      Sessions::Resume.new(@session).call
+      render json: status_payload
+    rescue Teams::EntitlementError => e
+      render json: status_payload.merge(error: e.message), status: :unprocessable_entity
+    end
+
+    def stop
+      Sessions::Stop.new(@session).call
+      render json: status_payload
+    end
+
+    private
+
+    def set_session_from_token
+      @session = Sessions::RegiaAccess.find_session_by_token(params[:token])
+      return if @session
+
+      head :not_found
+    end
+
+    def status_payload
+      score = @session.score_state
+      closed = @session.terminal?
+      playable = !closed && mediamtx_stream_playable?(@session)
+      publisher_online = !closed && mediamtx_publisher_online?(@session)
+      {
+        status: @session.status,
+        paused: @session.paused?,
+        stream_closed: closed,
+        live: !closed && (@session.live? || @session.paused? || publisher_online),
+        on_air: playable || (!closed && @session.status.in?(%w[connecting live reconnecting paused])),
+        publisher_online: publisher_online,
+        ended_at: @session.ended_at,
+        home_name: @session.match.team.name,
+        away_name: @session.match.opponent_name,
+        points_target: Scoring::Rules.points_target_for_match(@session.match, current_set: score&.current_set || 1),
+        score: score&.as_cable_payload
+      }
+    end
+  end
+end

backend/app/controllers/public/registrations_controller.rb

@@ -1,11 +1,17 @@
 module Public
   class RegistrationsController < WebBaseController
     def new
-      redirect_to public_team_dashboard_path(current_user.teams.first) if logged_in? && current_user.teams.any?
+      redirect_to public_club_path(current_user.primary_club) if logged_in? && current_user.primary_club
       @user = User.new
     end
 
     def create
+      unless params[:accept_terms] == "1"
+        @user = User.new(user_params.merge(role: "coach"))
+        flash.now[:alert] = "Devi accettare l’informativa privacy e i termini di servizio per registrarti."
+        return render :new, status: :unprocessable_entity
+      end
+
       @user = User.new(user_params.merge(role: "coach"))
       if @user.save
         session[:user_id] = @user.id
@@ -14,10 +20,10 @@ module Public
           invitation = TeamInvitation.pending.find_by(token_digest: Digest::SHA256.hexdigest(token))
           if invitation && invitation.email.downcase == @user.email.downcase
             invitation.accept!(@user)
-            return redirect_to public_team_dashboard_path(invitation.team), notice: "Benvenuto nella squadra!"
+            return redirect_to public_team_details_path(invitation.team), notice: "Benvenuto nella squadra!"
           end
         end
-        redirect_to new_public_team_path, notice: "Account creato. Ora crea la tua squadra."
+        redirect_to public_new_club_path, notice: "Account creato. Ora registra la tua società."
       else
         flash.now[:alert] = @user.errors.full_messages.join(", ")
         render :new, status: :unprocessable_entity

backend/app/controllers/public/replay_controller.rb

@@ -1,15 +1,117 @@
 module Public
   class ReplayController < SiteBaseController
+    include Public::LiveHelper
+
     layout "marketing_live"
 
-    def show
-      @session = StreamSession.includes(match: :team).find(params[:id])
-      @recording = Recording.ready.find_by(stream_session: @session)
-      @match = @session.match
+    before_action :set_session_and_recording, only: %i[show stream thumbnail download]
+    before_action :authorize_replay_access!, only: %i[show stream thumbnail download]
 
-      unless @recording
-        redirect_to public_live_path(@session), alert: "Replay non disponibile"
+    def index
+      @query = params[:q].to_s.strip
+      @recordings = Recording.ready.publicly_listed
+                             .includes(stream_session: { match: { team: :club } })
+                             .search_replays(@query)
+                             .order(recorded_at: :desc, created_at: :desc)
+                             .limit(100)
+      if params[:club_id].present?
+        @recordings = @recordings.joins(:team).where(teams: { club_id: params[:club_id] })
       end
+      if params[:team_id].present?
+        @recordings = @recordings.where(team_id: params[:team_id])
+      end
+      @clubs = Club.joins(teams: :recordings)
+                   .merge(Recording.ready.publicly_listed)
+                   .distinct
+                   .order(:name)
+      @filter_club = @clubs.find { |c| c.id.to_s == params[:club_id].to_s } if params[:club_id].present?
+    end
+
+    def show
+      @match = @session.match
+    end
+
+    def stream
+      Recordings::IncrementViews.new(@recording).call
+      serve_video(disposition: "inline")
+    end
+
+    def thumbnail
+      serve_thumbnail
+    end
+
+    def download
+      unless download_allowed?
+        redirect_to public_replay_path(@session), alert: "Download non disponibile"
+        return
+      end
+
+      serve_video(disposition: "attachment")
+    end
+
+    private
+
+    def serve_video(disposition:)
+      expires_in = disposition == "attachment" ? MatchLiveTv.replay_download_url_ttl_seconds : MatchLiveTv.replay_presigned_url_ttl_seconds
+      redirect_url = Recordings::PublicMediaUrl.new(
+        key: @recording.storage_key,
+        expires_in: expires_in,
+        disposition: disposition,
+        filename: disposition == "attachment" ? download_filename : nil
+      ).call
+      return redirect_to redirect_url, allow_other_host: true if redirect_url.present?
+
+      Recordings::ServeFromStorage.new(
+        key: @recording.storage_key,
+        content_type: "video/mp4",
+        disposition: disposition,
+        filename: disposition == "attachment" ? download_filename : nil
+      ).call(self)
+    rescue ArgumentError
+      head :not_found
+    end
+
+    def serve_thumbnail
+      key = @recording.thumbnail_storage_key
+      return head :not_found if key.blank?
+
+      redirect_url = Recordings::PublicMediaUrl.new(key: key, expires_in: MatchLiveTv.replay_presigned_url_ttl_seconds).call
+      return redirect_to redirect_url, allow_other_host: true if redirect_url.present?
+
+      Recordings::ServeFromStorage.new(
+        key: key,
+        content_type: "image/jpeg",
+        disposition: "inline"
+      ).call(self)
+    rescue ArgumentError
+      head :not_found
+    end
+
+    def download_allowed?
+      ent = @recording.team.entitlements
+      return false unless ent.phone_download_enabled?
+
+      Recordings::AccessPolicy.new(@recording, viewer: current_user).allowed? ||
+        Recordings::AccessPolicy.new(@recording, viewer: current_user).manage_allowed?
+    end
+
+    def download_filename
+      slug = @recording.title_or_default.parameterize.presence || "replay"
+      "#{slug}.mp4"
+    end
+
+    def set_session_and_recording
+      @session = StreamSession.includes(match: { team: :club }).find(params[:id])
+      @recording = Recording.not_deleted.find_by(stream_session: @session)
+      return if @recording
+
+      redirect_to public_live_path(@session), alert: "Replay non disponibile"
+    end
+
+    def authorize_replay_access!
+      return if Recordings::AccessPolicy.new(@recording, viewer: current_user).allowed?
+
+      redirect_to public_live_index_path, alert: "Replay non disponibile"
     end
   end
 end

backend/app/controllers/public/sessions_controller.rb

@@ -1,14 +1,22 @@
 module Public
   class SessionsController < WebBaseController
     def new
-      redirect_to public_team_dashboard_path(current_user.teams.first) if logged_in? && current_user.teams.any?
+      if logged_in? && current_user.primary_club
+        redirect_to public_club_path(current_user.primary_club)
+      end
     end
 
     def create
       user = User.find_by(email: params[:email]&.downcase)
       if user&.authenticate(params[:password])
         session[:user_id] = user.id
-        dest = user.teams.first ? public_team_dashboard_path(user.teams.first) : new_public_team_path
+        dest = if user.primary_club
+                 public_club_path(user.primary_club)
+               elsif user.manageable_teams.first
+                 public_team_details_path(user.manageable_teams.first)
+               else
+                 public_new_club_path
+               end
         redirect_to dest, notice: "Bentornato!"
       else
         flash.now[:alert] = "Email o password non validi"

backend/app/controllers/public/site_base_controller.rb

@@ -2,10 +2,19 @@ module Public
   class SiteBaseController < ActionController::Base
     layout "marketing"
 
+    include ::SeoHelper
+    include ::LegalHelper
+    helper ApplicationHelper
     helper_method :current_user, :logged_in?
 
+    before_action :set_site_locale
+
     private
 
+    def set_site_locale
+      I18n.locale = :it
+    end
+
     def current_user
       return @current_user if defined?(@current_user)
 

backend/app/controllers/public/sitemap_controller.rb

@@ -0,0 +1,22 @@
+module Public
+  class SitemapController < ActionController::Base
+    def show
+      base = MatchLiveTv.app_public_url.chomp("/")
+      @entries = [
+        { loc: "#{base}/", changefreq: "weekly", priority: "1.0" },
+        { loc: "#{base}/funzionalita", changefreq: "monthly", priority: "0.9" },
+        { loc: "#{base}/prezzi", changefreq: "monthly", priority: "0.9" },
+        { loc: "#{base}/pallavolo-giovanile", changefreq: "monthly", priority: "0.85" },
+        { loc: "#{base}/faq", changefreq: "monthly", priority: "0.8" },
+        { loc: "#{base}/live", changefreq: "hourly", priority: "0.85" },
+        { loc: "#{base}/privacy", changefreq: "yearly", priority: "0.3" },
+        { loc: "#{base}/cookie", changefreq: "yearly", priority: "0.3" },
+        { loc: "#{base}/termini", changefreq: "yearly", priority: "0.3" }
+      ]
+
+      respond_to do |format|
+        format.xml { render layout: false }
+      end
+    end
+  end
+end

backend/app/controllers/public/team_roster_members_controller.rb

@@ -0,0 +1,63 @@
+module Public
+  class TeamRosterMembersController < WebBaseController
+    before_action :require_login!
+    before_action :set_team
+    before_action :require_team_owner!
+    before_action :set_member, only: %i[edit update destroy]
+
+    def create
+      member = @team.roster_members.build(member_params)
+      attach_photo(member)
+      member.save!
+      redirect_to public_team_details_path(@team), notice: "#{member.full_name} aggiunto all'organico."
+    rescue ActiveRecord::RecordInvalid => e
+      redirect_to public_team_details_path(@team), alert: e.record.errors.full_messages.join(", ")
+    end
+
+    def edit
+      @club = @team.club
+    end
+
+    def update
+      @member.assign_attributes(member_params)
+      attach_photo(@member)
+      @member.save!
+      redirect_to public_team_details_path(@team), notice: "Scheda aggiornata."
+    rescue ActiveRecord::RecordInvalid => e
+      @club = @team.club
+      flash.now[:alert] = e.record.errors.full_messages.join(", ")
+      render :edit, status: :unprocessable_entity
+    end
+
+    def destroy
+      name = @member.full_name
+      @member.destroy!
+      redirect_to public_team_details_path(@team), notice: "#{name} rimosso dall'organico."
+    end
+
+    private
+
+    def set_team
+      @team = current_user.manageable_teams.find(params[:team_id])
+    end
+
+    def require_team_owner!
+      require_club_owner_for_team!(@team)
+    end
+
+    def set_member
+      @member = @team.roster_members.find(params[:id])
+    end
+
+    def member_params
+      params.require(:team_roster_member).permit(
+        :category, :full_name, :role_label, :jersey_number, :bio, :position
+      )
+    end
+
+    def attach_photo(member)
+      file = params.dig(:team_roster_member, :photo_file)
+      member.photo_file.attach(file) if file.present?
+    end
+  end
+end

backend/app/controllers/public/teams_controller.rb

@@ -1,82 +1,91 @@
 module Public
   class TeamsController < WebBaseController
+    include BrandingAttachments
+
     before_action :require_login!
+    before_action :set_club, only: %i[new create]
     before_action :set_team, only: %i[
-      dashboard billing checkout portal invite create_invitation
-      remove_member destroy_invitation
+      details dashboard roster edit update invite create_invitation
+      assign_self_staff clear_self_staff remove_member destroy_invitation
+      youtube_connect youtube_disconnect
     ]
 
     def new
-      redirect_to public_team_dashboard_path(current_user.teams.first) if current_user.teams.any?
+      redirect_to public_new_club_path if current_user.owned_clubs.none?
+      require_club_owner!(@club)
     end
 
     def create
-      if current_user.user_teams.where(role: "owner").exists?
-        redirect_to public_team_dashboard_path(current_user.teams.first), alert: "Hai già una squadra"
-        return
-      end
+      require_club_owner!(@club)
+      team = @club.teams.create!(team_params)
+      attach_branding_logo(team)
+      redirect_to public_club_path(@club), notice: "Squadra «#{team.name}» aggiunta."
+    rescue ActiveRecord::RecordInvalid => e
+      flash.now[:alert] = e.record.errors.full_messages.join(", ")
+      render :new, status: :unprocessable_entity
+    end
 
-      team = Team.create!(team_params)
-      UserTeam.create!(user: current_user, team: team, role: "owner")
-      plan = params[:plan].presence_in(%w[free premium_light premium_full]) || "free"
-      Billing::AssignPlan.call(team: team, plan_slug: plan)
-
-      if plan.in?(%w[premium_light premium_full]) && MatchLiveTv.stripe_enabled?
-        redirect_to public_team_checkout_path(team, plan: plan)
-      else
-        redirect_to public_team_dashboard_path(team), notice: "Squadra creata con piano Free"
-      end
+    def details
+      load_team_details!
+      render :details
     end
 
     def dashboard
-      require_team_owner!(@team)
-      @entitlements = @team.entitlements
-      @recordings = @team.recordings.ready.includes(stream_session: :match).order(created_at: :desc).limit(10)
-      @members = @team.user_teams.includes(:user).where.not(role: "owner")
-      @pending_invitations = @team.team_invitations.pending.order(created_at: :desc)
+      redirect_to public_team_details_path(params[:id])
     end
 
-    def billing
-      require_team_owner!(@team)
-      @entitlements = @team.entitlements
-      @plans = Plan.ordered
+    def roster
+      redirect_to public_team_details_path(params[:id])
     end
 
-    def checkout
-      require_team_owner!(@team)
-      unless MatchLiveTv.stripe_enabled?
-        redirect_to public_team_billing_path(@team), alert: "Pagamenti non ancora configurati sul server"
-        return
-      end
-
-      plan_slug = params[:plan].presence_in(%w[premium_light premium_full]) || "premium_light"
-      url = Billing::Stripe::CheckoutSession.new(team: @team, user: current_user, plan_slug: plan_slug).url
-      redirect_to url, allow_other_host: true
+    def edit
+      require_club_owner_for_team!(@team)
+      @club = @team.club
     end
 
-    def portal
-      require_team_owner!(@team)
-      unless MatchLiveTv.stripe_enabled?
-        redirect_to public_team_billing_path(@team), alert: "Portale pagamenti non configurato"
-        return
-      end
-
-      url = Billing::Stripe::CheckoutSession.new(team: @team, user: current_user).portal_url
-      redirect_to url, allow_other_host: true
+    def update
+      require_club_owner_for_team!(@team)
+      @team.assign_attributes(team_params)
+      attach_branding_logo(@team)
+      attach_team_photo(@team)
+      @team.save!
+      redirect_to public_team_details_path(@team), notice: "Squadra aggiornata."
+    rescue ActiveRecord::RecordInvalid => e
+      @club = @team.club
+      flash.now[:alert] = e.record.errors.full_messages.join(", ")
+      render :edit, status: :unprocessable_entity
     end
 
     def invite
-      require_team_owner!(@team)
+      require_club_owner_for_team!(@team)
       @entitlements = @team.entitlements
     end
 
+    def assign_self_staff
+      require_club_owner_for_team!(@team)
+      membership = current_user.user_teams.find_or_initialize_by(team: @team)
+      membership.role = "member" if membership.new_record?
+      Teams::StaffAssignment.call(team: @team, user: current_user, membership: membership)
+      redirect_to public_team_details_path(@team), notice: "Il tuo account è ora responsabile trasmissione."
+    rescue Teams::StaffAssignmentError, Teams::EntitlementError => e
+      redirect_to public_team_details_path(@team), alert: e.message
+    end
+
+    def clear_self_staff
+      require_club_owner_for_team!(@team)
+      membership = current_user.user_teams.find_by(team: @team)
+      membership&.update!(staff_kind: nil)
+      redirect_to public_team_details_path(@team), notice: "Ruolo staff rimosso dal tuo account."
+    end
+
     def create_invitation
-      require_team_owner!(@team)
+      require_club_owner_for_team!(@team)
       @entitlements = @team.entitlements
-      staff_kind = params[:staff_kind].presence_in(TeamInvitation::STAFF_KINDS) || "transmission"
+      staff_kind = "transmission"
       @entitlements.assert_can_invite!(staff_kind: staff_kind)
 
       email = params[:email]&.downcase&.strip
+      Teams::StaffEmailValidator.assert_available!(team: @team, email: email, staff_kind: staff_kind)
       token = TeamInvitation.generate_token
       @team.team_invitations.create!(
         email: email,
@@ -88,32 +97,89 @@ module Public
       @invite_url = join_public_invitation_url(token: token)
       flash.now[:notice] = "Link invito generato (valido 7 giorni)"
       render :invite
-    rescue Teams::EntitlementError => e
+    rescue Teams::EntitlementError, Teams::StaffAssignmentError => e
       redirect_to public_team_invite_path(@team), alert: e.message
     end
 
     def remove_member
-      require_team_owner!(@team)
+      require_club_owner_for_team!(@team)
       ut = @team.user_teams.find_by!(user_id: params[:user_id], role: "member")
       ut.destroy!
-      redirect_to public_team_dashboard_path(@team), notice: "Accesso revocato"
+      redirect_to public_team_details_path(@team), notice: "Accesso revocato"
     end
 
     def destroy_invitation
-      require_team_owner!(@team)
+      require_club_owner_for_team!(@team)
       inv = @team.team_invitations.pending.find(params[:invitation_id])
       inv.destroy!
-      redirect_to public_team_dashboard_path(@team), notice: "Invito annullato"
+      redirect_to public_team_details_path(@team), notice: "Invito annullato"
+    end
+
+    def youtube_connect
+      redirect_to public_club_youtube_connect_path(
+        @team.club_id,
+        return_app: params[:return_app]
+      )
+    end
+
+    def youtube_disconnect
+      require_club_owner_for_team!(@team)
+      @team.club.youtube_credential&.destroy!
+      redirect_to public_club_path(@team.club), notice: "Canale YouTube della società scollegato"
     end
 
     private
 
+    def load_team_details!
+      @club = @team.club
+      @can_manage = @club.owned_by?(current_user)
+      @entitlements = @team.entitlements
+      @roster_by_category = @team.roster_by_category
+      if @can_manage
+        @roster_member = @team.roster_members.build(
+          category: params[:category].presence_in(TeamRosterMember::CATEGORIES) || "player"
+        )
+      end
+      @recordings = @team.recordings.not_deleted
+                          .where(status: %w[ready processing])
+                          .includes(stream_session: :match)
+                          .order(recorded_at: :desc, created_at: :desc)
+                          .limit(10)
+      @owner_membership = current_user.user_teams.find_by(team: @team)
+      @staff_memberships = @team.user_teams.includes(:user)
+        .where("user_teams.role = 'member' OR (user_teams.staff_kind IS NOT NULL)")
+      @pending_invitations = @team.team_invitations.pending.order(created_at: :desc)
+    end
+
+    def set_club
+      @club = current_user.owned_clubs.find(params[:club_id])
+    end
+
     def set_team
-      @team = current_user.teams.find(params[:id])
+      @team = current_user.manageable_teams.find(params[:id])
+    end
+
+    def attach_team_photo(team)
+      file = params.dig(:team, :photo_file)
+      team.photo_file.attach(file) if file.present?
     end
 
     def team_params
-      params.require(:team).permit(:name, :sport, :logo_url)
+      p = params.require(:team).permit(:name, :sport, :sport_key, :description, :logo_url, :primary_color, :secondary_color)
+      if p[:sport].present? && p[:sport_key].blank?
+        p[:sport_key] = p.delete(:sport)
+      elsif p[:sport_key].present?
+        p.delete(:sport)
+      end
+      p[:primary_color] = p[:primary_color].presence
+      p[:secondary_color] = p[:secondary_color].presence
+      if p[:primary_color].present?
+        p[:primary_color] = normalize_hex_color(p[:primary_color], p[:primary_color])
+      end
+      if p[:secondary_color].present?
+        p[:secondary_color] = normalize_hex_color(p[:secondary_color], p[:secondary_color])
+      end
+      p
     end
   end
 end

backend/app/controllers/public/web_base_controller.rb

@@ -10,9 +10,12 @@ module Public
       redirect_to public_login_path, alert: "Accedi per continuare"
     end
 
-    def require_team_owner!(team)
-      membership = current_user.user_teams.find_by(team: team)
-      redirect_to public_prezzi_path, alert: "Accesso non consentito" unless membership&.role == "owner"
+    def require_club_owner!(club)
+      redirect_to public_prezzi_path, alert: "Accesso non consentito" unless club.owned_by?(current_user)
+    end
+
+    def require_club_owner_for_team!(team)
+      redirect_to public_prezzi_path, alert: "Accesso non consentito" unless team.club&.owned_by?(current_user)
     end
   end
 end

backend/app/controllers/youtube_oauth_callback_controller.rb

@@ -0,0 +1,49 @@
+# Callback OAuth YouTube (HTML). Non usare Api::V1 — ActionController::API non renderizza le view.
+class YoutubeOauthCallbackController < ActionController::Base
+  def show
+    return redirect_to_oauth_error("Codice OAuth mancante") if params[:code].blank?
+
+    ctx = Youtube::OauthState.verify!(params[:state])
+    tokens = Youtube::OauthExchange.call(params[:code])
+
+    if ctx[:kind] == :platform
+      @refresh_token = tokens[:refresh_token]
+      @channel_title = tokens[:channel_title]
+      return render "admin/youtube/platform_token", layout: false
+    end
+
+    user = User.find(ctx[:user_id])
+    club = Club.find(ctx[:club_id])
+    unless club.owned_by?(user)
+      return redirect_to_oauth_error("Solo il titolare della società può collegare il canale YouTube")
+    end
+
+    cred = club.youtube_credential || club.build_youtube_credential
+    cred.update!(
+      access_token: tokens[:access_token],
+      refresh_token: tokens[:refresh_token] || cred.refresh_token,
+      expires_at: Time.current + tokens[:expires_in].seconds,
+      channel_id: tokens[:channel_id],
+      channel_title: tokens[:channel_title]
+    )
+
+    if ctx[:return_app]
+      redirect_to "matchlivetv://youtube-connected?club_id=#{club.id}", allow_other_host: true
+    else
+      redirect_to "#{public_base_url}/clubs/#{club.id}?youtube=connected", allow_other_host: true
+    end
+  rescue ArgumentError, Youtube::BroadcastService::Error => e
+    redirect_to_oauth_error(e.message)
+  end
+
+  private
+
+  def public_base_url
+    MatchLiveTv.app_public_url.chomp("/")
+  end
+
+  def redirect_to_oauth_error(message)
+    redirect_to "#{public_base_url}/prezzi?youtube_error=#{ERB::Util.url_encode(message)}",
+                allow_other_host: true
+  end
+end

backend/app/domain/sports/board_type.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Sports
+  class BoardType
+    ALL = %w[volley basket timed racket timer generic].freeze
+
+    def self.valid?(value)
+      ALL.include?(value.to_s)
+    end
+  end
+end

backend/app/domain/sports/catalog.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Sports
+  class Catalog
+    LEGACY_SPORT_MAP = {
+      "volleyball" => "pallavolo"
+    }.freeze
+
+    class << self
+      def all
+        @all ||= load_entries
+      end
+
+      def keys
+        all.keys
+      end
+
+      def find(key)
+        normalized = normalize_key(key)
+        entry = all[normalized]
+        raise KeyError, "Sport sconosciuto: #{key}" unless entry
+
+        entry.merge(key: normalized)
+      end
+
+      def find_optional(key)
+        normalized = normalize_key(key)
+        entry = all[normalized]
+        return nil unless entry
+
+        entry.merge(key: normalized)
+      end
+
+      def board_for(key)
+        find(key)[:board]
+      end
+
+      def overlay_for(key)
+        find(key)[:overlay]
+      end
+
+      def allowed_overlays_for(key)
+        find(key)[:allowed_overlays]
+      end
+
+      def default_rules_for(key)
+        deep_stringify_keys(find(key)[:default_rules] || {})
+      end
+
+      def normalize_key(key)
+        raw = key.to_s.strip
+        return "pallavolo" if raw.blank?
+
+        LEGACY_SPORT_MAP.fetch(raw, raw)
+      end
+
+      def as_api_list
+        all.map do |key, entry|
+          {
+            key: key,
+            label: entry[:label],
+            board: entry[:board],
+            overlay: entry[:overlay],
+            allowed_overlays: entry[:allowed_overlays],
+            default_rules: entry[:default_rules] || {}
+          }
+        end
+      end
+
+      private
+
+      def load_entries
+        path = Rails.root.join("config/sports.yml")
+        raw = YAML.safe_load(File.read(path), permitted_classes: [], aliases: true) || {}
+        raw.transform_keys(&:to_s).transform_values do |entry|
+          entry.deep_symbolize_keys
+        end.freeze
+      end
+
+      def deep_stringify_keys(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(k, v), h|
+            h[k.to_s] = deep_stringify_keys(v)
+          end
+        when Array
+          value.map { |v| deep_stringify_keys(v) }
+        else
+          value
+        end
+      end
+    end
+  end
+end

backend/app/domain/sports/overlay_kind.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Sports
+  class OverlayKind
+    ALL = %w[none volley basket timed racket].freeze
+
+    def self.valid?(value)
+      ALL.include?(value.to_s)
+    end
+  end
+end

backend/app/domain/sports/player_roles.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Sports
+  class PlayerRoles
+    BY_BOARD = {
+      "volley" => %w[Schiacciatore Opposto Centrale Palleggiatore Libero Universale],
+      "basket" => ["Playmaker", "Guardia", "Ala", "Ala forte", "Centro"],
+      "racket" => %w[Giocatore],
+      "timed" => %w[Portiere Difensore Centrocampista Attaccante],
+      "generic" => %w[Giocatore],
+      "timer" => %w[Giocatore]
+    }.freeze
+
+    class << self
+      def for_team(team)
+        board = team.effective_board_type
+        BY_BOARD[board] || BY_BOARD["generic"]
+      end
+
+      def for_board(board)
+        BY_BOARD[board.to_s] || BY_BOARD["generic"]
+      end
+    end
+  end
+end

backend/app/domain/sports/rules_schema.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Sports
+  class RulesSchema
+    INTEGER_RULES = {
+      "volley" => %w[sets_to_win points_per_set points_deciding_set min_point_lead],
+      "racket" => %w[sets_to_win points_per_set points_deciding_set min_point_lead],
+      "basket" => %w[periods period_duration_secs overtime_duration_secs],
+      "timed" => %w[periods period_duration_secs overtime_duration_secs],
+      "timer" => [],
+      "generic" => []
+    }.freeze
+
+    def self.validate!(board_type, rules)
+      board = board_type.to_s
+      return if board == "generic" || board == "timer"
+
+      hash = rules.is_a?(Hash) ? rules : {}
+      INTEGER_RULES.fetch(board, []).each do |key|
+        val = hash[key] || hash[key.to_sym]
+        next if val.blank?
+
+        unless val.is_a?(Integer) || val.to_s.match?(/\A\d+\z/)
+          raise ArgumentError, "#{key} non valido"
+        end
+        int_val = val.to_i
+        raise ArgumentError, "#{key} deve essere positivo" if int_val < 1
+      end
+    end
+
+    def self.validate(board_type, rules)
+      validate!(board_type, rules)
+      true
+    rescue ArgumentError
+      false
+    end
+  end
+end

backend/app/helpers/admin_helper.rb

@@ -0,0 +1,40 @@
+module AdminHelper
+  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: "Pagina live", url: session.watch_page_url }
+    end
+    youtube = session.youtube_watch_url
+    links << { label: "YouTube", url: youtube } if youtube.present?
+    links
+  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
+end

backend/app/helpers/application_helper.rb

@@ -0,0 +1,24 @@
+module ApplicationHelper
+  PLAN_ICONS = {
+    "free" => "fa-solid fa-seedling",
+    "premium_light" => "fa-solid fa-rocket",
+    "premium_full" => "fa-solid fa-crown"
+  }.freeze
+
+  def plan_icon_class(plan)
+    PLAN_ICONS[plan.slug] || "fa-solid fa-circle"
+  end
+
+  # Data/ora nel fuso dell'app (Europe/Rome) e nella lingua del sito.
+  def l_local(date_or_time, format: :long)
+    return nil if date_or_time.blank?
+
+    value = date_or_time.respond_to?(:in_time_zone) ? date_or_time.in_time_zone : date_or_time
+    I18n.with_locale(:it) { I18n.l(value, format: format) }
+  end
+
+  def sport_catalog_options(selected = nil)
+    options = Sports::Catalog.as_api_list.map { |entry| [entry[:label], entry[:key]] }
+    options_for_select(options, Sports::Catalog.normalize_key(selected))
+  end
+end

backend/app/helpers/legal_helper.rb

@@ -0,0 +1,9 @@
+module LegalHelper
+  def legal_last_updated
+    "3 giugno 2026"
+  end
+
+  def cookie_policy_last_updated
+    "3 giugno 2026"
+  end
+end

backend/app/helpers/public/billing_helper.rb

@@ -0,0 +1,96 @@
+module Public
+  module BillingHelper
+    def plan_billing_action(current_slug:, target_plan:, stripe_subscription_active:, current_interval: nil, subscription: nil)
+      if target_plan.slug == "free"
+        return { kind: :current, label: "Piano attuale" } if current_slug == "free"
+        return { kind: :none } if stripe_subscription_active
+
+        return { kind: :contact, label: "Per passare al piano Free, contatta il supporto." }
+      end
+
+      unless MatchLiveTv.stripe_enabled?
+        return { kind: :disabled, label: "Stripe non configurato" }
+      end
+
+      intervals = Billing::Stripe::PriceCatalog.available_intervals(plan_slug: target_plan.slug)
+      return { kind: :disabled, label: "Prezzi Stripe non configurati" } if intervals.empty?
+
+      active_interval = current_interval.presence || Billing::Stripe::PriceCatalog::DEFAULT_INTERVAL
+
+      if current_slug == target_plan.slug && stripe_subscription_active && !subscription&.plan_change_pending?
+        other_intervals = intervals - [active_interval]
+        if other_intervals.empty?
+          label = "Piano attuale — #{Billing::Stripe::PriceCatalog.label(plan_slug: target_plan.slug, interval: active_interval)}"
+          return { kind: :current, label: label }
+        end
+
+        return {
+          kind: :interval_switch,
+          plan: target_plan,
+          intervals: other_intervals,
+          current_interval: active_interval,
+          current_slug: current_slug,
+          subscription: subscription
+        }
+      end
+
+      if current_slug == "free" || !stripe_subscription_active
+        { kind: :checkout_options, plan: target_plan, intervals: intervals, subscription: subscription }
+      else
+        {
+          kind: :change_options,
+          plan: target_plan,
+          intervals: intervals,
+          current_slug: current_slug,
+          current_interval: active_interval,
+          subscription: subscription
+        }
+      end
+    end
+
+    def plan_interval_checkout_path(club, plan, interval)
+      public_club_checkout_path(club, plan: plan.slug, interval: interval)
+    end
+
+    def plan_interval_button_label(plan, interval, kind: :checkout, **)
+      btn_kind = kind == :checkout_options ? :checkout : :change
+      Billing::Stripe::PlanChangeMessages.button_label(plan: plan, interval: interval, kind: btn_kind)
+    end
+
+    def billing_plan_change_info_lines(subscription: nil)
+      Billing::Stripe::PlanChangeMessages.billing_info_lines(subscription: subscription)
+    end
+
+    def stripe_subscription_active?(subscription)
+      subscription&.stripe_subscription_id.present? && subscription.active?
+    end
+
+    def stripe_interval_available?(plan_slug, interval)
+      Billing::Stripe::PriceCatalog.configured?(plan_slug: plan_slug, interval: interval)
+    end
+
+    def plan_interval_button_class(interval, **)
+      if interval.to_s == "yearly"
+        "btn btn-primary plan-interval-btn plan-interval-btn--yearly"
+      else
+        "btn btn-outline plan-interval-btn plan-interval-btn--monthly"
+      end
+    end
+
+    def plan_intervals_for_display(intervals)
+      Array(intervals).sort_by { |i| i.to_s == "yearly" ? 0 : 1 }
+    end
+
+    def billing_profile_blocks_premium?(club)
+      club.present? && !club.billing_profile_complete?
+    end
+
+    def billing_profile_incomplete_message(club)
+      missing = club.billing_profile_errors
+      return "Completa i dati di fatturazione prima di attivare un piano premium." if missing.empty?
+
+      "Mancano: #{missing.join(", ")}."
+    end
+
+  end
+end

backend/app/helpers/public/live_helper.rb

@@ -1,13 +1,30 @@
 module Public
   module LiveHelper
-    def live_score_sets_label(score_state)
+    def live_score_sets_label(score_state, match = nil)
       return nil unless score_state
 
-      "Set #{score_state.current_set} · Set vinti #{score_state.home_sets}-#{score_state.away_sets}"
+      board = match&.effective_board_type || score_state.effective_board_type
+      case board
+      when "basket", "timed"
+        live_score_period_label(match, score_state)
+      when "timer"
+        "Cronometro"
+      when "generic"
+        "Punteggio"
+      else
+        "Set #{score_state.current_set} · Set vinti #{score_state.home_sets}-#{score_state.away_sets}"
+      end
+    end
+
+    def live_score_period_label(match, score_state)
+      return "—" unless score_state
+
+      score_state.current_period_label
     end
 
     def live_score_partials_label(score_state)
       return nil unless score_state
+      return nil unless score_state.effective_board_type.in?(%w[volley racket])
 
       partials = Array(score_state.set_partials)
       return nil if partials.empty?
@@ -15,10 +32,60 @@ module Public
       partials.map { |p| format_set_partial_entry(p) }.join(" · ")
     end
 
+    def live_scheduled_label(datetime)
+      return nil unless datetime
+
+      datetime.in_time_zone.strftime("%d/%m/%Y alle %H:%M")
+    end
+
+    def live_scheduled_relative(datetime)
+      return nil unless datetime
+
+      if datetime.to_date == Time.zone.today
+        "Oggi alle #{datetime.strftime('%H:%M')}"
+      elsif datetime.to_date == Time.zone.tomorrow
+        "Domani alle #{datetime.strftime('%H:%M')}"
+      else
+        live_scheduled_label(datetime)
+      end
+    end
+
+    def live_match_card_heading(match)
+      team = match.team
+      club_name = team.club&.name.presence || "Società"
+      content_tag(:h3, class: "live-card__title") do
+        safe_join([
+          content_tag(:span, club_name, class: "live-card__club"),
+          content_tag(:span, "#{team.name} vs #{match.opponent_name}", class: "live-card__matchup")
+        ])
+      end
+    end
+
+    def live_match_page_heading(match)
+      team = match.team
+      club_name = team.club&.name.presence || "Società"
+      content_tag(:div, class: "live-page-heading") do
+        safe_join([
+          content_tag(:p, club_name, class: "live-page-heading__club"),
+          content_tag(:h1, "#{team.name} vs #{match.opponent_name}", class: "live-page-heading__matchup")
+        ])
+      end
+    end
+
     def live_score_points_label(match, score_state)
       return "—" unless score_state
 
-      "#{match.team.name} #{score_state.home_points} - #{score_state.away_points} #{match.opponent_name}"
+      board = match.effective_board_type
+      home = case board
+             when "basket", "timed" then score_state.basket_home_score
+             else score_state.home_points
+             end
+      away = case board
+             when "basket", "timed" then score_state.basket_away_score
+             else score_state.away_points
+             end
+
+      "#{match.team.name} #{home} - #{away} #{match.opponent_name}"
     end
 
     private

backend/app/helpers/public/regia_helper.rb

@@ -0,0 +1,32 @@
+module Public
+  module RegiaHelper
+    def regia_board_partial(match)
+      board = match.effective_board_type
+      partial = "public/regia/#{board}"
+      lookup_context.exists?(partial, [], true) ? partial : "public/regia/volley"
+    end
+
+    def regia_header_subtitle(match, score)
+      board = match.effective_board_type
+      case board
+      when "basket", "timed"
+        live_score_period_label(match, score)
+      when "timer"
+        "Cronometro"
+      when "generic"
+        "Punteggio"
+      else
+        "Set #{score.current_set}"
+      end
+    end
+
+    def format_clock_secs(secs, count_up: false)
+      total = secs.to_i
+      return count_up ? "0:00" : "—" if total <= 0 && !count_up
+
+      m = total / 60
+      s = total % 60
+      format("%d:%02d", m, s)
+    end
+  end
+end

backend/app/helpers/recordings_archive_helper.rb

@@ -0,0 +1,24 @@
+module RecordingsArchiveHelper
+  ArchivePaths = Struct.new(:index, :update, :destroy, :publish_youtube, :back, keyword_init: true)
+
+  def recordings_archive_paths(club, namespace:)
+    case namespace
+    when :admin
+      ArchivePaths.new(
+        index: admin_club_recordings_path(club),
+        update: ->(rec) { admin_club_recording_path(club, rec) },
+        destroy: ->(rec) { admin_club_recording_path(club, rec) },
+        publish_youtube: ->(rec) { publish_youtube_admin_club_recording_path(club, rec) },
+        back: admin_club_path(club)
+      )
+    else
+      ArchivePaths.new(
+        index: public_club_recordings_path(club),
+        update: ->(rec) { public_club_recording_path(club, rec) },
+        destroy: ->(rec) { public_club_recording_path(club, rec) },
+        publish_youtube: ->(rec) { public_club_recording_publish_youtube_path(club, rec) },
+        back: public_club_path(club)
+      )
+    end
+  end
+end

backend/app/helpers/roster_helper.rb

@@ -0,0 +1,33 @@
+module RosterHelper
+  def roster_person_avatar(person, team, size: 96)
+    primary = team.effective_primary_color
+    secondary = team.effective_secondary_color
+    style = "--avatar-primary:#{primary};--avatar-secondary:#{secondary};width:#{size}px;height:#{size}px"
+
+    if person.photo_url.present?
+      image_tag person.photo_url, alt: person.full_name, class: "roster-avatar roster-avatar--photo",
+                style: style, width: size, height: size
+    else
+      tag.div(
+        person.initials,
+        class: "roster-avatar roster-avatar--placeholder",
+        style: "#{style};font-size:#{(size * 0.34).round}px",
+        aria: { label: person.full_name }
+      )
+    end
+  end
+
+  def roster_category_options
+    TeamRosterMember::DISPLAY_ORDER.map do |cat|
+      [TeamRosterMember::CATEGORY_LABELS[cat], cat]
+    end
+  end
+
+  def roster_player_role_options(team, selected = nil)
+    roles = Sports::PlayerRoles.for_team(team)
+    options_for_select(
+      [["— Seleziona ruolo —", ""]] + roles.map { |r| [r, r] },
+      selected
+    )
+  end
+end

backend/app/helpers/seo_helper.rb

@@ -0,0 +1,33 @@
+module SeoHelper
+  DEFAULT_OG_IMAGE_PATH = "/og-share.png"
+
+  def seo_site_url
+    MatchLiveTv.app_public_url.chomp("/")
+  end
+
+  def seo_absolute_url(path)
+    path = "/#{path}" unless path.start_with?("/")
+    "#{seo_site_url}#{path}"
+  end
+
+  def seo_canonical_url
+    if content_for?(:canonical_url)
+      content_for(:canonical_url)
+    else
+      request.original_url.split("?").first
+    end
+  end
+
+  def seo_og_image_url
+    if content_for?(:og_image)
+      img = content_for(:og_image)
+      img.start_with?("http") ? img : seo_absolute_url(img)
+    else
+      seo_absolute_url(DEFAULT_OG_IMAGE_PATH)
+    end
+  end
+
+  def seo_robots_content
+    content_for?(:robots) ? content_for(:robots) : "index, follow"
+  end
+end

backend/app/helpers/staff_helper.rb

@@ -0,0 +1,9 @@
+module StaffHelper
+  def staff_role_label(membership, team)
+    Teams::StaffCoverage.new(team).role_label_for(membership)
+  end
+
+  def staff_coverage_for(team)
+    Teams::StaffCoverage.new(team)
+  end
+end

backend/app/jobs/expire_ended_subscriptions_job.rb

@@ -0,0 +1,17 @@
+# Passa a Free le società con disdetta programmata e periodo scaduto (anche senza visita pagina billing).
+class ExpireEndedSubscriptionsJob
+  include Sidekiq::Job
+
+  def perform
+    free_plan = Plan["free"]
+
+    Subscription.where(cancel_at_period_end: true)
+                  .where("current_period_end <= ?", Time.current)
+                  .where.not(plan_id: free_plan.id)
+                  .find_each do |sub|
+      Billing::Stripe::FinalizeSubscription.call(club: sub.club)
+    rescue StandardError => e
+      Rails.logger.warn("[ExpireEndedSubscriptions] club=#{sub.club_id} #{e.message}")
+    end
+  end
+end

backend/app/jobs/ops/health_monitor_job.rb

@@ -0,0 +1,33 @@
+module Ops
+  class HealthMonitorJob
+    include Sidekiq::Job
+
+    sidekiq_options retry: 1, queue: "default"
+
+    INTERVAL_SECS = ENV.fetch("OPS_HEALTH_INTERVAL_SECS", "180").to_i
+    REDIS_CHAIN_KEY = "ops:health_monitor:chain"
+    HEARTBEAT_KEY = "ops:health_monitor:last_run"
+
+    def self.ensure_chain
+      return unless redis
+
+      return if redis.get(REDIS_CHAIN_KEY)
+
+      redis.set(REDIS_CHAIN_KEY, "1", ex: INTERVAL_SECS * 2)
+      perform_in(INTERVAL_SECS)
+    end
+
+    def self.redis
+      @redis ||= Redis.new(url: ENV.fetch("REDIS_URL", "redis://localhost:6379/0"))
+    rescue Redis::CannotConnectError
+      nil
+    end
+
+    def perform
+      self.class.redis&.set(HEARTBEAT_KEY, Time.current.to_i, ex: INTERVAL_SECS * 3)
+      Ops::HealthChecks.new.call
+    ensure
+      self.class.perform_in(INTERVAL_SECS)
+    end
+  end
+end

backend/app/jobs/recordings/cleanup_local_job.rb

@@ -0,0 +1,16 @@
+module Recordings
+  class CleanupLocalJob
+    include Sidekiq::Job
+    sidekiq_options retry: 1, queue: "default"
+
+    def perform
+      result = Recordings::CleanupLocal.new.call
+      orphan = Mediamtx::CleanupOrphanPaths.new.call
+      Rails.logger.info(
+        "[Recordings::CleanupLocalJob] removed=#{result.removed} " \
+        "freed=#{result.freed_bytes} skipped=#{result.skipped} " \
+        "orphan_paths=#{orphan.removed}"
+      )
+    end
+  end
+end

backend/app/jobs/recordings/expiry_warning_job.rb

@@ -0,0 +1,18 @@
+module Recordings
+  class ExpiryWarningJob
+    include Sidekiq::Job
+    sidekiq_options retry: 1, queue: "default"
+
+    def perform
+      Recording.ready
+               .where(expiry_warning_sent_at: nil)
+               .where.not(expires_at: nil)
+               .where(expires_at: ..7.days.from_now)
+               .find_each do |recording|
+        Recordings::NotifyExpiring.new(recording).call
+      rescue StandardError => e
+        Rails.logger.warn("[Recordings::ExpiryWarningJob] #{recording.id}: #{e.message}")
+      end
+    end
+  end
+end

backend/app/jobs/recordings/post_process_job.rb

@@ -0,0 +1,18 @@
+module Recordings
+  class PostProcessJob
+    include Sidekiq::Job
+    sidekiq_options retry: 2, queue: "default"
+
+    def perform(recording_id)
+      recording = Recording.find_by(id: recording_id)
+      return unless recording&.ready?
+
+      Recordings::NotifyReady.new(recording).call
+
+      return unless recording.auto_publish_youtube?
+      return if recording.youtube_video_id.present?
+
+      Recordings::PublishToYoutubeJob.perform_async(recording.id)
+    end
+  end
+end

backend/app/jobs/recordings/publish_to_youtube_job.rb

@@ -0,0 +1,17 @@
+module Recordings
+  class PublishToYoutubeJob
+    include Sidekiq::Job
+    sidekiq_options retry: 2, queue: "default"
+
+    def perform(recording_id)
+      recording = Recording.find_by(id: recording_id)
+      return unless recording&.ready?
+
+      Recordings::PublishToYoutube.new(recording).call
+    rescue Recordings::PublishToYoutube::Error => e
+      meta = recording.metadata.merge("youtube_publish_error" => e.message, "youtube_publish_failed_at" => Time.current.iso8601)
+      recording.update!(metadata: meta)
+      Rails.logger.warn("[Recordings::PublishToYoutubeJob] #{recording_id}: #{e.message}")
+    end
+  end
+end

backend/app/jobs/recordings/purge_expired_job.rb

@@ -0,0 +1,14 @@
+module Recordings
+  class PurgeExpiredJob
+    include Sidekiq::Job
+    sidekiq_options retry: 1, queue: "default"
+
+    def perform
+      Recording.expired_pending_purge.find_each do |recording|
+        Recordings::Delete.new(recording, reason: :expired).call
+      rescue StandardError => e
+        Rails.logger.warn("[Recordings::PurgeExpiredJob] #{recording.id}: #{e.message}")
+      end
+    end
+  end
+end

backend/app/jobs/recordings/sync_youtube_privacy_job.rb

@@ -0,0 +1,17 @@
+module Recordings
+  class SyncYoutubePrivacyJob
+    include Sidekiq::Job
+    sidekiq_options retry: 2, queue: "default"
+
+    def perform(recording_id)
+      recording = Recording.find_by(id: recording_id)
+      return unless recording&.youtube_video_id.present?
+
+      Youtube::VideoLifecycleService.new(recording).update_privacy!(
+        privacy_status: recording.privacy_status
+      )
+    rescue Youtube::VideoLifecycleService::Error => e
+      Rails.logger.warn("[SyncYoutubePrivacyJob] #{recording_id}: #{e.message}")
+    end
+  end
+end

backend/app/jobs/recordings/upload_job.rb

@@ -0,0 +1,14 @@
+module Recordings
+  class UploadJob
+    include Sidekiq::Job
+    sidekiq_options retry: 3, queue: "default"
+
+    def perform(session_id)
+      session = StreamSession.find_by(id: session_id)
+      return unless session
+
+      Recordings::UploadFromSession.new(session).call
+      Recordings::PurgeExpiredJob.perform_async
+    end
+  end
+end

backend/app/jobs/stream_publisher_sync_job.rb

@@ -0,0 +1,37 @@
+# Poll MediaMTX + pipeline YouTube automatica (webhook MediaMTX non disponibile in prod).
+class StreamPublisherSyncJob < ApplicationJob
+  queue_as :default
+
+  INTERVAL = 5.seconds
+  ACTIVE_STATUSES = %w[connecting live reconnecting paused].freeze
+  REDIS_CHAIN_KEY = "stream_publisher_sync:chain"
+  RUN_LOCK_KEY = "stream_publisher_sync:run_lock"
+
+  def self.ensure_chain
+    return if redis.get(REDIS_CHAIN_KEY)
+
+    redis.set(REDIS_CHAIN_KEY, "1", ex: INTERVAL.to_i * 4)
+    set(wait: INTERVAL).perform_later
+  end
+
+  def self.redis
+    @redis ||= Redis.new(url: ENV.fetch("REDIS_URL", "redis://localhost:6379/0"))
+  end
+
+  def perform
+    return unless self.class.redis.set(RUN_LOCK_KEY, "1", nx: true, ex: INTERVAL.to_i)
+
+    begin
+      self.class.redis.set(REDIS_CHAIN_KEY, "1", ex: INTERVAL.to_i * 4)
+
+      StreamSession
+        .where(status: ACTIVE_STATUSES)
+        .find_each do |session|
+          Mediamtx::PublisherSync.new(session).call
+        end
+    ensure
+      self.class.set(wait: INTERVAL).perform_later
+      self.class.redis.del(RUN_LOCK_KEY)
+    end
+  end
+end

backend/app/jobs/youtube_broadcast_activate_job.rb

@@ -0,0 +1,54 @@
+class YoutubeBroadcastActivateJob < ApplicationJob
+  queue_as :default
+
+  MAX_ATTEMPTS = 30
+  RETRY_WAIT = 15.seconds
+  RATE_LIMIT_WAIT = 90.seconds
+  LIVE_STATUSES = %w[live connecting reconnecting paused].freeze
+
+  def perform(session_id, attempt = 1)
+    session = StreamSession.find_by(id: session_id)
+    return unless session&.platform == "youtube"
+    return if session.terminal?
+    return if session.youtube_broadcast_id.blank?
+    return unless LIVE_STATUSES.include?(session.status)
+    return unless Youtube::LivePipeline.broadcast_ready?(session)
+
+    unless Streams::YoutubeRelay.running?(session.id)
+      Streams::YoutubeRelay.ensure_publishing!(session)
+      return reschedule(session_id, attempt + 1) if attempt < MAX_ATTEMPTS
+
+      return
+    end
+
+    result = Youtube::BroadcastService.new(session.match.team).activate_broadcast!(session.youtube_broadcast_id)
+    Rails.logger.info("[YoutubeBroadcastActivate] session=#{session.id} attempt=#{attempt} result=#{result}")
+
+    return if result == :live || result == :transitioned
+
+    if result == :rate_limited
+      reschedule(session_id, attempt, wait: RATE_LIMIT_WAIT)
+      return
+    end
+
+    if result == :broadcast_ended
+      Youtube::SetupBroadcast.recreate!(session.reload)
+      Youtube::LivePipeline.schedule!(session.reload, force: true)
+      return
+    end
+
+    if result == :waiting_ingest && (attempt % 4).zero?
+      Streams::YoutubeRelay.ensure_publishing!(session)
+    end
+
+    return if attempt >= MAX_ATTEMPTS
+
+    reschedule(session_id, attempt + 1)
+  end
+
+  private
+
+  def reschedule(session_id, attempt, wait: RETRY_WAIT)
+    self.class.set(wait: wait).perform_later(session_id, attempt)
+  end
+end

backend/app/jobs/youtube_broadcast_setup_job.rb

@@ -0,0 +1,61 @@
+class YoutubeBroadcastSetupJob < ApplicationJob
+  queue_as :default
+
+  RUN_LOCK_KEY = "youtube_setup:running:%s"
+  MAX_RATE_LIMIT_ATTEMPTS = 15
+  RATE_LIMIT_WAITS = [30, 45, 60, 90, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120].freeze
+
+  def perform(session_id, youtube_channel = nil, attempt = 1)
+    session = StreamSession.find_by(id: session_id)
+    return unless session&.platform == "youtube"
+    return if session.terminal?
+    return if session.youtube_broadcast_id.present? && session.stream_key.present?
+    return unless acquire_run_lock!(session_id, attempt)
+
+    Youtube::SetupBroadcast.call(session, youtube_channel: youtube_channel.presence)
+    release_run_lock!(session_id)
+  rescue Youtube::SetupBroadcast::Error => e
+    if rate_limit?(e) && attempt < MAX_RATE_LIMIT_ATTEMPTS
+      Youtube::ApiThrottle.mark_rate_limited!
+      wait = RATE_LIMIT_WAITS[attempt - 1] || 120
+      extend_run_lock!(session_id, wait + 90)
+      Rails.logger.warn(
+        "[YoutubeBroadcastSetupJob] rate limit session=#{session_id} attempt=#{attempt} retry_in=#{wait}s"
+      )
+      self.class.set(wait: wait.seconds).perform_later(session_id, youtube_channel, attempt + 1)
+      return
+    end
+    release_run_lock!(session_id)
+    raise
+  end
+
+  private
+
+  def rate_limit?(error)
+    msg = error.message.to_s
+    msg.include?("rate limit") ||
+      msg.include?("userRequestsExceedRateLimit") ||
+      msg.include?("temporaneamente occupato")
+  end
+
+  def acquire_run_lock!(session_id, attempt)
+    key = format(RUN_LOCK_KEY, session_id)
+    if attempt > 1
+      return redis.exists?(key).positive?
+    end
+
+    redis.set(key, "1", nx: true, ex: 90)
+  end
+
+  def extend_run_lock!(session_id, seconds)
+    redis.expire(format(RUN_LOCK_KEY, session_id), seconds)
+  end
+
+  def release_run_lock!(session_id)
+    redis.del(format(RUN_LOCK_KEY, session_id))
+  end
+
+  def redis
+    @redis ||= Redis.new(url: ENV.fetch("REDIS_URL", "redis://localhost:6379/0"))
+  end
+end

backend/app/jobs/youtube_ingest_watchdog_job.rb

@@ -0,0 +1,57 @@
+# Controlli ripetuti finché YouTube non ha ingest active (poi attiva la broadcast).
+class YoutubeIngestWatchdogJob < ApplicationJob
+  queue_as :default
+
+  FIRST_WAIT = 20.seconds
+  NEXT_WAITS = [35.seconds, 45.seconds, 60.seconds].freeze
+
+  def perform(session_id, phase = 0)
+    session = StreamSession.find_by(id: session_id)
+    return unless Youtube::LivePipeline.broadcast_ready?(session)
+    return if Youtube::ApiThrottle.rate_limited?
+
+    ingest = youtube_ingest_status(session)
+    if ingest == "active"
+      Youtube::LivePipeline.schedule_activate!(session, force: true, wait: 3.seconds)
+      return
+    end
+
+    if Streams::YoutubeRelay.running?(session.id)
+      Rails.logger.info("[YoutubeIngestWatchdog] relay ok ingest=#{ingest} phase=#{phase} session=#{session.id}")
+    else
+      Rails.logger.warn("[YoutubeIngestWatchdog] avvio relay ingest=#{ingest} session=#{session.id}")
+      Streams::YoutubeRelay.ensure_publishing!(session)
+    end
+
+    schedule_next(session_id, phase)
+  rescue StandardError => e
+    Rails.logger.warn("[YoutubeIngestWatchdog] session=#{session_id}: #{e.message}")
+    schedule_next(session_id, phase)
+  end
+
+  def self.schedule_chain(session_id)
+    set(wait: FIRST_WAIT).perform_later(session_id, 0)
+  end
+
+  private
+
+  def schedule_next(session_id, phase)
+    wait = NEXT_WAITS[phase]
+    return unless wait
+
+    self.class.set(wait: wait).perform_later(session_id, phase + 1)
+  end
+
+  def youtube_ingest_status(session)
+    return nil if session.youtube_broadcast_id.blank?
+
+    client = Youtube::BroadcastService.new(session.match.team).send(:authorized_client)
+    b = client.list_live_broadcasts("status,contentDetails", id: session.youtube_broadcast_id).items&.first
+    return nil unless b
+
+    sid = b.content_details.bound_stream_id
+    client.list_live_streams("status", id: sid).items.first&.status&.stream_status
+  rescue StandardError
+    nil
+  end
+end

backend/app/jobs/youtube_relay_ensure_job.rb

@@ -0,0 +1,11 @@
+# Avvia/riavvia il relay YouTube solo nel container sidekiq (YOUTUBE_RELAY_WORKER=1).
+class YoutubeRelayEnsureJob < ApplicationJob
+  queue_as :default
+
+  def perform(session_id)
+    session = StreamSession.find_by(id: session_id)
+    return unless session
+
+    Streams::YoutubeRelay.ensure_on_worker!(session)
+  end
+end

backend/app/jobs/youtube_relay_stop_job.rb

@@ -0,0 +1,10 @@
+class YoutubeRelayStopJob < ApplicationJob
+  queue_as :default
+
+  def perform(session_id)
+    session = StreamSession.find_by(id: session_id)
+    return unless session
+
+    Streams::YoutubeRelay.stop_on_worker!(session) if Streams::YoutubeRelay.worker?
+  end
+end

backend/app/mailers/application_mailer.rb

@@ -1,4 +1,4 @@
 class ApplicationMailer < ActionMailer::Base
-  default from: "from@example.com"
+  default from: -> { MatchLiveTv.mail_from }
   layout "mailer"
 end

backend/app/mailers/billing/invoice_mailer.rb

@@ -0,0 +1,18 @@
+module Billing
+  class InvoiceMailer < ApplicationMailer
+    def invoice_pdf
+      @invoice = params[:invoice]
+      @club = @invoice.club
+
+      attachments["fattura-#{@invoice.number.parameterize}.pdf"] = {
+        mime_type: "application/pdf",
+        content: @invoice.pdf.download
+      }
+
+      mail(
+        to: @club.billing_email,
+        subject: "Fattura #{@invoice.display_number} — Match Live TV"
+      )
+    end
+  end
+end

backend/app/mailers/ops/alert_mailer.rb

@@ -0,0 +1,11 @@
+module Ops
+  class AlertMailer < ApplicationMailer
+    def incident(incident)
+      @incident = incident
+      mail(
+        to: ENV.fetch("OPS_ALERT_EMAIL"),
+        subject: "[Match Live TV Ops] #{incident.severity.upcase}: #{incident.title}"
+      )
+    end
+  end
+end

backend/app/mailers/recordings/replay_mailer.rb

@@ -0,0 +1,34 @@
+module Recordings
+  class ReplayMailer < ApplicationMailer
+    default from: -> { MatchLiveTv.mail_from }
+
+    def replay_ready(recording:, recipient:)
+      @recording = recording
+      @team = recording.team
+      @club = @team.club
+      @recipient = recipient
+      @replay_url = recording.replay_url
+      @expires_at = recording.expires_at
+
+      mail(
+        to: recipient.email,
+        subject: "Replay pronto — #{recording.title_or_default}"
+      )
+    end
+
+    def replay_expiring_soon(recording:, recipient:)
+      @recording = recording
+      @team = recording.team
+      @club = @team.club
+      @recipient = recipient
+      @replay_url = recording.replay_url
+      @expires_at = recording.expires_at
+      @days_left = ((recording.expires_at - Time.current) / 1.day).ceil
+
+      mail(
+        to: recipient.email,
+        subject: "Replay in scadenza tra #{@days_left} giorni — #{recording.title_or_default}"
+      )
+    end
+  end
+end

backend/app/mailers/user_mailer.rb

@@ -0,0 +1,11 @@
+class UserMailer < ApplicationMailer
+  default from: -> { MatchLiveTv.mail_from }
+
+  def password_reset(user, token)
+    @user = user
+    @reset_url = public_password_reset_url(token: token)
+    @expiry_hours = MatchLiveTv.password_reset_expiry_hours
+
+    mail to: user.email, subject: "Reimposta la password — Match Live TV"
+  end
+end

backend/app/models/admin_account.rb

@@ -0,0 +1,5 @@
+class AdminAccount < ApplicationRecord
+  has_secure_password
+
+  validates :username, presence: true, uniqueness: true
+end

backend/app/models/billing/invoice.rb

@@ -0,0 +1,63 @@
+module Billing
+  class Invoice < ApplicationRecord
+    self.table_name = "billing_invoices"
+
+    STATUSES = %w[draft issued sent cancelled].freeze
+    SOURCES = %w[manual aruba].freeze
+
+    belongs_to :club
+    belongs_to :billing_payment, class_name: "Billing::Payment", optional: true
+    has_one_attached :pdf
+
+    validates :number, presence: true, uniqueness: { scope: :club_id }
+    validates :issued_on, presence: true
+    validates :amount_cents, numericality: { greater_than: 0 }
+    validates :currency, presence: true
+    validates :status, inclusion: { in: STATUSES }
+    validates :source, inclusion: { in: SOURCES }
+    validates :billing_payment_id, uniqueness: true, allow_nil: true
+    validate :pdf_present_when_issued, on: :issue
+
+    scope :recent, -> { order(issued_on: :desc, created_at: :desc) }
+
+    def amount_euros
+      amount_cents / 100.0
+    end
+
+    def formatted_amount
+      format("%.2f €", amount_euros)
+    end
+
+    def downloadable?
+      pdf.attached? && status.in?(%w[issued sent])
+    end
+
+    def draft?
+      status == "draft"
+    end
+
+    def display_number
+      n = number.to_s.strip
+      cleaned = n.gsub(/\baruba[-_\s]*/i, "").strip
+      cleaned.presence || n
+    end
+
+    def display_status
+      {
+        "draft" => "In preparazione",
+        "issued" => "Emessa",
+        "sent" => "Inviata",
+        "cancelled" => "Annullata"
+      }[status] || status
+    end
+
+    private
+
+    def pdf_present_when_issued
+      return unless validation_context == :issue
+      return if pdf.attached?
+
+      errors.add(:pdf, "è obbligatorio per emettere la fattura")
+    end
+  end
+end

backend/app/models/billing/payment.rb

@@ -0,0 +1,72 @@
+module Billing
+  class Payment < ApplicationRecord
+    self.table_name = "billing_payments"
+
+    STATUSES = %w[paid failed refunded].freeze
+
+    belongs_to :club
+    has_one :invoice, class_name: "Billing::Invoice", foreign_key: :billing_payment_id, dependent: :nullify
+
+    validates :amount_cents, numericality: { greater_than: 0 }
+    validates :currency, presence: true
+    validates :status, inclusion: { in: STATUSES }
+    validates :stripe_invoice_id, uniqueness: true, allow_nil: true
+
+    scope :recent, -> { order(paid_at: :desc, created_at: :desc) }
+
+    # Pagamenti pagati senza PDF fattura caricato (da gestire in admin).
+    scope :awaiting_invoice_pdf, lambda {
+      where(status: "paid").where(
+        <<~SQL.squish,
+          NOT EXISTS (
+            SELECT 1 FROM billing_invoices bi
+            INNER JOIN active_storage_attachments asa
+              ON asa.record_type = 'Billing::Invoice'
+              AND asa.record_id = bi.id
+              AND asa.name = 'pdf'
+            WHERE bi.billing_payment_id = billing_payments.id
+          )
+        SQL
+      )
+    }
+
+    scope :with_invoice_pdf, lambda {
+      where(status: "paid").where(
+        <<~SQL.squish,
+          EXISTS (
+            SELECT 1 FROM billing_invoices bi
+            INNER JOIN active_storage_attachments asa
+              ON asa.record_type = 'Billing::Invoice'
+              AND asa.record_id = bi.id
+              AND asa.name = 'pdf'
+            WHERE bi.billing_payment_id = billing_payments.id
+          )
+        SQL
+      )
+    }
+
+    def awaiting_invoice_pdf?
+      status == "paid" && !invoice&.pdf&.attached?
+    end
+
+    def amount_euros
+      amount_cents / 100.0
+    end
+
+    def formatted_amount
+      format("%.2f €", amount_euros)
+    end
+
+    def display_description
+      PaymentDescription.for_payment(self)
+    end
+
+    def display_status
+      { "paid" => "Pagato", "failed" => "Non riuscito", "refunded" => "Rimborsato" }[status] || status
+    end
+
+    def invoice_for_display
+      invoice
+    end
+  end
+end

backend/app/models/club.rb

@@ -0,0 +1,31 @@
+class Club < ApplicationRecord
+  include Brandable
+  include ClubBillingProfile
+
+  has_many :club_memberships, dependent: :destroy
+  has_many :users, through: :club_memberships
+  has_many :teams, dependent: :destroy
+  has_one :youtube_credential, dependent: :destroy
+  has_one :subscription, dependent: :destroy
+  has_many :billing_payments, class_name: "Billing::Payment", dependent: :destroy
+  has_many :billing_invoices, class_name: "Billing::Invoice", dependent: :destroy
+
+  validates :name, presence: true
+  validates :sport, presence: true
+  validates :primary_color, presence: true
+  validates :secondary_color, presence: true
+
+  def owner
+    club_memberships.find_by(role: "owner")&.user
+  end
+
+  def owned_by?(user)
+    club_memberships.exists?(user: user, role: "owner")
+  end
+
+  private
+
+  def branding_parent
+    nil
+  end
+end

backend/app/models/club_membership.rb

@@ -0,0 +1,9 @@
+class ClubMembership < ApplicationRecord
+  ROLES = %w[owner].freeze
+
+  belongs_to :user
+  belongs_to :club
+
+  validates :role, inclusion: { in: ROLES }
+  validates :user_id, uniqueness: { scope: :club_id }
+end

backend/app/models/concerns/brandable.rb

@@ -0,0 +1,43 @@
+module Brandable
+  extend ActiveSupport::Concern
+
+  HEX_COLOR = /\A#[0-9A-Fa-f]{6}\z/
+
+  included do
+    has_one_attached :logo_file
+    validates :primary_color, format: { with: HEX_COLOR }, allow_blank: true
+    validates :secondary_color, format: { with: HEX_COLOR }, allow_blank: true
+  end
+
+  def effective_primary_color
+    primary_color.presence || default_primary_color
+  end
+
+  def effective_secondary_color
+    secondary_color.presence || default_secondary_color
+  end
+
+  def effective_logo_url
+    if logo_file.attached?
+      Rails.application.routes.url_helpers.rails_blob_path(logo_file, only_path: true)
+    elsif logo_url.present?
+      logo_url
+    else
+      branding_parent&.effective_logo_url
+    end
+  end
+
+  private
+
+  def default_primary_color
+    "#e53935"
+  end
+
+  def default_secondary_color
+    "#ffffff"
+  end
+
+  def branding_parent
+    nil
+  end
+end

backend/app/models/concerns/club_billing_profile.rb

@@ -0,0 +1,79 @@
+module ClubBillingProfile
+  extend ActiveSupport::Concern
+
+  BILLING_ENTITY_TYPES = {
+    "company" => "Società / ASD con P.IVA",
+    "individual" => "Persona fisica",
+    "nonprofit" => "Associazione senza scopo di lucro"
+  }.freeze
+
+  included do
+    validates :billing_entity_type, inclusion: { in: BILLING_ENTITY_TYPES.keys }, allow_nil: true
+    validates :billing_email, format: { with: URI::MailTo::EMAIL_REGEXP }, allow_blank: true
+    validates :billing_recipient_code, length: { is: 7 }, allow_blank: true
+    validates :billing_province, length: { is: 2 }, allow_blank: true
+    validates :billing_country, length: { is: 2 }, allow_blank: true
+    validate :billing_profile_for_invoicing, on: :billing_profile
+  end
+
+  def billing_profile_complete?
+    billing_profile_errors.empty?
+  end
+
+  # Campi minimi per intestazione fattura e invio (email PDF + SDI/PEC).
+  def billing_profile_errors
+    errors = []
+    errors << "Tipo intestatario" if billing_entity_type.blank?
+    errors << "Ragione sociale o nome intestatario" if billing_legal_name.blank?
+    errors << "Email di fatturazione" if billing_email.blank?
+    errors << "Indirizzo" if billing_address_line.blank?
+    errors << "Città" if billing_city.blank?
+    errors << "Provincia (sigla 2 lettere)" if billing_province.blank? || billing_province.to_s.length != 2
+    errors << "CAP" if billing_postal_code.blank?
+    errors << "Paese (ISO)" if billing_country.blank? || billing_country.to_s.length != 2
+    errors.concat(billing_tax_id_errors)
+    errors << "Codice destinatario SDI (7 caratteri) o PEC" if billing_recipient_code.blank? && billing_pec.blank?
+    errors << "Codice destinatario SDI (7 caratteri)" if billing_recipient_code.present? && billing_recipient_code.length != 7
+    errors
+  end
+
+  def billing_tax_id_errors
+    case billing_entity_type
+    when "company"
+      billing_vat_number.blank? ? ["Partita IVA"] : []
+    when "individual"
+      billing_fiscal_code.blank? ? ["Codice Fiscale"] : []
+    else
+      billing_vat_number.blank? && billing_fiscal_code.blank? ? ["P.IVA o Codice Fiscale"] : []
+    end
+  end
+
+  def billing_profile_summary
+    parts = [billing_legal_name.presence, billing_vat_number.presence && "P.IVA #{billing_vat_number}"]
+    parts.compact.join(" · ")
+  end
+
+  # Righe per intestazione fattura in admin (etichetta, valore).
+  def billing_profile_invoice_lines
+    lines = []
+    lines << ["Tipo", BILLING_ENTITY_TYPES[billing_entity_type]] if billing_entity_type.present?
+    lines << ["Intestatario", billing_legal_name]
+    lines << ["P.IVA", billing_vat_number] if billing_vat_number.present?
+    lines << ["Codice fiscale", billing_fiscal_code] if billing_fiscal_code.present?
+    lines << ["Email fatturazione", billing_email]
+    lines << ["Telefono", billing_phone] if billing_phone.present?
+    addr = [billing_address_line, billing_postal_code, billing_city, billing_province, billing_country].compact.join(", ")
+    lines << ["Indirizzo", addr] if addr.present?
+    lines << ["SDI", billing_recipient_code] if billing_recipient_code.present?
+    lines << ["PEC", billing_pec] if billing_pec.present?
+    lines
+  end
+
+  private
+
+  def billing_profile_for_invoicing
+    billing_profile_errors.each do |message|
+      errors.add(:base, message)
+    end
+  end
+end

backend/app/models/match.rb

@@ -2,6 +2,176 @@ class Match < ApplicationRecord
   belongs_to :team
   has_many :stream_sessions, dependent: :destroy
 
+  has_one_attached :opponent_logo_file
+
+  ACTIVE_SESSION_STATUSES = %w[live connecting reconnecting paused].freeze
+  DEFAULT_OPPONENT_COLOR = "#1E3A8A"
+
   validates :opponent_name, presence: true
   validates :sets_to_win, numericality: { greater_than: 0, less_than: 6 }
+  validates :sport_key, presence: true
+  validates :opponent_primary_color, format: { with: Brandable::HEX_COLOR }, allow_blank: true
+  validate :sport_key_known
+  validate :overlay_kind_allowed
+  validate :scoring_rules_shape
+  validate :opponent_logo_file_type, if: -> { opponent_logo_file.attached? }
+
+  before_validation :normalize_sport_key
+  before_validation :inherit_sport_from_team, on: :create
+
+  scope :scheduled_for_live, -> {
+    where.not(scheduled_at: nil).where("scheduled_at >= ?", Time.zone.now)
+  }
+
+  scope :scheduled_upcoming, -> { scheduled_for_live }
+
+  def scheduled_upcoming?
+    scheduled_at.present? && scheduled_at >= Time.zone.now
+  end
+
+  def scheduled_on_calendar?
+    scheduled_at.present? && scheduled_at >= Time.zone.now.beginning_of_day
+  end
+
+  def active_stream_session
+    latest = stream_sessions.max_by(&:created_at)
+    return nil if latest.nil? || latest.status.in?(%w[ended error])
+
+    latest
+  end
+
+  def deletable?
+    session = active_stream_session
+    session.nil? || !session.resumable?
+  end
+
+  def public_status_label
+    active = active_stream_session
+    return "In corso / da riprendere" if active
+    return "Programmata" if scheduled_upcoming?
+    return "Pronta" if scheduled_at.present?
+
+    "Senza orario"
+  end
+
+  scope :search_teams_or_opponents, lambda { |query|
+    q = query.to_s.strip
+    return all if q.blank?
+
+    term = "%#{sanitize_sql_like(q)}%"
+    joins(team: :club).where(
+      "teams.name ILIKE :term OR matches.opponent_name ILIKE :term OR clubs.name ILIKE :term OR matches.location ILIKE :term",
+      term: term
+    )
+  }
+
+  def broadcast_active?
+    stream_sessions.where(status: ACTIVE_SESSION_STATUSES).exists?
+  end
+
+  def stream_completed?
+    stream_sessions.where(status: %w[ended error]).exists?
+  end
+
+  def opponent_logo_url
+    return unless opponent_logo_file.attached?
+
+    Rails.application.routes.url_helpers.rails_blob_path(opponent_logo_file, only_path: true)
+  end
+
+  def effective_opponent_primary_color
+    opponent_primary_color.presence || DEFAULT_OPPONENT_COLOR
+  end
+
+  def coach_hub_visible?
+    active = active_stream_session
+    return true if active&.resumable?
+    return true if active&.idle?
+
+    return false if stream_completed?
+
+    scheduled_upcoming?
+  end
+
+  def effective_board_type
+    Sports::Catalog.board_for(sport_key)
+  end
+
+  def effective_overlay_kind
+    kind = overlay_kind.presence || Sports::Catalog.overlay_for(sport_key)
+    kind = "none" if kind == "timer"
+    allowed = Sports::Catalog.allowed_overlays_for(sport_key)
+    allowed.include?(kind) ? kind : Sports::Catalog.overlay_for(sport_key)
+  end
+
+  def effective_scoring_rules
+    merged = Sports::Catalog.default_rules_for(sport_key).deep_merge(normalized_scoring_rules)
+    merged["sets_to_win"] = sets_to_win if merged["sets_to_win"].blank? && sets_to_win.present?
+    merged
+  end
+
+  def sport_label
+    Sports::Catalog.find_optional(sport_key)&.dig(:label) || sport_key.to_s.humanize
+  end
+
+  # Alias legacy API/spec (colonna rinominata in sport_key).
+  def sport
+    sport_key
+  end
+
+  def sport=(value)
+    self.sport_key = Sports::Catalog.normalize_key(value)
+  end
+
+  private
+
+  def normalize_sport_key
+    self.sport_key = Sports::Catalog.normalize_key(sport_key)
+  end
+
+  def inherit_sport_from_team
+    return unless team.present?
+
+    # Il default DB (pallavolo) non deve prevalere sullo sport della squadra alla creazione.
+    self.sport_key = team.sport_key if new_record? || sport_key.blank?
+  end
+
+  def sport_key_known
+    return if sport_key.blank?
+    return if Sports::Catalog.find_optional(sport_key)
+
+    errors.add(:sport_key, "non valido")
+  end
+
+  def overlay_kind_allowed
+    return if overlay_kind.blank?
+
+    unless Sports::OverlayKind.valid?(overlay_kind)
+      errors.add(:overlay_kind, "non valido")
+      return
+    end
+
+    allowed = Sports::Catalog.allowed_overlays_for(sport_key)
+    errors.add(:overlay_kind, "non consentito per questo sport") unless allowed.include?(overlay_kind)
+  end
+
+  def normalized_scoring_rules
+    return {} unless scoring_rules.is_a?(Hash)
+
+    scoring_rules.each_with_object({}) do |(k, v), h|
+      h[k.to_s] = v
+    end
+  end
+
+  def opponent_logo_file_type
+    return if opponent_logo_file.content_type.in?(%w[image/png image/jpeg image/webp])
+
+    errors.add(:opponent_logo_file, "deve essere PNG, JPEG o WebP")
+  end
+
+  def scoring_rules_shape
+    Sports::RulesSchema.validate!(effective_board_type, normalized_scoring_rules)
+  rescue ArgumentError => e
+    errors.add(:scoring_rules, e.message)
+  end
 end

backend/app/models/ops/incident.rb

@@ -0,0 +1,43 @@
+module Ops
+  class Incident < ApplicationRecord
+    self.table_name = "ops_incidents"
+
+    KINDS = %w[
+      disk_space recordings_size service_down http_public http_rails rails_latency
+      sidekiq_stale sidekiq_dead log_pattern garage_storage
+    ].freeze
+    SEVERITIES = %w[critical warning info].freeze
+    STATUSES = %w[open acknowledged resolved].freeze
+
+    validates :kind, :severity, :status, :title, :fingerprint, presence: true
+    validates :severity, inclusion: { in: SEVERITIES }
+    validates :status, inclusion: { in: STATUSES }
+    validates :occurrence_count, numericality: { greater_than: 0 }
+
+    scope :open, -> { where(status: %w[open acknowledged]) }
+    scope :unresolved, -> { where.not(status: "resolved") }
+    scope :critical_open, -> { open.where(severity: "critical") }
+    scope :recent, -> { order(last_seen_at: :desc) }
+    scope :since, ->(time) { where("last_seen_at >= ?", time) }
+
+    def open?
+      status.in?(%w[open acknowledged])
+    end
+
+    def muted?
+      muted_until.present? && muted_until.future?
+    end
+
+    def acknowledge!
+      update!(status: "acknowledged", acknowledged_at: Time.current)
+    end
+
+    def resolve!
+      update!(status: "resolved")
+    end
+
+    def mute!(duration: 24.hours)
+      update!(muted_until: duration.from_now)
+    end
+  end
+end

backend/app/models/plan.rb

@@ -16,10 +16,20 @@ class Plan < ApplicationRecord
     find_by!(slug: slug.to_s)
   end
 
-  def allows_platform?(platform)
-    return false if platform.to_s == "youtube" && !youtube_enabled?
+  def self.tier(slug)
+    SLUGS.index(slug.to_s) || 0
+  end
 
-    Array(features["platforms"]).map(&:to_s).include?(platform.to_s)
+  def tier
+    self.class.tier(slug)
+  end
+
+  def allows_platform?(platform)
+    platform = platform.to_s
+    return false if platform == "youtube" && !youtube_enabled?
+    return true if platform == "youtube" && youtube_mode == "matchlivetv_light"
+
+    Array(features["platforms"]).map(&:to_s).include?(platform)
   end
 
   def feature(key)

backend/app/models/recording.rb

@@ -1,21 +1,182 @@
 class Recording < ApplicationRecord
-  STATUSES = %w[processing ready expired].freeze
+  STATUSES = %w[processing ready expired failed].freeze
+  PRIVACY_STATUSES = %w[public unlisted].freeze
+  STORAGE_BACKENDS = %w[local s3].freeze
 
   belongs_to :stream_session
   belongs_to :team
 
   validates :status, inclusion: { in: STATUSES }
+  validates :privacy_status, inclusion: { in: PRIVACY_STATUSES }
+  validates :storage_backend, inclusion: { in: STORAGE_BACKENDS }
 
-  scope :ready, -> { where(status: "ready").where("expires_at IS NULL OR expires_at > ?", Time.current) }
+  scope :not_deleted, -> { where(deleted_at: nil) }
+  scope :ready, lambda {
+    not_deleted.where(status: "ready").where("expires_at IS NULL OR expires_at > ?", Time.current)
+  }
+  scope :publicly_listed, -> { where(privacy_status: "public") }
   scope :for_team, ->(team) { where(team: team) }
+  scope :for_club, lambda { |club|
+    joins(:team).where(teams: { club_id: club.id })
+  }
+  scope :expiring_within, lambda { |days|
+    ready.where(expires_at: ..days.days.from_now)
+  }
+  scope :expired_pending_purge, lambda {
+    not_deleted.where(status: %w[ready failed]).where("expires_at IS NOT NULL AND expires_at <= ?", Time.current)
+  }
+  scope :search_replays, lambda { |query|
+    q = query.to_s.strip
+    return all if q.blank?
+
+    term = "%#{sanitize_sql_like(q)}%"
+    joins(stream_session: { match: { team: :club } }).where(
+      "recordings.title ILIKE :term OR teams.name ILIKE :term OR matches.opponent_name ILIKE :term OR clubs.name ILIKE :term OR matches.location ILIKE :term",
+      term: term
+    )
+  }
+
+  before_validation :normalize_privacy_status
 
   def replay_url
-    return nil unless ready? && stream_session_id.present?
+    return nil unless stream_session_id.present?
+    return nil unless ready? || status == "processing"
 
     "#{MatchLiveTv.app_public_url.chomp('/')}/replay/#{stream_session_id}"
   end
 
+  def playback_stream_url
+    return nil unless ready? && stream_session_id.present?
+
+    "#{MatchLiveTv.app_public_url.chomp('/')}/replay/#{stream_session_id}/stream"
+  end
+
+  def thumbnail_url
+    return nil unless thumbnail_storage_key.present? && stream_session_id.present?
+
+    "#{MatchLiveTv.app_public_url.chomp('/')}/replay/#{stream_session_id}/thumbnail"
+  end
+
+  def download_api_path
+    return nil unless ready?
+
+    "/api/v1/recordings/#{id}/download"
+  end
+
+  def youtube_watch_url
+    return nil if youtube_video_id.blank?
+    return nil if youtube_video_id.to_s.start_with?("mock_")
+
+    "https://www.youtube.com/watch?v=#{youtube_video_id}"
+  end
+
   def ready?
-    status == "ready" && (expires_at.nil? || expires_at.future?)
+    status == "ready" && !deleted? && (expires_at.nil? || expires_at.future?)
+  end
+
+  def deleted?
+    deleted_at.present?
+  end
+
+  def publicly_listed?
+    privacy_status == "public"
+  end
+
+  def unlisted?
+    privacy_status == "unlisted"
+  end
+
+  def auto_publish_youtube?
+    metadata.is_a?(Hash) && metadata["auto_publish_youtube"] == true
+  end
+
+  def ai_metadata
+    metadata.fetch("ai", {})
+  end
+
+  def merge_metadata!(attrs)
+    update!(metadata: metadata.merge(attrs.stringify_keys))
+  end
+
+  def title_or_default
+    title.presence || default_title
+  end
+
+  def default_title
+    match = stream_session&.match
+    return "Replay" unless match
+
+    "#{match.team.name} vs #{match.opponent_name}"
+  end
+
+  def recorded_at_or_fallback
+    recorded_at || stream_session&.ended_at || stream_session&.started_at || created_at
+  end
+
+  def duration_label
+    return "—" if duration_secs.to_i <= 0
+
+    mins = duration_secs / 60
+    secs = duration_secs % 60
+    format("%d:%02d", mins, secs)
+  end
+
+  def byte_size_label
+    bytes = byte_size.to_i
+    return "—" if bytes <= 0
+
+    if bytes >= 1.gigabyte
+      format("%.1f GB", bytes / 1.gigabyte.to_f)
+    elsif bytes >= 1.megabyte
+      format("%.1f MB", bytes / 1.megabyte.to_f)
+    else
+      format("%.0f KB", bytes / 1.kilobyte.to_f)
+    end
+  end
+
+  def views_label
+    count = view_count.to_i
+    return "0 visualizzazioni" if count.zero?
+
+    count == 1 ? "1 visualizzazione" : "#{count} visualizzazioni"
+  end
+
+  def source_platform
+    metadata.is_a?(Hash) ? metadata["source_platform"].presence : nil
+  end
+
+  def source_platform_label
+    case source_platform
+    when "youtube" then "YouTube"
+    when "matchlivetv" then "Match Live TV"
+    else "—"
+    end
+  end
+
+  def playable_on_site?
+    ready? && storage_key.present?
+  end
+
+  def days_until_expiry
+    return nil unless expires_at
+
+    ((expires_at - Time.current) / 1.day).ceil
+  end
+
+  def status_label
+    return "Eliminato" if deleted?
+    return "Scaduto" if status == "expired"
+    return "Errore" if status == "failed"
+    return "In elaborazione" if status == "processing"
+    return "Scade presto" if expires_at.present? && expires_at <= 7.days.from_now
+
+    "Disponibile"
+  end
+
+  private
+
+  def normalize_privacy_status
+    self.privacy_status = "public" if privacy_status == "private"
+    self.privacy_status = "unlisted" if privacy_status.blank?
   end
 end

backend/app/models/score_state.rb

@@ -1,9 +1,12 @@
 class ScoreState < ApplicationRecord
   belongs_to :stream_session
 
+  before_validation :sync_board_type_from_match, on: :create
+
   def as_cable_payload
-    {
+    payload = {
       type: "score_update",
+      board_type: effective_board_type,
       home_sets: home_sets,
       away_sets: away_sets,
       home_points: home_points,
@@ -11,7 +14,74 @@ class ScoreState < ApplicationRecord
       current_set: current_set,
       set_partials: set_partials || [],
       timeout_home: timeout_home,
-      timeout_away: timeout_away
+      timeout_away: timeout_away,
+      period: period,
+      data: data || {}
     }
+
+    case effective_board_type
+    when "basket", "timed"
+      payload[:home_points] = basket_home_score
+      payload[:away_points] = basket_away_score
+      payload[:period] = current_period_label
+      payload[:clock_secs] = clock_secs
+      payload[:clock_running] = clock_running?
+    when "timer"
+      payload[:clock_secs] = clock_secs
+      payload[:clock_running] = clock_running?
+    end
+
+    payload
+  end
+
+  def effective_board_type
+    board_type.presence || stream_session&.match&.effective_board_type || "volley"
+  end
+
+  def basket_home_score
+    (data || {})["home_score"].to_i
+  end
+
+  def basket_away_score
+    (data || {})["away_score"].to_i
+  end
+
+  def clock_secs
+    (data || {})["clock_secs"].to_i
+  end
+
+  def clock_running?
+    !!(data || {})["clock_running"]
+  end
+
+  def current_period
+    Scoring::PeriodData.number_from((data || {})["period"]) || 1
+  end
+
+  def current_period_label
+    case effective_board_type
+    when "basket"
+      ot = (data || {})["overtime"]
+      return "OT#{current_period - rules_periods}" if ot
+
+      "Q#{current_period}"
+    when "timed"
+      ot = (data || {})["overtime"]
+      return "Suppl." if ot
+
+      "#{current_period}° tempo"
+    else
+      period.presence || "#{current_set}° set"
+    end
+  end
+
+  private
+
+  def sync_board_type_from_match
+    self.board_type = stream_session.match.effective_board_type if board_type.blank? && stream_session&.match
+  end
+
+  def rules_periods
+    stream_session&.match&.effective_scoring_rules&.dig("periods").to_i
   end
 end