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

@@ -0,0 +1,36 @@
+# Ruby
+backend/.bundle
+backend/vendor/bundle
+backend/tmp/
+backend/log/
+backend/storage/
+backend/.env
+backend/.env.*
+
+# Flutter
+mobile/.dart_tool/
+mobile/.flutter-plugins
+mobile/.flutter-plugins-dependencies
+mobile/build/
+mobile/.packages
+mobile/pubspec.lock
+
+# Infra
+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
+*.swp
+.idea/
+.vscode/
+
+# Secrets
+.env
+*.pem
+credentials.json

README.md

@@ -1,3 +1,76 @@
-# MatchLiveTv
+# Match Live TV
 
-Piattaforma di live streaming per sport dilettantistico con regia remota, gestione squadre, streaming mobile e archivio partite.
+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:** *Ogni partita, ogni evento, per i tuoi tifosi.*
+
+## Struttura monorepo
+
+```
+├── 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)
+
+Vedi [docs/infrastructure/SERVER_DEPLOYMENT.md](docs/infrastructure/SERVER_DEPLOYMENT.md) per porte router, NPM e procedura completa.
+
+**Porte da aprire sul router:** `1935/TCP` (RTMP). Opzionale `8888/TCP` (HLS). HTTPS via Nginx Proxy Manager verso `http://192.168.1.146:3000`.
+
+**Sul server (una tantum, con sudo):**
+```bash
+sudo bash ~/matchlivetv/scripts/deploy/server_bootstrap.sh
+bash ~/matchlivetv/scripts/deploy/post_bootstrap_deploy.sh
+```
+
+## Avvio rapido (locale)
+
+```bash
+cd infra
+cp .env.example .env
+docker compose up -d --build
+```
+
+- API Rails: http://localhost:3000
+- MediaMTX RTMP: rtmp://localhost:1935
+- MediaMTX API: http://localhost:9997
+- Admin: http://localhost:3000/admin
+
+### Seed utente demo
+
+```
+email: coach@matchlivetv.test
+password: password123
+```
+
+## App Android nativa
+
+```bash
+./scripts/build_native_android_apk_prod.sh
+adb install -r native/android/app/build/outputs/apk/release/app-release.apk
+```
+
+API produzione: `https://www.matchlivetv.it` (override con `-PAPI_BASE_URL=...` in Gradle).
+
+Vedi [native/android/README.md](native/android/README.md).
+
+## Architettura
+
+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)
+
+### App Android produzione
+
+```bash
+./scripts/build_native_android_apk_prod.sh
+# API: https://www.matchlivetv.it
+```

backend/.dockerignore

@@ -0,0 +1,42 @@
+# See https://docs.docker.com/engine/reference/builder/#dockerignore-file for more about ignoring files.
+
+# Ignore git directory.
+/.git/
+/.gitignore
+
+# Ignore bundler config.
+/.bundle
+
+# Ignore all environment files (except templates).
+/.env*
+!/.env*.erb
+
+# Ignore all default key files.
+/config/master.key
+/config/credentials/*.key
+
+# Ignore all logfiles and tempfiles.
+/log/*
+/tmp/*
+!/log/.keep
+!/tmp/.keep
+
+# Ignore pidfiles, but keep the directory.
+/tmp/pids/*
+!/tmp/pids/.keep
+
+# Ignore storage (uploaded files in development and any SQLite databases).
+/storage/*
+!/storage/.keep
+/tmp/storage/*
+!/tmp/storage/.keep
+
+# Ignore CI service files.
+/.github
+
+# Ignore development files
+/.devcontainer
+
+# Ignore Docker-related files
+/.dockerignore
+/Dockerfile*

backend/.gitattributes

@@ -0,0 +1,9 @@
+# See https://git-scm.com/docs/gitattributes for more about git attribute files.
+
+# Mark the database schema as having been generated.
+db/schema.rb linguist-generated
+
+# Mark any vendored files as having been vendored.
+vendor/* linguist-vendored
+config/credentials/*.yml.enc diff=rails_credentials
+config/credentials.yml.enc diff=rails_credentials

backend/.github/dependabot.yml

@@ -0,0 +1,12 @@
+version: 2
+updates:
+- package-ecosystem: bundler
+  directory: "/"
+  schedule:
+    interval: daily
+  open-pull-requests-limit: 10
+- package-ecosystem: github-actions
+  directory: "/"
+  schedule:
+    interval: daily
+  open-pull-requests-limit: 10

backend/.github/workflows/ci.yml

@@ -0,0 +1,39 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches: [ main ]
+
+jobs:
+  scan_ruby:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: .ruby-version
+          bundler-cache: true
+
+      - name: Scan for common Rails security vulnerabilities using static analysis
+        run: bin/brakeman --no-pager
+
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: .ruby-version
+          bundler-cache: true
+
+      - name: Lint code for consistent style
+        run: bin/rubocop -f github
+

backend/.gitignore

@@ -0,0 +1,33 @@
+# See https://help.github.com/articles/ignoring-files for more about ignoring files.
+#
+# Temporary files generated by your text editor or operating system
+# belong in git's global ignore instead:
+# `$XDG_CONFIG_HOME/git/ignore` or `~/.config/git/ignore`
+
+# Ignore bundler config.
+/.bundle
+
+# Ignore all environment files (except templates).
+/.env*
+!/.env*.erb
+
+# Ignore all logfiles and tempfiles.
+/log/*
+/tmp/*
+!/log/.keep
+!/tmp/.keep
+
+# Ignore pidfiles, but keep the directory.
+/tmp/pids/*
+!/tmp/pids/
+!/tmp/pids/.keep
+
+# Ignore storage (uploaded files in development and any SQLite databases).
+/storage/*
+!/storage/.keep
+/tmp/storage/*
+!/tmp/storage/
+!/tmp/storage/.keep
+
+# Ignore master key for decrypting credentials and more.
+/config/master.key

backend/.rubocop.yml

@@ -0,0 +1,8 @@
+# Omakase Ruby styling for Rails
+inherit_gem: { rubocop-rails-omakase: rubocop.yml }
+
+# Overwrite or add rules to create your own house style
+#
+# # Use `[a, [b, c]]` not `[ a, [ b, c ] ]`
+# Layout/SpaceInsideArrayLiteralBrackets:
+#   Enabled: false

backend/.ruby-version

@@ -0,0 +1 @@
+ruby-3.3.11

backend/Dockerfile

@@ -0,0 +1,19 @@
+FROM ruby:3.3-bookworm
+
+RUN apt-get update -qq && \
+    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
+
+ENV BUNDLE_WITHOUT="development:test"
+ENV BUNDLE_DEPLOYMENT="1"
+
+COPY Gemfile Gemfile.lock ./
+RUN bundle install
+
+COPY . .
+
+EXPOSE 3000
+
+CMD ["bundle", "exec", "puma", "-C", "config/puma.rb", "-b", "tcp://0.0.0.0:3000"]

backend/Gemfile

@@ -0,0 +1,36 @@
+source "https://rubygems.org"
+
+gem "rails", "~> 7.2.2"
+gem "pg", "~> 1.1"
+gem "puma", ">= 5.0"
+gem "bootsnap", require: false
+gem "tzinfo-data", platforms: %i[ windows jruby ]
+
+gem "redis", ">= 4.0.1"
+gem "bcrypt", "~> 3.1.7"
+gem "rack-cors"
+gem "jwt"
+gem "sidekiq"
+gem "rack-attack"
+gem "aasm"
+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"
+  gem "brakeman", require: false
+  gem "rubocop-rails-omakase", require: false
+  gem "rspec-rails"
+  gem "factory_bot_rails"
+  gem "faker"
+end
+
+group :development do
+  gem "letter_opener"
+end

backend/Gemfile.lock

@@ -0,0 +1,473 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    aasm (5.5.2)
+      concurrent-ruby (~> 1.0)
+    actioncable (7.2.3.1)
+      actionpack (= 7.2.3.1)
+      activesupport (= 7.2.3.1)
+      nio4r (~> 2.0)
+      websocket-driver (>= 0.6.1)
+      zeitwerk (~> 2.6)
+    actionmailbox (7.2.3.1)
+      actionpack (= 7.2.3.1)
+      activejob (= 7.2.3.1)
+      activerecord (= 7.2.3.1)
+      activestorage (= 7.2.3.1)
+      activesupport (= 7.2.3.1)
+      mail (>= 2.8.0)
+    actionmailer (7.2.3.1)
+      actionpack (= 7.2.3.1)
+      actionview (= 7.2.3.1)
+      activejob (= 7.2.3.1)
+      activesupport (= 7.2.3.1)
+      mail (>= 2.8.0)
+      rails-dom-testing (~> 2.2)
+    actionpack (7.2.3.1)
+      actionview (= 7.2.3.1)
+      activesupport (= 7.2.3.1)
+      cgi
+      nokogiri (>= 1.8.5)
+      racc
+      rack (>= 2.2.4, < 3.3)
+      rack-session (>= 1.0.1)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.2)
+      rails-html-sanitizer (~> 1.6)
+      useragent (~> 0.16)
+    actiontext (7.2.3.1)
+      actionpack (= 7.2.3.1)
+      activerecord (= 7.2.3.1)
+      activestorage (= 7.2.3.1)
+      activesupport (= 7.2.3.1)
+      globalid (>= 0.6.0)
+      nokogiri (>= 1.8.5)
+    actionview (7.2.3.1)
+      activesupport (= 7.2.3.1)
+      builder (~> 3.1)
+      cgi
+      erubi (~> 1.11)
+      rails-dom-testing (~> 2.2)
+      rails-html-sanitizer (~> 1.6)
+    activejob (7.2.3.1)
+      activesupport (= 7.2.3.1)
+      globalid (>= 0.3.6)
+    activemodel (7.2.3.1)
+      activesupport (= 7.2.3.1)
+    activerecord (7.2.3.1)
+      activemodel (= 7.2.3.1)
+      activesupport (= 7.2.3.1)
+      timeout (>= 0.4.0)
+    activestorage (7.2.3.1)
+      actionpack (= 7.2.3.1)
+      activejob (= 7.2.3.1)
+      activerecord (= 7.2.3.1)
+      activesupport (= 7.2.3.1)
+      marcel (~> 1.0)
+    activesupport (7.2.3.1)
+      base64
+      benchmark (>= 0.3)
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.3.1)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      logger (>= 1.4.2)
+      minitest (>= 5.1, < 6)
+      securerandom (>= 0.3)
+      tzinfo (~> 2.0, >= 2.0.5)
+    addressable (2.9.0)
+      public_suffix (>= 2.0.2, < 8.0)
+    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)
+    bcrypt_pbkdf (1.1.2-arm64-darwin)
+    bcrypt_pbkdf (1.1.2-x86_64-darwin)
+    benchmark (0.5.0)
+    bigdecimal (4.1.2)
+    bootsnap (1.24.5)
+      msgpack (~> 1.2)
+    brakeman (8.0.4)
+      racc
+    builder (3.3.0)
+    cgi (0.5.1)
+    childprocess (5.1.0)
+      logger (~> 1.5)
+    concurrent-ruby (1.3.6)
+    connection_pool (3.0.2)
+    crass (1.0.6)
+    date (3.5.1)
+    debug (1.11.1)
+      irb (~> 1.10)
+      reline (>= 0.3.8)
+    declarative (0.0.20)
+    diff-lcs (1.6.2)
+    dotenv (3.2.0)
+    drb (2.2.3)
+    ed25519 (1.4.0)
+    encryptor (3.0.0)
+    erb (6.0.4)
+    erubi (1.13.1)
+    factory_bot (6.6.0)
+      activesupport (>= 6.1.0)
+    factory_bot_rails (6.5.1)
+      factory_bot (~> 6.5)
+      railties (>= 6.1.0)
+    faker (3.8.0)
+      i18n (>= 1.8.11, < 2)
+    faraday (2.14.2)
+      faraday-net_http (>= 2.0, < 3.5)
+      json
+      logger
+    faraday-follow_redirects (0.5.0)
+      faraday (>= 1, < 3)
+    faraday-net_http (3.4.3)
+      net-http (~> 0.5)
+    globalid (1.3.0)
+      activesupport (>= 6.1)
+    google-apis-core (1.0.2)
+      addressable (~> 2.8, >= 2.8.7)
+      faraday (~> 2.13)
+      faraday-follow_redirects (~> 0.3)
+      googleauth (~> 1.14)
+      mini_mime (~> 1.1)
+      representable (~> 3.0)
+      retriable (~> 3.1)
+    google-apis-youtube_v3 (0.64.0)
+      google-apis-core (>= 0.15.0, < 2.a)
+    google-cloud-env (2.3.1)
+      base64 (~> 0.2)
+      faraday (>= 1.0, < 3.a)
+    google-logging-utils (0.2.0)
+    googleauth (1.16.2)
+      faraday (>= 1.0, < 3.a)
+      google-cloud-env (~> 2.2)
+      google-logging-utils (~> 0.1)
+      jwt (>= 1.4, < 4.0)
+      multi_json (~> 1.11)
+      os (>= 0.9, < 2.0)
+      signet (>= 0.16, < 2.a)
+    i18n (1.14.8)
+      concurrent-ruby (~> 1.0)
+    io-console (0.8.2)
+    irb (1.18.0)
+      pp (>= 0.6.0)
+      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
+    kamal (2.11.0)
+      activesupport (>= 7.0)
+      base64 (~> 0.2)
+      bcrypt_pbkdf (~> 1.0)
+      concurrent-ruby (~> 1.2)
+      dotenv (~> 3.1)
+      ed25519 (~> 1.4)
+      net-ssh (~> 7.3)
+      sshkit (>= 1.23.0, < 2.0)
+      thor (~> 1.3)
+      zeitwerk (>= 2.6.18, < 3.0)
+    language_server-protocol (3.17.0.5)
+    launchy (3.1.1)
+      addressable (~> 2.8)
+      childprocess (~> 5.0)
+      logger (~> 1.6)
+    letter_opener (1.10.0)
+      launchy (>= 2.2, < 4)
+    lint_roller (1.1.0)
+    logger (1.7.0)
+    loofah (2.25.1)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.12.0)
+    mail (2.9.0)
+      logger
+      mini_mime (>= 0.1.1)
+      net-imap
+      net-pop
+      net-smtp
+    marcel (1.2.1)
+    mini_mime (1.1.5)
+    minitest (5.27.0)
+    msgpack (1.8.0)
+    multi_json (1.21.1)
+    net-http (0.9.1)
+      uri (>= 0.11.1)
+    net-imap (0.6.4)
+      date
+      net-protocol
+    net-pop (0.1.2)
+      net-protocol
+    net-protocol (0.2.2)
+      timeout
+    net-scp (4.1.0)
+      net-ssh (>= 2.6.5, < 8.0.0)
+    net-sftp (4.0.0)
+      net-ssh (>= 5.0.0, < 8.0.0)
+    net-smtp (0.5.1)
+      net-protocol
+    net-ssh (7.3.2)
+    nio4r (2.7.5)
+    nokogiri (1.19.3-aarch64-linux-gnu)
+      racc (~> 1.4)
+    nokogiri (1.19.3-aarch64-linux-musl)
+      racc (~> 1.4)
+    nokogiri (1.19.3-arm-linux-gnu)
+      racc (~> 1.4)
+    nokogiri (1.19.3-arm-linux-musl)
+      racc (~> 1.4)
+    nokogiri (1.19.3-arm64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.19.3-x86_64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.19.3-x86_64-linux-gnu)
+      racc (~> 1.4)
+    nokogiri (1.19.3-x86_64-linux-musl)
+      racc (~> 1.4)
+    os (1.1.4)
+    ostruct (0.6.3)
+    parallel (2.1.0)
+    parser (3.3.11.1)
+      ast (~> 2.4.1)
+      racc
+    pg (1.6.3)
+    pg (1.6.3-aarch64-linux)
+    pg (1.6.3-aarch64-linux-musl)
+    pg (1.6.3-arm64-darwin)
+    pg (1.6.3-x86_64-darwin)
+    pg (1.6.3-x86_64-linux)
+    pg (1.6.3-x86_64-linux-musl)
+    pp (0.6.3)
+      prettyprint
+    prettyprint (0.2.0)
+    prism (1.9.0)
+    psych (5.3.1)
+      date
+      stringio
+    public_suffix (7.0.5)
+    puma (8.0.1)
+      nio4r (~> 2.0)
+    racc (1.8.1)
+    rack (3.2.6)
+    rack-attack (6.8.0)
+      rack (>= 1.0, < 4)
+    rack-cors (3.0.0)
+      logger
+      rack (>= 3.0.14)
+    rack-session (2.1.2)
+      base64 (>= 0.1.0)
+      rack (>= 3.0.0)
+    rack-test (2.2.0)
+      rack (>= 1.3)
+    rackup (2.3.1)
+      rack (>= 3)
+    rails (7.2.3.1)
+      actioncable (= 7.2.3.1)
+      actionmailbox (= 7.2.3.1)
+      actionmailer (= 7.2.3.1)
+      actionpack (= 7.2.3.1)
+      actiontext (= 7.2.3.1)
+      actionview (= 7.2.3.1)
+      activejob (= 7.2.3.1)
+      activemodel (= 7.2.3.1)
+      activerecord (= 7.2.3.1)
+      activestorage (= 7.2.3.1)
+      activesupport (= 7.2.3.1)
+      bundler (>= 1.15.0)
+      railties (= 7.2.3.1)
+    rails-dom-testing (2.3.0)
+      activesupport (>= 5.0.0)
+      minitest
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.7.0)
+      loofah (~> 2.25)
+      nokogiri (>= 1.15.7, != 1.16.7, != 1.16.6, != 1.16.5, != 1.16.4, != 1.16.3, != 1.16.2, != 1.16.1, != 1.16.0.rc1, != 1.16.0)
+    railties (7.2.3.1)
+      actionpack (= 7.2.3.1)
+      activesupport (= 7.2.3.1)
+      cgi
+      irb (~> 1.13)
+      rackup (>= 1.0.0)
+      rake (>= 12.2)
+      thor (~> 1.0, >= 1.2.2)
+      tsort (>= 0.2)
+      zeitwerk (~> 2.6)
+    rainbow (3.1.1)
+    rake (13.4.2)
+    rdoc (7.2.0)
+      erb
+      psych (>= 4.0.0)
+      tsort
+    redis (5.4.1)
+      redis-client (>= 0.22.0)
+    redis-client (0.29.0)
+      connection_pool
+    regexp_parser (2.12.0)
+    reline (0.6.3)
+      io-console (~> 0.5)
+    representable (3.2.0)
+      declarative (< 0.1.0)
+      trailblazer-option (>= 0.1.1, < 0.2.0)
+      uber (< 0.2.0)
+    retriable (3.5.0)
+    rspec-core (3.13.6)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.8)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-rails (8.0.4)
+      actionpack (>= 7.2)
+      activesupport (>= 7.2)
+      railties (>= 7.2)
+      rspec-core (>= 3.13.0, < 5.0.0)
+      rspec-expectations (>= 3.13.0, < 5.0.0)
+      rspec-mocks (>= 3.13.0, < 5.0.0)
+      rspec-support (>= 3.13.0, < 5.0.0)
+    rspec-support (3.13.7)
+    rubocop (1.86.2)
+      json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      parallel (>= 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.49.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.49.1)
+      parser (>= 3.3.7.2)
+      prism (~> 1.7)
+    rubocop-performance (1.26.1)
+      lint_roller (~> 1.1)
+      rubocop (>= 1.75.0, < 2.0)
+      rubocop-ast (>= 1.47.1, < 2.0)
+    rubocop-rails (2.35.2)
+      activesupport (>= 4.2.0)
+      lint_roller (~> 1.1)
+      rack (>= 1.1)
+      rubocop (>= 1.75.0, < 2.0)
+      rubocop-ast (>= 1.44.0, < 2.0)
+    rubocop-rails-omakase (1.1.0)
+      rubocop (>= 1.72)
+      rubocop-performance (>= 1.24)
+      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)
+      logger (>= 1.7.0)
+      rack (>= 3.2.0)
+      redis-client (>= 0.29.0)
+    signet (0.21.0)
+      addressable (~> 2.8)
+      faraday (>= 0.17.5, < 3.a)
+      jwt (>= 1.5, < 4.0)
+      multi_json (~> 1.10)
+    sshkit (1.25.0)
+      base64
+      logger
+      net-scp (>= 1.1.2)
+      net-sftp (>= 2.1.2)
+      net-ssh (>= 2.8.0)
+      ostruct
+    stringio (3.2.0)
+    stripe (19.1.0)
+      bigdecimal
+      logger
+    thor (1.5.0)
+    timeout (0.6.1)
+    trailblazer-option (0.1.2)
+    tsort (0.2.0)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    uber (0.1.0)
+    unicode-display_width (3.2.0)
+      unicode-emoji (~> 4.1)
+    unicode-emoji (4.2.0)
+    uri (1.1.1)
+    useragent (0.16.11)
+    websocket-driver (0.8.0)
+      base64
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.5)
+    zeitwerk (2.8.2)
+
+PLATFORMS
+  aarch64-linux
+  aarch64-linux-gnu
+  aarch64-linux-musl
+  arm-linux-gnu
+  arm-linux-musl
+  arm64-darwin
+  x86_64-darwin
+  x86_64-linux
+  x86_64-linux-gnu
+  x86_64-linux-musl
+
+DEPENDENCIES
+  aasm
+  attr_encrypted
+  aws-sdk-s3 (~> 1.0)
+  bcrypt (~> 3.1.7)
+  bootsnap
+  brakeman
+  debug
+  factory_bot_rails
+  faker
+  faraday
+  google-apis-youtube_v3
+  jwt
+  kamal
+  letter_opener
+  pg (~> 1.1)
+  puma (>= 5.0)
+  rack-attack
+  rack-cors
+  rails (~> 7.2.2)
+  redis (>= 4.0.1)
+  rspec-rails
+  rubocop-rails-omakase
+  sentry-rails
+  sentry-ruby
+  sidekiq
+  stripe
+  tzinfo-data
+
+BUNDLED WITH
+   2.5.22

backend/README.md

@@ -0,0 +1,24 @@
+# README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...

backend/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative "config/application"
+
+Rails.application.load_tasks

backend/app/channels/application_cable/channel.rb

@@ -0,0 +1,4 @@
+module ApplicationCable
+  class Channel < ActionCable::Channel::Base
+  end
+end

backend/app/channels/application_cable/connection.rb

@@ -0,0 +1,23 @@
+module ApplicationCable
+  class Connection < ActionCable::Connection::Base
+    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
+    end
+
+    private
+
+    def token_from_header
+      request.headers["Authorization"].to_s.delete_prefix("Bearer ").presence
+    end
+  end
+end

backend/app/channels/concerns/cable_broadcastable.rb

@@ -0,0 +1,9 @@
+module CableBroadcastable
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def broadcast_message(session, data)
+      broadcast_to(session, data)
+    end
+  end
+end

backend/app/channels/session_channel.rb

@@ -0,0 +1,88 @@
+class SessionChannel < ApplicationCable::Channel
+  include CableBroadcastable
+  def subscribed
+    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 = resolve_session
+    return unless session
+
+    handle_message(session, data)
+  end
+
+  private
+
+  def handle_message(session, data)
+    case data["type"]
+    when "command"
+      SessionChannel.broadcast_message(session, data)
+      execute_command(session, data)
+    when "score_update"
+      update_score(session, data)
+    when "timeout"
+      update_timeout(session, data)
+    when "device_state"
+      update_device(session, data)
+    end
+  end
+
+  def execute_command(session, data)
+    case data["action"]
+    when "start_stream"
+      Sessions::Start.new(session).call
+    when "stop_stream"
+      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)
+    Scoring::SyncState.new(session: session, payload: data).call
+  end
+
+  def update_timeout(session, data)
+    score = session.score_state
+    return unless score
+
+    if data["team"] == "home"
+      score.update!(timeout_home: true)
+    else
+      score.update!(timeout_away: true)
+    end
+    SessionChannel.broadcast_message(session, { type: "timeout", team: data["team"] })
+  end
+
+  def update_device(session, data)
+    state = session.device_states.find_or_initialize_by(device_role: data["device_role"] || "camera")
+    state.update!(
+      battery_level: data["battery"],
+      network_type: data["network"],
+      current_bitrate: data["bitrate"],
+      fps: data["fps"],
+      last_seen_at: Time.current
+    )
+    SessionChannel.broadcast_message(session, state.as_cable_payload)
+  end
+end

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

@@ -0,0 +1,32 @@
+module Admin
+  class BaseController < ActionController::Base
+    layout "admin"
+    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

@@ -0,0 +1,34 @@
+module Admin
+  class DashboardController < Admin::BaseController
+    def index
+      @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

@@ -0,0 +1,43 @@
+module Admin
+  class SessionsController < Admin::BaseController
+    def index
+      @sessions = StreamSession.includes(:match, :user).order(created_at: :desc).limit(50)
+    end
+
+    def show
+      @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

@@ -0,0 +1,12 @@
+module Admin
+  class TeamsController < Admin::BaseController
+    def index
+      redirect_to admin_clubs_path, status: :moved_permanently
+    end
+
+    def show
+      @team = Team.find(params[:id])
+      @matches = @team.matches.order(scheduled_at: :desc)
+    end
+  end
+end

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/auth_controller.rb

@@ -0,0 +1,65 @@
+module Api
+  module V1
+    class AuthController < ApplicationController
+      skip_before_action :authenticate_request!, only: %i[login refresh register]
+
+      def register
+        user = User.new(
+          email: params[:email]&.downcase,
+          name: params[:name],
+          password: params[:password],
+          role: "coach"
+        )
+        if user.save
+          render json: token_response(user), status: :created
+        else
+          render json: { error: user.errors.full_messages.join(", ") }, status: :unprocessable_entity
+        end
+      end
+
+      def login
+        user = User.find_by(email: params[:email]&.downcase)
+        if user&.authenticate(params[:password])
+          render json: token_response(user), status: :ok
+        else
+          render json: { error: "Invalid credentials" }, status: :unauthorized
+        end
+      end
+
+      def logout
+        render json: { message: "Logged out" }
+      end
+
+      def refresh
+        payload = JsonWebToken.decode(params[:refresh_token] || bearer_token)
+        user = User.find_by(id: payload&.dig(:user_id))
+        return render json: { error: "Invalid token" }, status: :unauthorized unless user
+
+        render json: token_response(user)
+      end
+
+      def me
+        render json: user_json(current_user)
+      end
+
+      private
+
+      def token_response(user)
+        {
+          user: user_json(user),
+          access_token: JsonWebToken.encode({ user_id: user.id, type: "access" }),
+          refresh_token: JsonWebToken.encode({ user_id: user.id, type: "refresh" }, exp: 30.days.from_now)
+        }
+      end
+
+      def user_json(user)
+        {
+          id: user.id,
+          email: user.email,
+          name: user.name,
+          role: user.role
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+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,
+          error_code: error.code,
+          billing_url: error.billing_url
+        }, status: :forbidden
+      end
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+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(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
+        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
+
+      def show
+        render json: match_json(@match, detail: true)
+      end
+
+      def update
+        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
+
+      def destroy
+        active = active_session_for(@match)
+        if active&.resumable?
+          return render json: {
+            error: "Chiudi la diretta prima di eliminare questa partita"
+          }, status: :unprocessable_entity
+        end
+
+        @match.destroy!
+        head :no_content
+      end
+
+      private
+
+      def set_team
+        @team = current_user.streamable_teams.find { |t| t.id == params[:team_id] }
+        raise ActiveRecord::RecordNotFound unless @team
+      end
+
+      def set_match
+        team_ids = current_user.streamable_teams.map(&:id)
+        @match = Match.includes(:team).where(team_id: team_ids).find(params[:id])
+      end
+
+      def match_params
+        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: team.name,
+          opponent_name: match.opponent_name,
+          location: match.location,
+          scheduled_at: match.scheduled_at,
+          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,
+          effective_scoring_rules: match.effective_scoring_rules,
+          category: match.category,
+          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,
+          stream_completed: match.stream_completed?,
+          coach_hub_visible: match.coach_hub_visible?
+        }
+      end
+
+      def active_session_for(match)
+        match.active_stream_session
+      end
+    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

@@ -0,0 +1,224 @@
+module Api
+  module V1
+    class StreamSessionsController < BaseController
+      before_action :set_session, except: :create
+
+      def create
+        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
+
+      def show
+        render json: session_json(@session, detail: true)
+      end
+
+      def start
+        Sessions::Start.new(@session).call
+        render json: session_json(@session)
+      end
+
+      def stop
+        Sessions::Stop.new(@session).call
+        render json: session_json(@session)
+      end
+
+      def pause
+        Sessions::Pause.new(@session).call
+        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) }
+      end
+
+      def telemetry
+        role = params.require(:device_role)
+        state = @session.device_states.find_or_initialize_by(device_role: role)
+        state.update!(
+          battery_level: params[:battery_level],
+          network_type: params[:network_type],
+          signal_strength: params[:signal_strength],
+          current_bitrate: params[:current_bitrate],
+          target_bitrate: params[:target_bitrate],
+          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
+
+      def pairing_token
+        token = SecureRandom.urlsafe_base64(24)
+        @session.update!(
+          pairing_token_digest: Digest::SHA256.hexdigest(token),
+          pairing_token_expires_at: 15.minutes.from_now
+        )
+        render json: {
+          pairing_token: token,
+          expires_at: @session.pairing_token_expires_at,
+          qr_payload: {
+            session_id: @session.id,
+            pairing_token: token,
+            api_url: request.base_url
+          }
+        }
+      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)
+        unless @session.pairing_token_digest == digest &&
+               @session.pairing_token_expires_at&.future?
+          return render json: { error: "Invalid or expired token" }, status: :unauthorized
+        end
+
+        @session.device_states.find_or_create_by!(device_role: params[:device_role] || "controller")
+        render json: session_json(@session)
+      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.merge(
+              "quality_preset" => preset[:id],
+              "target_bitrate" => preset[:target_bitrate]
+            ),
+          occurred_at: Time.current
+        )
+        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
+        count = if @session.platform == "youtube" && @session.youtube_broadcast_id.present?
+                  Youtube::BroadcastService.new(@session.match.team)
+                                           .viewer_count(@session.youtube_broadcast_id)
+                else
+                  0
+                end
+        render json: { concurrent_viewers: count, live: @session.live? }
+      end
+
+      private
+
+      def set_session
+        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, :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)
+        data = {
+          id: session.id,
+          match_id: session.match_id,
+          status: session.status,
+          platform: session.platform,
+          rtmp_ingest_url: session.rtmp_ingest_url,
+          hls_playback_url: session.hls_playback_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,
+          started_at: session.started_at,
+          disconnection_count: session.disconnection_count
+        }
+        if detail
+          data[:score] = session.score_state&.as_cable_payload
+          data[:devices] = session.device_states.map(&:as_cable_payload)
+        end
+        data
+      end
+
+      def event_json(event)
+        {
+          id: event.id,
+          event_type: event.event_type,
+          metadata: event.metadata,
+          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

@@ -0,0 +1,188 @@
+module Api
+  module V1
+    class TeamsController < BaseController
+      include Api::UrlHelper
+      include BrandingAttachments
+
+      def index
+        teams = current_user.streamable_teams
+        render json: teams.map { |t| team_json(t) }
+      end
+
+      def show
+        team = current_user.manageable_teams.find(params[:id])
+        render json: team_json(team, detail: true)
+      end
+
+      def create
+        if current_user.owned_clubs.exists?
+          return render json: {
+            error: "Registra o gestisci la società dal sito web per aggiungere squadre."
+          }, status: :unprocessable_entity
+        end
+
+        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.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",
+            error_code: "premium_required",
+            billing_url: team.entitlements.billing_url
+          }, status: :forbidden
+        end
+
+        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.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.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" }
+        head :no_content
+      end
+
+      def remove_member
+        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
+      end
+
+      private
+
+      def team_params
+        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_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?,
+          premium_full: ent.premium_full?,
+          subscription_status: ent.subscription.status,
+          features: ent.plan.features,
+          billing_url: ent.billing_url,
+          staff_manage_url: ent.staff_manage_url,
+          max_staff: ent.max_staff,
+          max_staff_transmission: ent.max_staff_transmission,
+          staff_used: ent.staff_count,
+          staff_transmission_used: ent.staff_count_for("transmission"),
+          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,
+          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|
+            { id: ut.user.id, name: ut.user.name, email: ut.user.email, role: ut.role }
+          end
+        end
+        data
+      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,
+          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,
+          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
+  end
+end

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

@@ -0,0 +1,23 @@
+module Api
+  module V1
+    class YoutubeController < BaseController
+      def authorize
+        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
+
+        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
+        )
+        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
+end

backend/app/controllers/application_controller.rb

@@ -0,0 +1,25 @@
+class ApplicationController < ActionController::API
+  include ActionController::HttpAuthentication::Token::ControllerMethods
+
+  before_action :authenticate_request!
+
+  attr_reader :current_user
+
+  private
+
+  def authenticate_request!
+    token = bearer_token
+    payload = JsonWebToken.decode(token)
+    @current_user = User.find_by(id: payload[:user_id]) if payload
+    render json: { error: "Unauthorized" }, status: :unauthorized unless @current_user
+  end
+
+  def bearer_token
+    auth = request.headers["Authorization"].to_s
+    auth.start_with?("Bearer ") ? auth.split(" ", 2).last : nil
+  end
+
+  def skip_auth?
+    false
+  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

@@ -0,0 +1,104 @@
+class HlsProxyController < ActionController::Base
+  # 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
+    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"
+
+    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
+
+    head :bad_gateway
+  rescue Faraday::Error => e
+    Rails.logger.warn("[HlsProxy] #{upstream_path}: #{e.message}")
+    head :bad_gateway
+  end
+
+  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|
+      f.adapter Faraday.default_adapter
+      f.options.timeout = 15
+      f.options.open_timeout = 5
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Public
+  class InvitationsController < WebBaseController
+    def show
+      @token = params[:token]
+      @invitation = TeamInvitation.pending.find_by(token_digest: Digest::SHA256.hexdigest(@token.to_s))
+      unless @invitation
+        redirect_to public_pricing_path, alert: "Invito non valido o scaduto"
+      end
+    end
+
+    def accept
+      invitation = TeamInvitation.pending.find_by(token_digest: Digest::SHA256.hexdigest(params[:token].to_s))
+      return redirect_to public_pricing_path, alert: "Invito non valido" unless invitation
+
+      if logged_in?
+        if current_user.email.downcase != invitation.email.downcase
+          redirect_to public_pricing_path, alert: "Questo invito è per #{invitation.email}"
+          return
+        end
+        invitation.accept!(current_user)
+        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"
+      end
+    end
+  end
+end

backend/app/controllers/public/live_controller.rb

@@ -0,0 +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
+      @club = Club.find_by(id: params[:club_id]) if params[:club_id].present?
+      team_ids = @club&.teams&.pluck(:id)
+
+      sessions = StreamSession
+        .broadcasting
+        .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: :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_stream_playable?(@session) ||
+        @session.status.in?(%w[connecting live reconnecting paused])
+      )
+      @publisher_online = !@stream_closed && mediamtx_publisher_online?(@session)
+    end
+
+    def status
+      # 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? || 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
+  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

@@ -0,0 +1,42 @@
+module Public
+  class PagesController < WebBaseController
+    def home
+    end
+
+    def features
+    end
+
+    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
+    end
+
+    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

@@ -0,0 +1,39 @@
+module Public
+  class RegistrationsController < WebBaseController
+    def new
+      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
+        if session[:pending_invite_token].present?
+          token = session.delete(:pending_invite_token)
+          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_details_path(invitation.team), notice: "Benvenuto nella squadra!"
+          end
+        end
+        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
+      end
+    end
+
+    private
+
+    def user_params
+      params.require(:user).permit(:name, :email, :password, :password_confirmation)
+    end
+  end
+end

backend/app/controllers/public/replay_controller.rb

@@ -0,0 +1,117 @@
+module Public
+  class ReplayController < SiteBaseController
+    include Public::LiveHelper
+
+    layout "marketing_live"
+
+    before_action :set_session_and_recording, only: %i[show stream thumbnail download]
+    before_action :authorize_replay_access!, only: %i[show stream thumbnail download]
+
+    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

@@ -0,0 +1,32 @@
+module Public
+  class SessionsController < WebBaseController
+    def new
+      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 = 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"
+        render :new, status: :unauthorized
+      end
+    end
+
+    def destroy
+      reset_session
+      redirect_to public_pricing_path, notice: "Disconnesso"
+    end
+  end
+end

backend/app/controllers/public/site_base_controller.rb

@@ -0,0 +1,28 @@
+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)
+
+      @current_user = User.find_by(id: session[:user_id]) if session[:user_id]
+    end
+
+    def logged_in?
+      current_user.present?
+    end
+  end
+end

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

@@ -0,0 +1,185 @@
+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[
+      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_new_club_path if current_user.owned_clubs.none?
+      require_club_owner!(@club)
+    end
+
+    def create
+      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
+
+    def details
+      load_team_details!
+      render :details
+    end
+
+    def dashboard
+      redirect_to public_team_details_path(params[:id])
+    end
+
+    def roster
+      redirect_to public_team_details_path(params[:id])
+    end
+
+    def edit
+      require_club_owner_for_team!(@team)
+      @club = @team.club
+    end
+
+    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_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_club_owner_for_team!(@team)
+      @entitlements = @team.entitlements
+      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,
+        token_digest: Digest::SHA256.hexdigest(token),
+        role: "member",
+        staff_kind: staff_kind,
+        expires_at: 7.days.from_now
+      )
+      @invite_url = join_public_invitation_url(token: token)
+      flash.now[:notice] = "Link invito generato (valido 7 giorni)"
+      render :invite
+    rescue Teams::EntitlementError, Teams::StaffAssignmentError => e
+      redirect_to public_team_invite_path(@team), alert: e.message
+    end
+
+    def remove_member
+      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_details_path(@team), notice: "Accesso revocato"
+    end
+
+    def destroy_invitation
+      require_club_owner_for_team!(@team)
+      inv = @team.team_invitations.pending.find(params[:invitation_id])
+      inv.destroy!
+      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.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
+      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

@@ -0,0 +1,21 @@
+module Public
+  class WebBaseController < SiteBaseController
+    protect_from_forgery with: :exception
+
+    private
+
+    def require_login!
+      return if logged_in?
+
+      redirect_to public_login_path, alert: "Accedi per continuare"
+    end
+
+    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/webhooks/mediamtx_controller.rb

@@ -0,0 +1,53 @@
+module Webhooks
+  class MediamtxController < ApplicationController
+    skip_before_action :authenticate_request!
+
+    before_action :verify_signature!
+
+    def connect
+      handle_event("connect")
+    end
+
+    def disconnect
+      handle_event("disconnect")
+    end
+
+    def ready
+      handle_event("ready")
+    end
+
+    def validate_publish
+      session_id = params[:session_id] || extract_session_id(params[:path])
+      token = params[:token]
+      session = StreamSession.find_by(id: session_id)
+
+      valid = session && session.publish_token == token && !session.ended?
+      render json: { valid: valid }, status: valid ? :ok : :forbidden
+    end
+
+    private
+
+    def handle_event(event)
+      session_id = params[:session_id].presence || extract_session_id(params[:path])
+      Webhooks::MediamtxHandler.new(
+        event: event,
+        session_id: session_id,
+        metadata: params.permit!.to_h.except("controller", "action")
+      ).call
+      head :ok
+    end
+
+    def extract_session_id(path)
+      path.to_s[%r{match_([0-9a-f-]+)}, 1]
+    end
+
+    def verify_signature!
+      signature = request.headers["X-MediaMTX-Signature"]
+      payload = request.raw_post.presence || request.query_string
+      return if Webhooks::Signature.valid?(payload, signature)
+      return if Rails.env.development? && signature.blank?
+
+      head :unauthorized
+    end
+  end
+end

backend/app/controllers/webhooks/stripe_controller.rb

@@ -0,0 +1,32 @@
+module Webhooks
+  class StripeController < ActionController::API
+    def create
+      payload = request.body.read
+      sig_header = request.env["HTTP_STRIPE_SIGNATURE"]
+
+      unless MatchLiveTv.stripe_webhook_secret.present?
+        Rails.logger.info("[Stripe webhook] ignored — STRIPE_WEBHOOK_SECRET not set")
+        return head :ok
+      end
+
+      event = ::Stripe::Webhook.construct_event(
+        payload, sig_header, MatchLiveTv.stripe_webhook_secret
+      )
+
+      Billing::Stripe::WebhookHandler.call(event)
+
+      head :ok
+    rescue JSON::ParserError, ::Stripe::SignatureVerificationError => e
+      Rails.logger.warn("[Stripe webhook] #{e.message}")
+      head :bad_request
+    end
+
+    private
+
+    def stripe_object_from_hash(hash)
+      OpenStruct.new(hash.transform_keys(&:to_s).transform_values do |v|
+        v.is_a?(Hash) ? stripe_object_from_hash(v) : v
+      end)
+    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

@@ -0,0 +1,102 @@
+module Public
+  module LiveHelper
+    def live_score_sets_label(score_state, match = nil)
+      return nil unless score_state
+
+      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?
+
+      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
+
+      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
+
+    def format_set_partial_entry(partial)
+      data = partial.respond_to?(:with_indifferent_access) ? partial.with_indifferent_access : partial
+      set_no = data[:set] || data["set"]
+      home = data[:home] || data["home"]
+      away = data[:away] || data["away"]
+      label = set_no.present? ? "Set #{set_no}" : "Set"
+      "#{label} #{home}-#{away}"
+    end
+  end
+end

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/application_job.rb

@@ -0,0 +1,7 @@
+class ApplicationJob < ActiveJob::Base
+  # Automatically retry jobs that encountered a deadlock
+  # retry_on ActiveRecord::Deadlocked
+
+  # Most jobs are safe to ignore if the underlying records are no longer available
+  # discard_on ActiveJob::DeserializationError
+end

backend/app/jobs/cleanup_expired_sessions_job.rb

@@ -0,0 +1,12 @@
+class CleanupExpiredSessionsJob
+  include Sidekiq::Job
+
+  def perform
+    StreamSession.where(status: %w[connecting reconnecting])
+                 .where("updated_at < ?", 6.hours.ago)
+                 .find_each do |session|
+      session.fail! if session.may_fail?
+      Mediamtx::Client.new.delete_path(session)
+    end
+  end
+end

backend/app/jobs/disconnection_timeout_job.rb

@@ -0,0 +1,22 @@
+class DisconnectionTimeoutJob
+  include Sidekiq::Job
+
+  def perform(session_id)
+    session = StreamSession.find_by(id: session_id)
+    return unless session&.reconnecting?
+
+    session.finish! if session.may_finish?
+    session.update!(timeout_job_id: nil)
+    session.stream_events.create!(
+      event_type: "error",
+      metadata: { reason: "reconnect_timeout" },
+      occurred_at: Time.current
+    )
+    SessionChannel.broadcast_message(session, {
+      type: "stream_event",
+      event: "timeout_ended",
+      message: "Session ended after reconnect timeout"
+    })
+    Sessions::Stop.new(session).call
+  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/notify_stream_health_job.rb

@@ -0,0 +1,17 @@
+class NotifyStreamHealthJob
+  include Sidekiq::Job
+
+  def perform(session_id)
+    session = StreamSession.find_by(id: session_id)
+    return unless session&.live?
+
+    camera = session.device_states.find_by(device_role: "camera")
+    return unless camera&.current_bitrate && camera.current_bitrate < session.target_bitrate * 0.5
+
+    SessionChannel.broadcast_message(session, {
+      type: "stream_event",
+      event: "quality_degraded",
+      bitrate: camera.current_bitrate
+    })
+  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_analytics_job.rb

@@ -0,0 +1,16 @@
+class StreamAnalyticsJob
+  include Sidekiq::Job
+
+  def perform(session_id)
+    session = StreamSession.find_by(id: session_id)
+    return unless session&.ended?
+
+    duration = session.total_duration_secs
+    disconnects = session.disconnection_count
+    session.stream_events.create!(
+      event_type: "quality_changed",
+      metadata: { analytics: true, duration: duration, disconnects: disconnects },
+      occurred_at: Time.current
+    )
+  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