Flutter+Rails 실시간 인프라 4대 단절 고치기 — FCM 딥링크, ActionCable JWT, 익명→회원 연결

// 잘못된 위치: Widget.initState 안에서 호출
@override
void initState() {
  super.initState();
  FirebaseMessaging.instance.getInitialMessage().then(_handle);
  // 이미 늦었다. 네이티브 레이어가 메시지를 소비해버렸다.
}

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Firebase.initializeApp();

  // 1. 백그라운드 핸들러를 제일 먼저 등록
  FirebaseMessaging.onBackgroundMessage(_firebaseBackgroundHandler);

  // 2. getInitialMessage는 runApp 전에
  final RemoteMessage? initial =
      await FirebaseMessaging.instance.getInitialMessage();
  if (initial != null) {
    // 라우터가 준비된 후 소비할 수 있게 어딘가에 쟁여둔다
    _pendingIntent = parsePayload(initial);
  }

  runApp(const MyApp());
}

@pragma('vm:entry-point')
Future<void> _firebaseBackgroundHandler(RemoteMessage message) async {
  await Firebase.initializeApp(); // 이 아이솔레이트에서도 초기화 필요
  // 여기서는 GoRouter도, BLoC도, Provider도 접근 불가
  // 필요하면 SharedPreferences 같은 영속 저장소에만 쓴다
}

class NotificationIntent {
  final String type; // 'match', 'court', 'round_started' 등
  final String? id;

  String toPath() {
    switch (type) {
      case 'match':
      case 'match_upcoming':
      case 'player_called':
        return id != null ? '/m/$id' : '/';
      case 'court_assigned':
        return id != null ? '/courts/$id' : '/courts';
      case 'round_started':
        return '/bracket';
      default:
        return '/';
    }
  }
}

module ApplicationCable
  class Connection < ActionCable::Connection::Base
    identified_by :current_user

    def connect
      self.current_user = find_verified_user
      reject_unauthorized_connection unless current_user
    end

    private

    def find_verified_user
      User.find_by(id: request.session[:user_id])
    end
  end
end

def find_verified_user
  user_from_jwt || User.find_by(id: request.session[:user_id])
end

def user_from_jwt
  token = request.params[:token].presence
  return nil unless token

  payload = Api::V2::Auth::TokenEncoder.decode(token)
  return nil unless payload["sub_type"] == "user"

  api_token = ApiToken.active.find_by(id: payload["api_token_id"])
  return nil unless api_token&.subject_type == "user" &&
                    api_token.user_id.to_s == payload["sub"].to_s

  api_token.user
rescue Api::V2::Auth::TokenEncoder::InvalidTokenError
  nil
end

final String? token = await _session.accessToken();
final Uri cableUri = token == null || token.isEmpty
    ? baseUri
    : baseUri.replace(
        queryParameters: <String, String>{
          ...baseUri.queryParameters,
          'token': token,
        },
      );
await _client.connect(cableUri);

test "jwt token query param authenticates user" do
  user = users(:one)
  bundle = Api::V2::Auth::TokenManager.new(request: fake_request).issue_user_tokens(user)

  connect "/cable?token=#{bundle[:access_token]}"
  assert_equal user, connection.current_user
end

test "invalid jwt is rejected" do
  assert_reject_connection { connect "/cable?token=not-a-real-token" }
end

test "participant jwt does not authenticate as user" do
  # ... participant 토큰은 거절돼야 함
end

module Notifications
  class PushService
    # 라운드 시작 → Flutter에서 /bracket으로 딥링크
    def self.notify_round_started(tournament:, round_number:, match_ids: [])
      matches = tournament.matches.where(id: match_ids)
                          .includes(match_players: { participant: :user })
      users = matches.flat_map { |m| 
        m.match_players.filter_map { |mp| mp.participant.try(:user) } 
      }.uniq
      return if users.empty?

      users.each do |user|
        PushNotificationJob.perform_later(
          user_id: user.id,
          notification_type: "match_invite",
          title: "Round #{round_number} started",
          body: "...",
          data: {
            type: "round_started",
            id: tournament.id.to_s,
            round_number: round_number
          }
        )
      end
    end

    # 운영자가 선수 호출 → Flutter에서 /m/:id로 딥링크
    def self.notify_player_called(match:, called_by: nil)
      # ...
    end

    # 매치 15분 전 리마인더 → Flutter에서 /m/:id로 딥링크
    def self.notify_match_upcoming(match:, minutes_until: 15)
      # ...
    end
  end
end

class Match < ApplicationRecord
  after_commit :schedule_upcoming_reminder,
               on: %i[create update],
               if: :reminder_scheduling_needed?

  private

  def reminder_scheduling_needed?
    saved_change_to_scheduled_at? &&
      status_scheduled? &&
      scheduled_at.present? &&
      scheduled_at > 15.minutes.from_now
  end

  def schedule_upcoming_reminder
    users_for_reminder.each do |user|
      next unless user.push_match_reminder?
      MatchReminderJob
        .set(wait_until: scheduled_at - 15.minutes)
        .perform_later(match_id: id, user_id: user.id)
    end
  end
end

class AddClaimDeviceIdToPlayers < ActiveRecord::Migration[8.1]
  def change
    add_column :players, :claim_device_id, :string
    # 부분 인덱스: 아직 clamim 안된 레코드만 조회 대상
    add_index :players, :claim_device_id,
              where: "user_id IS NULL AND claim_device_id IS NOT NULL",
              name: "index_players_on_claim_device_id_unclaimed"
  end
end

class GuestDataClaimer
  Result = Struct.new(:claimed_count, :player_ids, keyword_init: true)

  def self.call(user:, device_identifier:)
    new(user: user, device_identifier: device_identifier).call
  end

  def call
    return Result.new(claimed_count: 0, player_ids: []) \
      if @device_identifier.blank? || @user.nil?

    player_ids = []
    ApplicationRecord.transaction(isolation: :serializable) do
      players = Player
                  .lock("FOR UPDATE")
                  .where(claim_device_id: @device_identifier, user_id: nil)
                  .to_a
      player_ids = players.map(&:id)

      if player_ids.any?
        Player.where(id: player_ids).update_all(
          user_id: @user.id,
          updated_at: Time.current
        )
      end
    end

    Result.new(claimed_count: player_ids.size, player_ids: player_ids)
  end
end

@lazySingleton
class DeviceIdentifierService {
  DeviceIdentifierService(this._storage);
  final FlutterSecureStorage _storage;
  static const String _key = 'guest_device_identifier';

  Future<String> getOrCreate() async {
    final existing = await _storage.read(key: _key);
    if (existing != null && existing.isNotEmpty) return existing;
    final fresh = _generate();
    await _storage.write(key: _key, value: fresh);
    return fresh;
  }

  String _generate() {
    final rnd = Random.secure();
    final bytes = List<int>.generate(16, (_) => rnd.nextInt(256));
    return 'dev-${bytes.map((b) => b.toRadixString(16).padLeft(2, '0')).join()}';
  }
}

Future<void> _claimGuestData() async {
  try {
    final deviceId = await _deviceIdentifierService.read();
    if (deviceId == null || deviceId.isEmpty) return;
    await _api.claimGuestData(<String, dynamic>{
      'deviceIdentifier': deviceId,
    });
  } catch (_) {
    // 실패해도 로그인 자체는 성공 상태를 유지.
    // 사용자가 프로필에서 수동 재시도할 수 있게 UX 보강 여지.
  }
}