import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:provider/provider.dart';
import 'package:intl/intl.dart';
import 'package:share_plus/share_plus.dart';

import '../../utils/url_utils.dart';

import '../../models/event_model.dart';
import '../../models/participant_model.dart';
import '../../models/score_model.dart';
import '../../models/team_model.dart';
import '../../services/event_service.dart';
import '../../services/notification_service.dart';
import '../../widgets/loading_indicator.dart';

// 뱃지 위젯 - 회원 유형, 참가자 상태, 결제 상태 등에 사용
class BadgeWidget extends StatelessWidget {
  final String text;
  final Color color;
  final IconData? icon;
  final EdgeInsets? margin;
  final bool outlined;

  const BadgeWidget({
    Key? key,
    required this.text,
    required this.color,
    this.icon,
    this.margin,
    this.outlined = true,
  }) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return Container(
      margin: margin ?? const EdgeInsets.only(right: 8),
      padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
      decoration: BoxDecoration(
        color: outlined ? color.withOpacity(0.1) : color,
        borderRadius: BorderRadius.circular(8),
        border: outlined ? Border.all(color: color) : null,
      ),
      child: Row(
        mainAxisSize: MainAxisSize.min,
        children: [
          if (icon != null) ...[  
            Icon(
              icon!,
              color: outlined ? color : Colors.white,
              size: 14,
            ),
            const SizedBox(width: 4),
          ],
          Text(
            text,
            style: TextStyle(
              color: outlined ? color : Colors.white,
              fontWeight: FontWeight.bold,
              fontSize: 12,
            ),
          ),
        ],
      ),
    );
  }
}

class EventDetailsScreen extends StatefulWidget {
  final Event event;

  const EventDetailsScreen({
    Key? key,
    required this.event,
  }) : super(key: key);

  @override
  State<EventDetailsScreen> createState() => _EventDetailsScreenState();
}

class _EventDetailsScreenState extends State<EventDetailsScreen> with SingleTickerProviderStateMixin {
  // 공유 성공 스낵바 표시
  void _showShareSuccessSnackBar() {
    ScaffoldMessenger.of(context).showSnackBar(
      const SnackBar(
        content: Text('이벤트 정보가 공유되었습니다'),
        duration: Duration(seconds: 2),
      ),
    );
  }

  // 기본 정보만 공유
  void _shareBasicInfo(String title, String type, String date, String location) {
    final text = '[$type] $title\n날짜: $date\n장소: $location';
    Share.share(text);
    _showShareSuccessSnackBar();
  }
  
  // 참가 링크 포함 공유
  void _shareWithLink(String title, String type, String date, String location, String url) {
    final text = '[$type] $title\n날짜: $date\n장소: $location\n\n참가 링크: $url';
    Share.share(text);
    _showShareSuccessSnackBar();
  }
  
  // 상세 정보 포함 공유
  void _shareDetailedInfo(String title, String type, String date, String location, String gameCount, String fee, String url) {
    final text = '[$type] $title\n날짜: $date\n장소: $location\n게임 수: $gameCount\n참가비: ${fee}원\n참가자: ${_participants.length}명\n\n참가 링크: $url';
    Share.share(text);
    _showShareSuccessSnackBar();
  }

  // 이벤트 공유 기능
  void _shareEvent() {
    // 공유할 정보 준비
    final eventTitle = widget.event.title;
    final eventType = widget.event.type ?? '기타';
    final eventDate = DateFormat('yyyy년 MM월 dd일 HH:mm').format(widget.event.startDate);
    final eventLocation = widget.event.location?.isEmpty ?? true ? '장소 미정' : widget.event.location!;
    final gameCount = widget.event.gameCount?.toString() ?? '0';
    final participantFee = NumberFormat('#,###').format(widget.event.participantFee ?? 0);
    
    // 공유 URL - publicHash를 사용하여 URL 생성
    final shareUrl = widget.event.publicHash?.isNotEmpty ?? false 
        ? 'https://bowling.example.com/events/${widget.event.publicHash}' 
        : '';
    
    // 공유 옵션 다이얼로그 표시
    showModalBottomSheet(
      context: context,
      shape: const RoundedRectangleBorder(
        borderRadius: BorderRadius.vertical(top: Radius.circular(16)),
      ),
      builder: (context) => Column(
        mainAxisSize: MainAxisSize.min,
        children: [
          Container(
            padding: const EdgeInsets.all(16),
            alignment: Alignment.center,
            decoration: BoxDecoration(
              color: Colors.blue.shade50,
              borderRadius: const BorderRadius.vertical(top: Radius.circular(16)),
            ),
            child: Column(
              children: [
                Text(
                  '이벤트 공유',
                  style: TextStyle(
                    fontSize: 18,
                    fontWeight: FontWeight.bold,
                    color: Colors.blue.shade800,
                  ),
                ),
                const SizedBox(height: 4),
                Text(
                  '공유 방식을 선택하세요',
                  style: TextStyle(
                    fontSize: 14,
                    color: Colors.blue.shade600,
                  ),
                ),
              ],
            ),
          ),
          ListTile(
            leading: const Icon(Icons.info_outline),
            title: const Text('기본 정보 공유'),
            subtitle: const Text('이벤트 제목, 유형, 날짜, 장소 정보를 공유합니다'),
            onTap: () {
              Navigator.pop(context);
              _shareBasicInfo(eventTitle, eventType, eventDate, eventLocation);
            },
          ),
          ListTile(
            leading: const Icon(Icons.link),
            title: const Text('참가 링크 포함 공유'),
            subtitle: const Text('기본 정보와 함께 참가 링크를 포함하여 공유합니다'),
            enabled: shareUrl.isNotEmpty,
            onTap: shareUrl.isNotEmpty ? () {
              Navigator.pop(context);
              _shareWithLink(eventTitle, eventType, eventDate, eventLocation, shareUrl);
            } : null,
          ),
          ListTile(
            leading: const Icon(Icons.info),
            title: const Text('상세 정보 포함 공유'),
            subtitle: const Text('기본 정보, 참가 링크, 게임 수, 참가비 등 상세 정보를 포함하여 공유합니다'),
            onTap: () {
              Navigator.pop(context);
              _shareDetailedInfo(eventTitle, eventType, eventDate, eventLocation, gameCount, participantFee, shareUrl);
            },
          ),
          const SizedBox(height: 16),
        ],
      ),
    );
  }

  // 정보 행 위젯
  Widget _buildInfoRow(IconData icon, String text, {bool isSelectable = false}) {
    return Padding(
      padding: const EdgeInsets.only(bottom: 12),
      child: Row(
        crossAxisAlignment: CrossAxisAlignment.start,
        children: [
          Icon(icon, size: 18, color: Colors.grey.shade700),
          const SizedBox(width: 8),
          Expanded(
            child: isSelectable
                ? SelectableText(
                    text,
                    style: TextStyle(color: Colors.grey.shade800),
                  )
                : Text(
                    text,
                    style: TextStyle(color: Colors.grey.shade800),
                  ),
          ),
        ],
      ),
    );
  }

  Widget _buildBadge({
    required String text,
    required Color color,
    IconData? icon,
    bool outlined = true,
    EdgeInsets? margin,
  }) {
    return BadgeWidget(
      text: text,
      color: color,
      icon: icon,
      outlined: outlined,
      margin: margin,
    );
  }

  Color _getParticipantStatusColor(String status) {
    return Colors.grey;
  }

  IconData _getParticipantStatusIcon(String status) {
    return Icons.person;
  }

  List<Participant> _getUnassignedParticipants() {
    return [];
  }

  // 공유 관련 메서드는 아래에 구현되어 있음

  // 스낵바 표시 함수
  void _showSnackBar(String message) {
    ScaffoldMessenger.of(context).showSnackBar(
      SnackBar(
        content: Text(message),
        duration: const Duration(seconds: 2),
      ),
    );
  }
  
  // 공유 성공 스낵바 표시
  void _showShareSuccessSnackBar() {
    _showSnackBar('이벤트 정보가 공유되었습니다');
  }
  
  // 클립보드에 복사 후 스낵바 표시
  void _copyToClipboard(String text, String message) {
    Clipboard.setData(ClipboardData(text: text));
    _showSnackBar(message);
  }
  
  void _editEvent() {}
  
  void _addParticipant() {}
  
  void _addScore() {}
  
  // 이벤트 알림 설정 기능
  Future<void> _setEventReminders() async {
    final notificationService = NotificationService();
    
    // 알림 권한 확인
    final hasPermission = await notificationService.requestPermission();
    
    if (!hasPermission) {
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
          const SnackBar(content: Text('알림 권한이 없습니다. 설정에서 권한을 허용해주세요.')),
        );
      }
      return;
    }
    
    // 알림 설정 다이얼로그 표시
    if (!mounted) return;
    
    showDialog(
      context: context,
      builder: (context) => AlertDialog(
        title: const Text('이벤트 알림 설정'),
        content: Column(
          mainAxisSize: MainAxisSize.min,
          children: [
            ListTile(
              leading: const Icon(Icons.notifications_active),
              title: const Text('이벤트 시작 알림'),
              subtitle: Text('${DateFormat('yyyy-MM-dd HH:mm').format(widget.event.startDate)} 1시간 전'),
              onTap: () async {
                Navigator.of(context).pop();
                await notificationService.scheduleEventStartReminder(widget.event);
                
                if (mounted) {
                  ScaffoldMessenger.of(context).showSnackBar(
                    const SnackBar(content: Text('이벤트 시작 알림이 설정되었습니다')),
                  );
                }
              },
            ),
            if (widget.event.registrationDeadline != null) ListTile(
              leading: const Icon(Icons.timer),
              title: const Text('등록 마감 알림'),
              subtitle: Text('${DateFormat('yyyy-MM-dd HH:mm').format(widget.event.registrationDeadline!)} 1일 전'),
              onTap: () async {
                Navigator.of(context).pop();
                await notificationService.scheduleRegistrationDeadlineReminder(widget.event);
                
                if (mounted) {
                  ScaffoldMessenger.of(context).showSnackBar(
                    const SnackBar(content: Text('등록 마감 알림이 설정되었습니다')),
                  );
                }
              },
            ),
            ListTile(
              leading: const Icon(Icons.notifications_off),
              title: const Text('알림 취소'),
              subtitle: const Text('이 이벤트에 대한 모든 알림 취소'),
              onTap: () async {
                Navigator.of(context).pop();
                await notificationService.cancelEventNotifications(widget.event.id);
                
                if (mounted) {
                  ScaffoldMessenger.of(context).showSnackBar(
                    const SnackBar(content: Text('이벤트 알림이 취소되었습니다')),
                  );
                }
              },
            ),
          ],
        ),
        actions: [
          TextButton(
            onPressed: () => Navigator.of(context).pop(),
            child: const Text('닫기'),
          ),
        ],
      ),
    );
  }
  
  void _generateTeams() {}
  
  Color _getEventTypeColor(String type) {
    switch (type.toLowerCase()) {
      case '개인전':
        return Colors.blue;
      case '팀전':
        return Colors.purple;
      case '리그':
        return Colors.teal;
      case '토너먼트':
        return Colors.deepOrange;
      case '친선전':
        return Colors.green;
      default:
        return Colors.blueGrey;
    }
  }
  
  Color _getEventStatusColor(String status) {
    switch (status.toLowerCase()) {
      case '예정':
        return Colors.blue;
      case '진행중':
        return Colors.green;
      case '완료':
        return Colors.purple;
      case '취소':
        return Colors.red;
      case '연기':
        return Colors.orange;
      default:
        return Colors.grey;
    }
  }
  
  void _editParticipant(Participant participant) {}
  
  void _removeParticipant(Participant participant) {}
  
  void _showParticipantDetails(Participant participant) {}
  
  Color _getRankColor(int rank) {
    return Colors.amber;
  }
  
  Color _getScoreColor(int score) {
    return Colors.black;
  }
  
  void _editScore(Score score) {}
  
  void _deleteScore(Score score) {}
  
  void _showScoreDetails(Score score) {}
  

  
  List<Participant> _filteredParticipants() {
    return [];
  }
  
  List<Participant> _sortedParticipants() {
    return [];
  }
  
  List<Score> sortScores(bool withHandicap) {
    return [];
  }
  
  List<Participant> _getTeamMembers(Team team) {
    return [];
  }
  
  double _calculateTeamAverage(Team team) {
    return 0.0;
  }
  
  void _saveTeams() {}
  
  void _removeFromTeam(Team team, Participant participant) {}
  
  void _showParticipantSelectionDialog(Team team) {}
  
  void _showTeamSelectionDialog(Participant participant) {}
  
  Widget _buildFilterChip({required String label, required VoidCallback onRemove}) {
    return const SizedBox();
  }
  late TabController _tabController;
  List<Participant> _participants = [];
  List<Score> _scores = [];
  List<Team> _teams = [];

  // 참가자 모델에 회원 유형 할당
  void _assignMemberTypes() {
    for (var participant in _participants) {
      // 실제 구현에서는 API에서 회원 유형 정보를 가져와야 함
      // 여기서는 임시로 회원 유형을 할당
      participant.memberType = _getRandomMemberType();
    }
  }
  
  // 임시: 랜덤 회원 유형 반환 (실제 구현에서는 API에서 가져와야 함)
  String _getRandomMemberType() {
    final types = ['정회원', '준회원', '게스트'];
    return types[DateTime.now().millisecond % 3];
  }
  
  // 회원 유형에 따른 색상 반환
  Color _getMemberTypeColor(String memberType) {
    switch (memberType.toLowerCase()) {
      case 'regular':
      case '정회원':
        return Colors.indigo;
      case 'associate':
      case '준회원':
        return Colors.amber.shade800;
      case 'guest':
      case '게스트':
        return Colors.teal;
      default:
        return Colors.grey;
    }
  }

  // 탭별 로딩 상태 관리
  bool _isInitialLoading = true; // 초기 로딩 상태
  final Map<int, bool> _tabLoadingStates = {0: false, 1: false, 2: false, 3: false};
  final Map<int, bool> _tabLoadedStates = {0: false, 1: false, 2: false, 3: false};

  int _teamGenerationMethod = 1; // 1: 팀 인원수로 나누기, 2: 팀 개수로 나누기
  final TextEditingController _teamSizeController = TextEditingController(text: '4');
  final TextEditingController _teamCountController = TextEditingController(text: '2');
  bool _showTeamTab = false;

  @override
  void initState() {
    super.initState();
    // 팀 탭 표시 여부에 따라 TabController 길이 설정
    _tabController = TabController(length: _showTeamTab ? 4 : 3, vsync: this);

    // 탭 선택 변경 리스너 추가
    _tabController.addListener(_handleTabChange);

    // 초기 기본 정보 탭 데이터 로드
    _loadBasicInfoData();
  }

  @override
  void dispose() {
    _tabController.removeListener(_handleTabChange);
    _tabController.dispose();
    _teamSizeController.dispose();
    _teamCountController.dispose();
    super.dispose();
  }

  // 탭 변경 시 호출되는 핸들러
  void _handleTabChange() {
    final currentTabIndex = _tabController.index;

    // 현재 탭이 아직 로드되지 않았다면 데이터 로드
    if (!_tabLoadedStates[currentTabIndex]!) {
      switch (currentTabIndex) {
        case 0:
          _loadBasicInfoData();
          break;
        case 1:
          _loadParticipantsData();
          break;
        case 2:
          _loadScoresData();
          break;
        case 3:
          if (_showTeamTab) {
            _loadTeamsData();
          }
          break;
      }
    }
  }

  // 기본 정보 탭 데이터 로드
  Future<void> _loadBasicInfoData() async {
    if (_tabLoadedStates[0]!) return; // 이미 로드된 경우 스킵

    setState(() {
      _isInitialLoading = true;
      _tabLoadingStates[0] = true;
    });

    try {
      // 기본 정보는 이미 widget.event에 있으므로 추가 API 호출 불필요
      // 팀 관련 정보만 확인
      final eventService = Provider.of<EventService>(context, listen: false);

      try {
        // 팀 탭 표시 여부 확인을 위해 팀 정보 간략히 조회
        final hasTeams = await eventService.hasEventTeams(widget.event.id);
        if (mounted) {
          setState(() {
            _showTeamTab = hasTeams || widget.event.type == '팀전';
            _tabLoadedStates[0] = true;
            _tabLoadingStates[0] = false;
            _isInitialLoading = false;
          });
        }
      } catch (e) {
        // 팀 정보 조회 실패 시 기본값 설정
        if (mounted) {
          setState(() {
            _showTeamTab = widget.event.type == '팀전';
            _tabLoadedStates[0] = true;
            _tabLoadingStates[0] = false;
            _isInitialLoading = false;
          });
        }
      }
    } catch (e) {
      if (mounted) {
        setState(() {
          _tabLoadedStates[0] = true; // 오류가 나도 로드 시도는 했으므로 표시
          _tabLoadingStates[0] = false;
          _isInitialLoading = false;
        });
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(content: Text('기본 정보를 불러오는데 실패했습니다: $e')),
        );
      }
    }
  }

  // 참가자 탭 데이터 로드
  Future<void> _loadParticipantsData() async {
    if (_tabLoadedStates[1]!) return; // 이미 로드된 경우 스킵

    setState(() {
      _tabLoadingStates[1] = true;
    });

    try {
      final eventService = Provider.of<EventService>(context, listen: false);
      final participants = await eventService.fetchEventParticipants(widget.event.id);

      if (mounted) {
        setState(() {
          _participants = participants;
          _assignMemberTypes(); // 회원 유형 정보 추가
          _tabLoadedStates[1] = true;
          _tabLoadingStates[1] = false;
        });
      }
    } catch (e) {
      if (mounted) {
        setState(() {
          _tabLoadedStates[1] = true; // 오류가 나도 로드 시도는 했으므로 표시
          _tabLoadingStates[1] = false;
        });
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(content: Text('참가자 정보를 불러오는데 실패했습니다: $e')),
        );
      }
    }
  }

  // 점수 탭 데이터 로드
  Future<void> _loadScoresData() async {
    if (_tabLoadedStates[2]!) return; // 이미 로드된 경우 스킵

    setState(() {
      _tabLoadingStates[2] = true;
    });

    try {
      final eventService = Provider.of<EventService>(context, listen: false);
      final scores = await eventService.fetchEventScores(widget.event.id);

      if (mounted) {
        setState(() {
          _scores = scores;
          _tabLoadedStates[2] = true;
          _tabLoadingStates[2] = false;
        });
      }
    } catch (e) {
      if (mounted) {
        setState(() {
          _tabLoadedStates[2] = true; // 오류가 나도 로드 시도는 했으므로 표시
          _tabLoadingStates[2] = false;
        });
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(content: Text('점수 정보를 불러오는데 실패했습니다: $e')),
        );
      }
    }
  }

  // 팀 탭 데이터 로드
  Future<void> _loadTeamsData() async {
    if (_tabLoadedStates[3]! || !_showTeamTab) return; // 이미 로드된 경우 또는 팀 탭이 없는 경우 스킵

    setState(() {
      _tabLoadingStates[3] = true;
    });

    try {
      final eventService = Provider.of<EventService>(context, listen: false);
      final teams = await eventService.fetchEventTeams(widget.event.id);

      if (mounted) {
        setState(() {
          _teams = teams;
          _tabLoadedStates[3] = true;
          _tabLoadingStates[3] = false;
        });
      }
    } catch (e) {
      if (mounted) {
        setState(() {
          _tabLoadedStates[3] = true; // 오류가 나도 로드 시도는 했으므로 표시
          _tabLoadingStates[3] = false;
        });
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(content: Text('팀 정보를 불러오는데 실패했습니다: $e')),
        );
      }
    }
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(widget.event.title),
        bottom: TabBar(
          controller: _tabController,
          tabs: [
            const Tab(text: '기본 정보'),
            const Tab(text: '참가자'),
            const Tab(text: '점수'),
            if (_showTeamTab) const Tab(text: '팀'),
          ],
        ),
      ),
      body: _isInitialLoading
          ? const LoadingIndicator()
          : TabBarView(
              controller: _tabController,
              children: [
                _buildTabContent(0, _buildBasicInfoTab),
                _buildTabContent(1, _buildParticipantsTab),
                _buildTabContent(2, _buildScoresTab),
                if (_showTeamTab) _buildTabContent(3, _buildTeamsTab),
              ],
            ),
      floatingActionButton: _buildFloatingActionButton(),
    );
  }

  // 탭 콘텐츠 빌더 - 로딩 상태 처리
  Widget _buildTabContent(int tabIndex, Widget Function() contentBuilder) {
    // 탭이 로딩 중이면 로딩 인디케이터 표시
    if (_tabLoadingStates[tabIndex]!) {
      return const Center(child: LoadingIndicator());
    }

    // 탭이 로드되지 않았다면 자동 로드 시도
    if (!_tabLoadedStates[tabIndex]!) {
      // 현재 탭이 활성화된 경우에만 자동 로드
      if (_tabController.index == tabIndex) {
        switch (tabIndex) {
          case 0:
            Future.microtask(() => _loadBasicInfoData());
            break;
          case 1:
            Future.microtask(() => _loadParticipantsData());
            break;
          case 2:
            Future.microtask(() => _loadScoresData());
            break;
          case 3:
            if (_showTeamTab) {
              Future.microtask(() => _loadTeamsData());
            }
            break;
        }
      }
      return const Center(child: LoadingIndicator());
    }

    // 로드가 완료된 경우 콘텐츠 빌드
    return contentBuilder();
  }

  Widget _buildFloatingActionButton() {
    final currentTab = _tabController.index;

    switch (currentTab) {
      case 0: // 기본 정보 탭
        return FloatingActionButton(
          onPressed: _editEvent,
          child: const Icon(Icons.edit),
        );
      case 1: // 참가자 탭
        return FloatingActionButton(
          onPressed: _addParticipant,
          child: const Icon(Icons.person_add),
        );
      case 2: // 점수 탭
        return FloatingActionButton(
          onPressed: _addScore,
          child: const Icon(Icons.add_chart),
        );
      case 3: // 팀 탭 (표시되는 경우)
        if (_showTeamTab) {
          return FloatingActionButton(
            onPressed: _generateTeams,
            child: const Icon(Icons.group_add),
          );
        }
        return Container();
      default:
        return Container();
    }
  }

  // 기본 정보 탭
  Widget _buildBasicInfoTab() {
    return SingleChildScrollView(
      padding: const EdgeInsets.all(16),
      child: Column(
        crossAxisAlignment: CrossAxisAlignment.start,
        children: [
          // 이벤트 유형 및 상태 뱃지
          Row(
            children: [
              _buildBadge(
                text: widget.event.type ?? '기본',
                color: _getEventTypeColor(widget.event.type ?? '기본'),
                icon: Icons.event,
              ),
              const SizedBox(width: 8),
              _buildBadge(
                text: widget.event.status ?? '기본',
                color: _getEventStatusColor(widget.event.status ?? '기본'),
                icon: Icons.flag,
              ),
              const Spacer(),
              // 공유 버튼 추가
              IconButton(
                icon: const Icon(Icons.share),
                onPressed: () => _shareEvent(),
                tooltip: '이벤트 공유',
              ),
            ],
          ),
          const SizedBox(height: 16),

          // 이벤트 설명
          if (widget.event.description != null && widget.event.description!.isNotEmpty) ...[
            const Text(
              '설명',
              style: TextStyle(fontSize: 18, fontWeight: FontWeight.bold),
            ),
            const SizedBox(height: 8),
            Container(
              width: double.infinity,
              padding: const EdgeInsets.all(12),
              decoration: BoxDecoration(
                color: Colors.grey[100],
                borderRadius: BorderRadius.circular(8),
              ),
              child: Text(widget.event.description ?? ''),
            ),
            const SizedBox(height: 16),
          ],

          // 이벤트 정보
          const Text(
            '이벤트 정보',
            style: TextStyle(fontSize: 18, fontWeight: FontWeight.bold),
          ),
          const SizedBox(height: 8),
          _buildInfoRow(
            Icons.calendar_today,
            '시작: ${DateFormat('yyyy-MM-dd HH:mm').format(widget.event.startDate)}',
          ),
          if (widget.event.endDate != null)
            _buildInfoRow(
              Icons.calendar_today,
              '종료: ${DateFormat('yyyy-MM-dd HH:mm').format(widget.event.endDate!)}',
            ),
          if (widget.event.location != null && widget.event.location!.isNotEmpty)
            _buildInfoRow(Icons.location_on, '장소: ${widget.event.location}'),
          if (widget.event.maxParticipants != null)
            _buildInfoRow(
              Icons.people,
              '최대 참가자: ${widget.event.maxParticipants}명',
            ),
          if (widget.event.gameCount != null)
            _buildInfoRow(
              Icons.sports,
              '게임 수: ${widget.event.gameCount}게임',
            ),
          if (widget.event.participantFee != null)
            _buildInfoRow(
              Icons.attach_money,
              '참가비: ${NumberFormat.currency(locale: 'ko_KR', symbol: '₩', decimalDigits: 0).format(widget.event.participantFee)}',
            ),
          if (widget.event.registrationDeadline != null)
            _buildInfoRow(
              Icons.timer,
              '신청마감: ${DateFormat('yyyy-MM-dd HH:mm').format(widget.event.registrationDeadline!)}',
            ),
          const SizedBox(height: 16),

          // 공개 접근 정보
          Row(
            children: [
              const Text(
                '공개 접근',
                style: TextStyle(fontSize: 18, fontWeight: FontWeight.bold),
              ),
              const SizedBox(width: 8),
              if (widget.event.publicHash != null && widget.event.publicHash!.isNotEmpty)
                Tooltip(
                  message: '이 이벤트는 공개 URL을 통해 접근할 수 있습니다',
                  child: const Icon(Icons.public, size: 18, color: Colors.blue),
                ),
              if (widget.event.accessPassword != null && widget.event.accessPassword!.isNotEmpty)
                Tooltip(
                  message: '이 이벤트는 비밀번호로 보호되어 있습니다',
                  child: const Icon(Icons.lock, size: 18, color: Colors.orange),
                ),
            ],
          ),
          const SizedBox(height: 12),
          if (widget.event.publicHash != null && widget.event.publicHash!.isNotEmpty) ...[
            Container(
              width: double.infinity,
              padding: const EdgeInsets.all(12),
              decoration: BoxDecoration(
                color: Colors.blue.withOpacity(0.05),
                borderRadius: BorderRadius.circular(8),
                border: Border.all(color: Colors.blue.withOpacity(0.3)),
              ),
              child: Column(
                crossAxisAlignment: CrossAxisAlignment.start,
                children: [
                  Row(
                    children: [
                      const Icon(Icons.link, size: 18, color: Colors.blue),
                      const SizedBox(width: 8),
                      const Text(
                        '공개 URL',
                        style: TextStyle(fontWeight: FontWeight.bold),
                      ),
                      const Spacer(),
                      ElevatedButton.icon(
                        onPressed: () {
                          final url = UrlUtils.getEventPublicUrl(widget.event.publicHash!);
                          _copyToClipboard(url, '공개 URL이 클립보드에 복사되었습니다');
                        },
                        icon: const Icon(Icons.copy, size: 16),
                        label: const Text('복사'),
                        style: ElevatedButton.styleFrom(
                          backgroundColor: Colors.blue,
                          foregroundColor: Colors.white,
                          padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 0),
                          minimumSize: const Size(0, 32),
                        ),
                      ),
                    ],
                  ),
                  const SizedBox(height: 8),
                  SelectableText(
                    'https://bowling.example.com/events/${widget.event.publicHash}',
                    style: const TextStyle(color: Colors.blue),
                  ),
                  const SizedBox(height: 8),
                  const Text(
                    '이 URL을 공유하여 다른 사람들이 이벤트에 접근할 수 있도록 할 수 있습니다.',
                    style: TextStyle(fontSize: 12, color: Colors.grey),
                  ),
                ],
              ),
            ),
          ],
          const SizedBox(height: 12),
          if (widget.event.accessPassword != null && widget.event.accessPassword!.isNotEmpty) ...[
            Container(
              width: double.infinity,
              padding: const EdgeInsets.all(12),
              decoration: BoxDecoration(
                color: Colors.orange.withOpacity(0.05),
                borderRadius: BorderRadius.circular(8),
                border: Border.all(color: Colors.orange.withOpacity(0.3)),
              ),
              child: Row(
                children: [
                  const Icon(Icons.lock, size: 18, color: Colors.orange),
                  const SizedBox(width: 8),
                  const Text(
                    '접근 비밀번호: ',
                    style: TextStyle(fontWeight: FontWeight.bold),
                  ),
                  Text(widget.event.accessPassword!),
                  const Spacer(),
                  IconButton(
                    icon: const Icon(Icons.copy, size: 18),
                    onPressed: () {
                      _copyToClipboard(widget.event.accessPassword!, '비밀번호가 클립보드에 복사되었습니다');
                    },
                    tooltip: '비밀번호 복사',
                    color: Colors.orange,
                    padding: EdgeInsets.zero,
                    constraints: const BoxConstraints(),
                  ),
                ],
              ),
            ),
          ],

          // 참가자 정보
          const SizedBox(height: 16),
          const Text(
            '참가자 정보',
            style: TextStyle(fontSize: 18, fontWeight: FontWeight.bold),
          ),
          const SizedBox(height: 8),
          _buildInfoRow(
            Icons.people,
            '현재 참가자: ${_participants.length}명',
          ),
        ],
      ),
    );
  }

  // 참가자 탭
  Widget _buildParticipantsTab() {
    // 필터링 및 정렬을 위한 상태 변수
    final TextEditingController _searchController = TextEditingController();
    String _searchQuery = '';
    String _filterStatus = '전체';
    String _filterPayment = '전체';
    String _filterMemberType = '전체';
    String _sortBy = '이름';
    bool _sortAscending = true;

    // 필터링된 참가자 목록
    List<Participant> _filteredParticipants() {
      return _participants.where((participant) {
        // 검색어 필터링
        final nameMatch = _searchQuery.isEmpty || 
            (participant.name?.toLowerCase().contains(_searchQuery.toLowerCase()) ?? false);
        
        // 상태 필터링
        final statusMatch = _filterStatus == '전체' || 
            participant.status == _filterStatus;
        
        // 결제 상태 필터링
        final paymentMatch = _filterPayment == '전체' || 
            (_filterPayment == '결제완료' && participant.isPaid) || 
            (_filterPayment == '미결제' && !participant.isPaid);
        
        // 회원 유형 필터링
        final memberTypeMatch = _filterMemberType == '전체' || 
            participant.memberType == _filterMemberType;
        
        return nameMatch && statusMatch && paymentMatch && memberTypeMatch;
      }).toList();
    }

    // 정렬된 참가자 목록
    List<Participant> _sortedParticipants() {
      final filtered = _filteredParticipants();
      
      switch (_sortBy) {
        case '이름':
          filtered.sort((a, b) => _sortAscending 
              ? (a.name ?? '').compareTo(b.name ?? '') 
              : (b.name ?? '').compareTo(a.name ?? ''));
          break;
        case '등록일':
          filtered.sort((a, b) => _sortAscending 
              ? (a.registeredAt ?? DateTime.now()).compareTo(b.registeredAt ?? DateTime.now()) 
              : (b.registeredAt ?? DateTime.now()).compareTo(a.registeredAt ?? DateTime.now()));
          break;
        case '상태':
          filtered.sort((a, b) => _sortAscending 
              ? (a.status ?? '').compareTo(b.status ?? '') 
              : (b.status ?? '').compareTo(a.status ?? ''));
          break;
      }
      
      return filtered;
    }

    // 참가자 상태 목록
    final statusOptions = ['전체', '확정', '대기', '취소'];
    final paymentOptions = ['전체', '결제완료', '미결제'];
    final memberTypeOptions = ['전체', '정회원', '준회원', '게스트'];
    final sortOptions = ['이름', '등록일', '상태'];

    if (_participants.isEmpty) {
      return const Center(
        child: Text('참가자가 없습니다.'),
      );
    }

    return StatefulBuilder(
      builder: (context, setState) {
        final displayedParticipants = _sortedParticipants();
        
        return Column(
          children: [
            // 검색 및 필터 영역
            Container(
              padding: const EdgeInsets.all(8),
              color: Colors.grey.shade50,
              child: Column(
                children: [
                  // 검색 필드
                  TextField(
                    controller: _searchController,
                    decoration: InputDecoration(
                      hintText: '참가자 검색',
                      prefixIcon: const Icon(Icons.search),
                      suffixIcon: _searchQuery.isNotEmpty 
                          ? IconButton(
                              icon: const Icon(Icons.clear),
                              onPressed: () {
                                _searchController.clear();
                                setState(() => _searchQuery = '');
                              },
                            )
                          : null,
                      border: OutlineInputBorder(
                        borderRadius: BorderRadius.circular(8),
                        borderSide: BorderSide(color: Colors.grey.shade300),
                      ),
                      contentPadding: const EdgeInsets.symmetric(vertical: 0, horizontal: 16),
                    ),
                    onChanged: (value) {
                      setState(() => _searchQuery = value);
                    },
                  ),
                  
                  const SizedBox(height: 8),
                  
                  // 필터 및 정렬 옵션
                  SingleChildScrollView(
                    scrollDirection: Axis.horizontal,
                    child: Row(
                      children: [
                        // 상태 필터
                        Container(
                          padding: const EdgeInsets.symmetric(horizontal: 8),
                          decoration: BoxDecoration(
                            border: Border.all(color: Colors.grey.shade300),
                            borderRadius: BorderRadius.circular(8),
                          ),
                          child: DropdownButton<String>(
                            value: _filterStatus,
                            icon: const Icon(Icons.arrow_drop_down),
                            underline: Container(),
                            hint: const Text('상태'),
                            onChanged: (String? newValue) {
                              if (newValue != null) {
                                setState(() => _filterStatus = newValue);
                              }
                            },
                            items: statusOptions.map<DropdownMenuItem<String>>((String value) {
                              return DropdownMenuItem<String>(
                                value: value,
                                child: Text(value),
                              );
                            }).toList(),
                          ),
                        ),
                        
                        const SizedBox(width: 8),
                        
                        // 결제 상태 필터
                        Container(
                          padding: const EdgeInsets.symmetric(horizontal: 8),
                          decoration: BoxDecoration(
                            border: Border.all(color: Colors.grey.shade300),
                            borderRadius: BorderRadius.circular(8),
                          ),
                          child: DropdownButton<String>(
                            value: _filterPayment,
                            icon: const Icon(Icons.arrow_drop_down),
                            underline: Container(),
                            hint: const Text('결제 상태'),
                            onChanged: (String? newValue) {
                              if (newValue != null) {
                                setState(() => _filterPayment = newValue);
                              }
                            },
                            items: paymentOptions.map<DropdownMenuItem<String>>((String value) {
                              return DropdownMenuItem<String>(
                                value: value,
                                child: Text(value),
                              );
                            }).toList(),
                          ),
                        ),
                        
                        const SizedBox(width: 8),
                        
                        // 회원 유형 필터
                        Container(
                          padding: const EdgeInsets.symmetric(horizontal: 8),
                          decoration: BoxDecoration(
                            border: Border.all(color: Colors.grey.shade300),
                            borderRadius: BorderRadius.circular(8),
                          ),
                          child: DropdownButton<String>(
                            value: _filterMemberType,
                            icon: const Icon(Icons.arrow_drop_down),
                            underline: Container(),
                            hint: const Text('회원 유형'),
                            onChanged: (String? newValue) {
                              if (newValue != null) {
                                setState(() => _filterMemberType = newValue);
                              }
                            },
                            items: memberTypeOptions.map<DropdownMenuItem<String>>((String value) {
                              return DropdownMenuItem<String>(
                                value: value,
                                child: Text(value),
                              );
                            }).toList(),
                          ),
                        ),
                        
                        const SizedBox(width: 8),
                        
                        // 정렬 옵션
                        Container(
                          padding: const EdgeInsets.symmetric(horizontal: 8),
                          decoration: BoxDecoration(
                            border: Border.all(color: Colors.grey.shade300),
                            borderRadius: BorderRadius.circular(8),
                          ),
                          child: Row(
                            mainAxisSize: MainAxisSize.min,
                            children: [
                              DropdownButton<String>(
                                value: _sortBy,
                                icon: const Icon(Icons.arrow_drop_down),
                                underline: Container(),
                                hint: const Text('정렬'),
                                onChanged: (String? newValue) {
                                  if (newValue != null) {
                                    setState(() => _sortBy = newValue);
                                  }
                                },
                                items: sortOptions.map<DropdownMenuItem<String>>((String value) {
                                  return DropdownMenuItem<String>(
                                    value: value,
                                    child: Text(value),
                                  );
                                }).toList(),
                              ),
                              IconButton(
                                icon: Icon(_sortAscending ? Icons.arrow_upward : Icons.arrow_downward),
                                onPressed: () {
                                  setState(() => _sortAscending = !_sortAscending);
                                },
                                tooltip: _sortAscending ? '오름차순' : '내림차순',
                                padding: EdgeInsets.zero,
                                constraints: const BoxConstraints(),
                              ),
                            ],
                          ),
                        ),
                      ],
                    ),
                  ),
                  
                  // 필터 적용 상태 표시
                  if (_filterStatus != '전체' || _filterPayment != '전체' || _filterMemberType != '전체' || _searchQuery.isNotEmpty) ...[  
                    const SizedBox(height: 8),
                    Row(
                      children: [
                        const Text('필터: ', style: TextStyle(fontWeight: FontWeight.bold)),
                        if (_searchQuery.isNotEmpty)
                          _buildFilterChip(
                            label: '"$_searchQuery"',
                            onRemove: () {
                              _searchController.clear();
                              setState(() => _searchQuery = '');
                            },
                          ),
                        if (_filterStatus != '전체')
                          _buildFilterChip(
                            label: '상태: $_filterStatus',
                            onRemove: () => setState(() => _filterStatus = '전체'),
                          ),
                        if (_filterPayment != '전체')
                          _buildFilterChip(
                            label: '결제: $_filterPayment',
                            onRemove: () => setState(() => _filterPayment = '전체'),
                          ),
                        if (_filterMemberType != '전체')
                          _buildFilterChip(
                            label: '회원: $_filterMemberType',
                            onRemove: () => setState(() => _filterMemberType = '전체'),
                          ),
                        const Spacer(),
                        TextButton(
                          onPressed: () {
                            _searchController.clear();
                            setState(() {
                              _searchQuery = '';
                              _filterStatus = '전체';
                              _filterPayment = '전체';
                              _filterMemberType = '전체';
                            });
                          },
                          child: const Text('필터 초기화'),
                        ),
                      ],
                    ),
                  ],
                  
                  // 참가자 수 표시
                  Padding(
                    padding: const EdgeInsets.symmetric(vertical: 8),
                    child: Row(
                      children: [
                        Text(
                          '총 ${_participants.length}명 중 ${displayedParticipants.length}명 표시',
                          style: TextStyle(color: Colors.grey.shade700),
                        ),
                      ],
                    ),
                  ),
                ],
              ),
            ),
            
            // 참가자 목록
            Expanded(
              child: displayedParticipants.isEmpty
                  ? Center(
                      child: Column(
                        mainAxisAlignment: MainAxisAlignment.center,
                        children: [
                          const Icon(Icons.search_off, size: 48, color: Colors.grey),
                          const SizedBox(height: 16),
                          const Text('검색 결과가 없습니다.'),
                          const SizedBox(height: 8),
                          ElevatedButton(
                            onPressed: () {
                              _searchController.clear();
                              setState(() {
                                _searchQuery = '';
                                _filterStatus = '전체';
                                _filterPayment = '전체';
                                _filterMemberType = '전체';
                              });
                            },
                            child: const Text('필터 초기화'),
                          ),
                        ],
                      ),
                    )
                  : ListView.builder(
                      itemCount: displayedParticipants.length,
                      itemBuilder: (context, index) {
                        final participant = displayedParticipants[index];
                        
                        return Card(
                          margin: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
                          elevation: 2,
                          shape: RoundedRectangleBorder(
                            borderRadius: BorderRadius.circular(8),
                            side: BorderSide(color: Colors.grey.shade200),
                          ),
                          child: Padding(
                            padding: const EdgeInsets.all(8),
                            child: Column(
                              crossAxisAlignment: CrossAxisAlignment.start,
                              children: [
                                // 참가자 기본 정보
                                ListTile(
                                  contentPadding: EdgeInsets.zero,
                                  leading: CircleAvatar(
                                    backgroundColor: Colors.blue.shade100,
                                    child: Text(
                                      participant.name?.substring(0, 1) ?? '?',
                                      style: const TextStyle(color: Colors.blue),
                                    ),
                                  ),
                                  title: Text(
                                    participant.name ?? '이름 없음',
                                    style: const TextStyle(fontWeight: FontWeight.bold),
                                  ),
                                  subtitle: participant.registeredAt != null
                                      ? Text(
                                          '등록일: ${DateFormat('yyyy-MM-dd').format(participant.registeredAt!)}',
                                          style: TextStyle(color: Colors.grey.shade600, fontSize: 12),
                                        )
                                      : null,
                                  trailing: Row(
                                    mainAxisSize: MainAxisSize.min,
                                    children: [
                                      IconButton(
                                        icon: const Icon(Icons.edit, size: 20),
                                        tooltip: '참가자 정보 수정',
                                        onPressed: () => _editParticipant(participant),
                                      ),
                                      IconButton(
                                        icon: const Icon(Icons.delete, size: 20),
                                        tooltip: '참가자 삭제',
                                        onPressed: () => _removeParticipant(participant),
                                      ),
                                    ],
                                  ),
                                  onTap: () => _showParticipantDetails(participant),
                                ),
                                
                                // 뱃지 영역
                                Padding(
                                  padding: const EdgeInsets.only(left: 8, right: 8, bottom: 8),
                                  child: Wrap(
                                    spacing: 8,
                                    runSpacing: 8,
                                    children: [
                                      // 회원 유형 뱃지
                                      if (participant.memberType != null && participant.memberType!.isNotEmpty)
                                        _buildBadge(
                                          text: participant.memberType!,
                                          color: _getMemberTypeColor(participant.memberType!),
                                          icon: Icons.person,
                                        ),
                                      
                                      // 참가 상태 뱃지
                                      if (participant.status != null)
                                        _buildBadge(
                                          text: participant.status!,
                                          color: _getParticipantStatusColor(participant.status!),
                                          icon: _getParticipantStatusIcon(participant.status!),
                                        ),
                                      
                                      // 결제 상태 뱃지
                                      Row(
                                        children: [
                                          Expanded(
                                            child: _buildInfoRow(
                                              Icons.password,
                                              participant.isPaid ? '결제완료' : '미결제',
                                              isSelectable: true,
                                            ),
                                          ),
                                          if (participant.isPaid)
                                            IconButton(
                                              icon: const Icon(Icons.copy, size: 20),
                                              onPressed: () => _copyToClipboard(
                                                participant.isPaid ? '결제완료' : '미결제',
                                                '결제 상태가 클립보드에 복사되었습니다',
                                              ),
                                              tooltip: '클립보드에 복사',
                                            ),
                                        ],
                                      ),
                                    ],
                                  ),
                                ),
                              ],
                            ),
                          ),
                        );
                      },
                    ),
            ),
          ],
        );
      },
    );
  }
  
  // 필터 칩 위젯
  Widget _buildFilterChip({required String label, required VoidCallback onRemove}) {
    return Container(
      margin: const EdgeInsets.only(right: 8),
      padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
      decoration: BoxDecoration(
        color: Colors.blue.shade50,
        borderRadius: BorderRadius.circular(16),
      ),
      child: Row(
        mainAxisSize: MainAxisSize.min,
        children: [
          Text(label, style: TextStyle(fontSize: 12, color: Colors.blue.shade800)),
          const SizedBox(width: 4),
          InkWell(
            onTap: onRemove,
            child: Icon(Icons.close, size: 14, color: Colors.blue.shade800),
          ),
        ],
      ),
    );
  }

  // 점수 탭
  Widget _buildScoresTab() {
    if (_scores.isEmpty) {
      return const Center(
        child: Text('등록된 점수가 없습니다.'),
      );
    }

    // 핸디캡 포함 점수 표시 여부
    bool _showWithHandicap = false;
    
    // 점수를 내림차순으로 정렬하여 순위 계산
    final sortedScores = List<Score>.from(_scores);
    
    // 점수 순위 계산을 위한 맵 (동점자 처리를 위해)
    final Map<String, int> scoreRanks = {};
    
    // 핸디캡 포함 점수로 정렬하는 함수
    void sortScores(bool withHandicap) {
      if (withHandicap) {
        sortedScores.sort((a, b) => b.totalWithHandicap.compareTo(a.totalWithHandicap));
      } else {
        sortedScores.sort((a, b) => b.totalScore.compareTo(a.totalScore));
      }
      
      // 동점자 처리를 위한 순위 계산
      scoreRanks.clear();
      int rank = 1;
      int count = 0;
      int sameRankCount = 0;
      int prevScore = -1;
      
      for (int i = 0; i < sortedScores.length; i++) {
        final score = sortedScores[i];
        final currentScore = withHandicap ? score.totalWithHandicap : score.totalScore;
        
        // 이전 점수와 비교하여 동점자 처리
        if (i > 0 && currentScore == prevScore) {
          // 동점자는 이전 순위와 같은 순위 부여
          scoreRanks[score.id] = rank - sameRankCount;
          sameRankCount++;
        } else {
          // 새로운 점수는 현재까지의 카운트 + 1을 순위로 부여
          rank = count + 1;
          scoreRanks[score.id] = rank;
          sameRankCount = 1;
        }
        
        prevScore = currentScore;
        count++;
      }
    }
    
    // 초기 정렬
    sortScores(false);

    // 평균 점수 계산
    final totalScoreSum = sortedScores.fold<int>(0, (sum, score) => sum + score.totalScore);
    final averageScore = sortedScores.isNotEmpty ? totalScoreSum / sortedScores.length : 0;
    
    // 평균 핸디캡 계산
    final handicapScores = sortedScores.where((score) => score.handicap != null).toList();
    final totalHandicapSum = handicapScores.fold<int>(0, (sum, score) => sum + (score.handicap ?? 0));
    final averageHandicap = handicapScores.isNotEmpty ? totalHandicapSum / handicapScores.length : 0;

    return StatefulBuilder(
      builder: (context, setState) {
        return Column(
          children: [
            // 평균 점수 표시
            Container(
              padding: const EdgeInsets.all(8),
              margin: const EdgeInsets.all(8),
              decoration: BoxDecoration(
                color: Colors.blue.shade50,
                borderRadius: BorderRadius.circular(8),
                border: Border.all(color: Colors.blue.shade200),
              ),
              child: Column(
                children: [
                  Row(
                    mainAxisAlignment: MainAxisAlignment.center,
                    children: [
                      const Icon(Icons.score, color: Colors.blue),
                      const SizedBox(width: 8),
                      Text(
                        '평균 점수: ${averageScore.toStringAsFixed(1)}',
                        style: const TextStyle(fontWeight: FontWeight.bold),
                      ),
                    ],
                  ),
                  if (handicapScores.isNotEmpty) ...[  
                    const SizedBox(height: 4),
                    Row(
                      mainAxisAlignment: MainAxisAlignment.center,
                      children: [
                        const Icon(Icons.add_circle_outline, color: Colors.green),
                        const SizedBox(width: 8),
                        Text(
                          '평균 핸디캡: ${averageHandicap.toStringAsFixed(1)}',
                          style: const TextStyle(fontWeight: FontWeight.bold),
                        ),
                      ],
                    ),
                  ],
                ],
              ),
            ),
            
            // 핸디캡 포함 점수 표시 옵션
            if (handicapScores.isNotEmpty)
              Padding(
                padding: const EdgeInsets.symmetric(horizontal: 16.0),
                child: Row(
                  children: [
                    const Text('핸디캡 포함 점수 표시'),
                    const Spacer(),
                    Switch(
                      value: _showWithHandicap,
                      onChanged: (value) {
                        setState(() {
                          _showWithHandicap = value;
                          sortScores(value);
                        });
                      },
                    ),
                  ],
                ),
              ),
            

        // 점수 목록
        Expanded(
          child: ListView.builder(
            itemCount: sortedScores.length,
            itemBuilder: (context, index) {
              final score = sortedScores[index];
              // 동점자 처리가 적용된 순위 사용
              final rank = scoreRanks[score.id] ?? (index + 1);

              // 참가자 이름 찾기
              final participant = _participants.firstWhere(
                (p) => p.memberId == score.memberId,
                orElse: () => Participant(
                  id: '',
                  eventId: '',
                  memberId: score.memberId,
                  name: '알 수 없음',
                ),
              );

              return Card(
                margin: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
                child: ListTile(
                  leading: CircleAvatar(
                    backgroundColor: _getRankColor(rank),
                    child: Text(
                      rank.toString(),
                      style: const TextStyle(color: Colors.white, fontWeight: FontWeight.bold),
                    ),
                  ),
                  title: Row(
                    children: [
                      Expanded(
                        child: Text(
                          participant.name ?? '알 수 없음',
                          style: const TextStyle(fontWeight: FontWeight.bold),
                        ),
                      ),
                      Container(
                        padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 2),
                        decoration: BoxDecoration(
                          color: Colors.blue.shade100,
                          borderRadius: BorderRadius.circular(12),
                        ),
                        child: Text(
                          _showWithHandicap && score.handicap != null
                              ? '총점: ${score.totalWithHandicap} (⬆${score.handicap})'
                              : '총점: ${score.totalScore}',
                          style: const TextStyle(fontWeight: FontWeight.bold),
                        ),
                      ),
                    ],
                  ),
                  subtitle: Column(
                    crossAxisAlignment: CrossAxisAlignment.start,
                    children: [
                      const SizedBox(height: 4),
                      Text(
                        '날짜: ${DateFormat('yyyy-MM-dd').format(score.date)}',
                      ),
                      const SizedBox(height: 4),
                      SingleChildScrollView(
                        scrollDirection: Axis.horizontal,
                        child: Row(
                          children: score.frames.asMap().entries.map((entry) {
                            return Container(
                              width: 30,
                              height: 30,
                              margin: const EdgeInsets.only(right: 4),
                              decoration: BoxDecoration(
                                color: _getScoreColor(entry.value),
                                borderRadius: BorderRadius.circular(4),
                              ),
                              child: Center(
                                child: Text(
                                  entry.value.toString(),
                                  style: const TextStyle(
                                    color: Colors.white,
                                    fontWeight: FontWeight.bold,
                                  ),
                                ),
                              ),
                            );
                          }).toList(),
                        ),
                      ),
                    ],
                  ),
                  trailing: Row(
                    mainAxisSize: MainAxisSize.min,
                    children: [
                      IconButton(
                        icon: const Icon(Icons.edit, size: 20),
                        tooltip: '점수 수정',
                        onPressed: () => _editScore(score),
                      ),
                      IconButton(
                        icon: const Icon(Icons.delete, size: 20),
                        tooltip: '점수 삭제',
                        onPressed: () => _deleteScore(score),
                      ),
                    ],
                  ),
                  onTap: () => _showScoreDetails(score),
                ),
              );
            },
          ),
        ),
      ],
    );
  }

  // 팀 탭
  Widget _buildTeamsTab() {
    if (_teams.isEmpty) {
      return Center(
        child: Padding(
          padding: const EdgeInsets.all(16.0),
          child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: [
              const Icon(Icons.groups, size: 64, color: Colors.blue),
              const SizedBox(height: 16),
              const Text('생성된 팀이 없습니다.', style: TextStyle(fontSize: 18, fontWeight: FontWeight.bold)),
              const SizedBox(height: 24),
              // 팀 생성 옵션
              Card(
                child: Padding(
                  padding: const EdgeInsets.all(16.0),
                  child: Column(
                    crossAxisAlignment: CrossAxisAlignment.start,
                    children: [
                      const Text('팀 생성 옵션', style: TextStyle(fontSize: 16, fontWeight: FontWeight.bold)),
                      const SizedBox(height: 16),
                      // 팀 생성 방법 선택
                      Row(
                        children: [
                          Radio<int>(
                            value: 1,
                            groupValue: _teamGenerationMethod,
                            onChanged: (value) {
                              setState(() {
                                _teamGenerationMethod = value!;
                              });
                            },
                          ),
                          const Text('팀 인원수로 나누기'),
                        ],
                      ),
                      if (_teamGenerationMethod == 1)
                        Padding(
                          padding: const EdgeInsets.only(left: 32.0),
                          child: Row(
                            children: [
                              SizedBox(
                                width: 80,
                                child: TextFormField(
                                  controller: _teamSizeController,
                                  decoration: const InputDecoration(
                                    labelText: '인원수',
                                    suffixText: '명',
                                  ),
                                  keyboardType: TextInputType.number,
                                  inputFormatters: [FilteringTextInputFormatter.digitsOnly],
                                ),
                              ),
                              const SizedBox(width: 16),
                              Text('총 ${_participants.length}명 참가자'),
                            ],
                          ),
                        ),
                      const SizedBox(height: 8),
                      Row(
                        children: [
                          Radio<int>(
                            value: 2,
                            groupValue: _teamGenerationMethod,
                            onChanged: (value) {
                              setState(() {
                                _teamGenerationMethod = value!;
                              });
                            },
                          ),
                          const Text('팀 개수로 나누기'),
                        ],
                      ),
                      if (_teamGenerationMethod == 2)
                        Padding(
                          padding: const EdgeInsets.only(left: 32.0),
                          child: Row(
                            children: [
                              SizedBox(
                                width: 80,
                                child: TextFormField(
                                  controller: _teamCountController,
                                  decoration: const InputDecoration(
                                    labelText: '팀 수',
                                    suffixText: '개',
                                  ),
                                  keyboardType: TextInputType.number,
                                  inputFormatters: [FilteringTextInputFormatter.digitsOnly],
                                ),
                              ),
                              const SizedBox(width: 16),
                              Text('총 ${_participants.length}명 참가자'),
                            ],
                          ),
                        ),
                      const SizedBox(height: 16),
                      // 팀 생성 버튼
                      Row(
                        mainAxisAlignment: MainAxisAlignment.center,
                        children: [
                          ElevatedButton.icon(
                            onPressed: _generateTeams,
                            icon: const Icon(Icons.group_add),
                            label: const Text('팀 생성하기'),
                            style: ElevatedButton.styleFrom(
                              backgroundColor: Colors.blue,
                              foregroundColor: Colors.white,
                              padding: const EdgeInsets.symmetric(horizontal: 24, vertical: 12),
                            ),
                          ),
                        ],
                      ),
                    ],
                  ),
                ),
              ),
            ],
          ),
        ),
      );
    }

    // 미배정 참가자 목록 조회
    final List<Participant> unassignedParticipants = _getUnassignedParticipants();

    return Column(
      children: [
        // 팀 관리 버튼
        Padding(
          padding: const EdgeInsets.all(8.0),
          child: Row(
            mainAxisAlignment: MainAxisAlignment.spaceEvenly,
            children: [
              ElevatedButton.icon(
                onPressed: _generateTeams,
                icon: const Icon(Icons.refresh),
                label: const Text('팀 재생성'),
                style: ElevatedButton.styleFrom(
                  backgroundColor: Colors.blue,
                  foregroundColor: Colors.white,
                ),
              ),
              ElevatedButton.icon(
                onPressed: _saveTeams,
                icon: const Icon(Icons.save),
                label: const Text('팀 저장'),
                style: ElevatedButton.styleFrom(
                  backgroundColor: Colors.green,
                  foregroundColor: Colors.white,
                ),
              ),
            ],
          ),
        ),

        // 이벤트 설명
        if (widget.event.description != null && widget.event.description!.isNotEmpty)
          Padding(
            padding: const EdgeInsets.symmetric(vertical: 16.0),
            child: Column(
              crossAxisAlignment: CrossAxisAlignment.start,
              children: [
                const Text(
                  '이벤트 설명',
                  style: TextStyle(fontSize: 18, fontWeight: FontWeight.bold),
                ),
                const SizedBox(height: 8),
                Text(widget.event.description!),
              ],
            ),
          ),

        // 버튼 그룹 (공유 및 알림)
        Padding(
          padding: const EdgeInsets.symmetric(vertical: 16.0),
          child: Row(
            mainAxisAlignment: MainAxisAlignment.spaceEvenly,
            children: [
              // 공유 버튼
              Expanded(
                child: ElevatedButton.icon(
                  onPressed: () => _shareEvent(),
                  icon: const Icon(Icons.share),
                  label: const Text('이벤트 공유'),
                  style: ElevatedButton.styleFrom(
                    foregroundColor: Colors.white,
                    backgroundColor: Colors.blue,
                  ),
                ),
              ),
              const SizedBox(width: 8),
              // 알림 설정 버튼
              Expanded(
                child: ElevatedButton.icon(
                  onPressed: _setEventReminders,
                  icon: const Icon(Icons.notifications_active),
                  label: const Text('알림 설정'),
                  style: ElevatedButton.styleFrom(
                    foregroundColor: Colors.white,
                    backgroundColor: Colors.green,
                  ),
                ),
              ),
            ],
          ),
        ),

        // 미배정 참가자 섹션
        if (unassignedParticipants.isNotEmpty)
          Card(
            margin: const EdgeInsets.all(8),
            color: Colors.amber.shade50,
            child: Column(
              crossAxisAlignment: CrossAxisAlignment.start,
              children: [
                Padding(
                  padding: const EdgeInsets.all(8.0),
                  child: Row(
                    children: [
                      const Icon(Icons.person_off, color: Colors.amber),
                      const SizedBox(width: 8),
                      Text('미배정 참가자 (${unassignedParticipants.length}명)',
                          style: const TextStyle(fontWeight: FontWeight.bold)),
                    ],
                  ),
                ),
                const Divider(height: 1),
                Wrap(
                  children: unassignedParticipants.map((participant) {
                    return Padding(
                      padding: const EdgeInsets.all(4.0),
                      child: Chip(
                        avatar: const CircleAvatar(
                          child: Icon(Icons.person, size: 16),
                        ),
                        label: Text(participant.name ?? '알 수 없음'),
                        deleteIcon: const Icon(Icons.add_circle, size: 18),
                        onDeleted: () => _showTeamSelectionDialog(participant),
                      ),
                    );
                  }).toList(),
                ),
              ],
            ),
          ),

        // 팀 목록
        Expanded(
          child: ListView.builder(
            itemCount: _teams.length,
            itemBuilder: (context, index) {
              final team = _teams[index];
              final teamMembers = _getTeamMembers(team);
              final teamAverage = _calculateTeamAverage(team);

              return Card(
                margin: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
                child: ExpansionTile(
                  leading: CircleAvatar(
                    backgroundColor: Colors.blue.shade700,
                    child: Text('${index + 1}', style: const TextStyle(color: Colors.white)),
                  ),
                  title: Row(
                    children: [
                      Text('팀 ${team.name}', style: const TextStyle(fontWeight: FontWeight.bold)),
                      const SizedBox(width: 8),
                      Container(
                        padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 2),
                        decoration: BoxDecoration(
                          color: Colors.blue.shade100,
                          borderRadius: BorderRadius.circular(12),
                        ),
                        child: Text('${team.memberIds.length}명'),
                      ),
                    ],
                  ),
                  subtitle: Row(
                    children: [
                      const Icon(Icons.bar_chart, size: 16, color: Colors.blue),
                      const SizedBox(width: 4),
                      Text('팀 에버리지: ${teamAverage.toStringAsFixed(1)}'),
                    ],
                  ),
                  children: [
                    Padding(
                      padding: const EdgeInsets.symmetric(horizontal: 16.0, vertical: 8.0),
                      child: Row(
                        children: [
                          const Icon(Icons.info_outline, size: 16, color: Colors.blue),
                          const SizedBox(width: 8),
                          const Text('팀원을 드래그하여 순서를 변경할 수 있습니다', style: TextStyle(fontSize: 12, color: Colors.blue)),
                        ],
                      ),
                    ),
                    ReorderableListView(
                      shrinkWrap: true,
                      physics: const NeverScrollableScrollPhysics(),
                      onReorder: (oldIndex, newIndex) {
                        setState(() {
                          if (oldIndex < newIndex) {
                            newIndex -= 1;
                          }
                          final participant = teamMembers.removeAt(oldIndex);
                          teamMembers.insert(newIndex, participant);
                          
                          // 팀 모델의 memberIds 순서 업데이트
                          final updatedMemberIds = teamMembers.map((p) => p.id).toList();
                          final teamIndex = _teams.indexWhere((t) => t.id == team.id);
                          if (teamIndex != -1) {
                            _teams[teamIndex] = Team(
                              id: team.id,
                              eventId: team.eventId,
                              name: team.name,
                              memberIds: updatedMemberIds,
                              description: team.description,
                              createdAt: team.createdAt,
                              updatedAt: DateTime.now(),
                            );
                          }
                        });
                      },
                      children: teamMembers.map((participant) {
                        // 참가자의 평균 점수 계산
                        final participantScores = _scores.where((s) => s.memberId == participant.memberId).toList();
                        final participantAverage = participantScores.isNotEmpty
                            ? participantScores.fold<int>(0, (sum, s) => sum + s.totalScore) / participantScores.length
                            : 0.0;

                        return ListTile(
                          key: Key(participant.id),
                          leading: const CircleAvatar(
                            child: Icon(Icons.person, size: 16),
                          ),
                          title: Text(participant.name ?? '알 수 없음'),
                          subtitle: Text('평균: ${participantAverage.toStringAsFixed(1)}'),
                          trailing: Row(
                            mainAxisSize: MainAxisSize.min,
                            children: [
                              const Icon(Icons.drag_handle, color: Colors.grey),
                              const SizedBox(width: 8),
                              IconButton(
                                icon: const Icon(Icons.remove_circle, color: Colors.red),
                                tooltip: '팀에서 제외',
                                onPressed: () => _removeFromTeam(team, participant),
                              ),
                            ],
                          ),
                        );
                      }).toList(),
                    ),
                    // 팀원 추가 버튼
                    if (unassignedParticipants.isNotEmpty)
                      ListTile(
                        leading: const Icon(Icons.add_circle, color: Colors.green),
                        title: const Text('팀원 추가하기'),
                        onTap: () => _showParticipantSelectionDialog(team),
                      ),
                  ],
                ),
              );
            },
          ),
        ),
      ],
    );
  }

  // 정보 행 위젯
  Widget _buildInfoRow(IconData icon, String text, {bool isSelectable = false}) {
    return Padding(
      padding: const EdgeInsets.symmetric(vertical: 8.0),
      child: Row(
        children: [
          Icon(icon, color: Colors.blue),
          const SizedBox(width: 8),
          isSelectable
              ? Expanded(
                  child: SelectableText(
                    text,
                    style: const TextStyle(fontSize: 16),
                  ),
                )
              : Expanded(
                  child: Text(
                    text,
                    style: const TextStyle(fontSize: 16),
                  ),
                ),
        ],
      ),
    );
  }

  // 뱃지 위젯 빌더 메서드
  Widget _buildBadge({
    required String text,
    required Color color,
    IconData? icon,
    bool outlined = true,
    EdgeInsets? margin,
  }) {
    return BadgeWidget(
      text: text,
      color: color,
      icon: icon,
      outlined: outlined,
      margin: margin,
    );
  }

  // 이벤트 유형에 따른 색상 반환
  Color _getEventTypeColor(String type) {
    switch (type.toLowerCase()) {
      case '개인전':
      case 'individual':
        return Colors.blue;
      case '팀전':
      case 'team':
        return Colors.purple;
      case '리그':
      case 'league':
        return Colors.green;
      case '토너먼트':
      case 'tournament':
        return Colors.orange;
      default:
        return Colors.grey;
    }
  }

  // 이벤트 상태에 따른 색상 반환
  Color _getEventStatusColor(String status) {
    switch (status.toLowerCase()) {
      case 'draft':
      case '초안':
        return Colors.grey;
      case 'published':
      case '공개됨':
        return Colors.blue;
      case 'in_progress':
      case '진행중':
        return Colors.green;
      case 'completed':
      case '완료됨':
        return Colors.purple;
      case 'cancelled':
      case '취소됨':
        return Colors.red;
      default:
        return Colors.grey;
    }
  }

  // 참가자 상태에 따른 색상 반환
  Color _getParticipantStatusColor(String status) {
    switch (status.toLowerCase()) {
      case 'registered':
      case '등록됨':
        return Colors.blue;
      case 'confirmed':
      case '확인됨':
        return Colors.green;
      case 'cancelled':
      case '취소됨':
        return Colors.red;
      default:
        return Colors.grey;
    }
  }

  // 참가자 상태에 따른 아이콘 반환
  IconData _getParticipantStatusIcon(String status) {
    switch (status.toLowerCase()) {
      case 'registered':
      case '등록됨':
        return Icons.how_to_reg;
      case 'confirmed':
      case '확인됨':
        return Icons.verified;
      case 'cancelled':
      case '취소됨':
        return Icons.cancel;
      default:
        return Icons.help_outline;
    }
  }

  // 순위에 따른 색상 반환
  Color _getRankColor(int rank) {
    switch (rank) {
      case 1:
        return Colors.amber.shade700; // 금메달
      case 2:
        return Colors.blueGrey.shade400; // 은메달
      case 3:
        return Colors.brown.shade400; // 동메달
      default:
        return Colors.blue.shade700; // 기본 색상
    }
  }

  // 점수에 따른 색상 반환
  Color _getScoreColor(int score) {
    if (score >= 9) {
      return Colors.red.shade700; // 스트라이크
    } 
    if (score >= 7) {
      return Colors.orange.shade700; // 좋은 점수
    } 
    if (score >= 5) {
      return Colors.green.shade700; // 평균 점수
    } 
    // 낮은 점수
    return Colors.blue.shade700;
  }

  // 미배정 참가자 목록 가져오기
  List<Participant> _getUnassignedParticipants() {
    if (_participants.isEmpty || _teams.isEmpty) {
      return _participants;
    }

    // 현재 팀에 배정된 모든 참가자 ID 목록
    final List<String> assignedMemberIds = [];
    for (final team in _teams) {
      assignedMemberIds.addAll(team.memberIds);
    }

    // 미배정 참가자만 필터링
    return _participants.where((p) => p.memberId != null && !assignedMemberIds.contains(p.memberId)).toList();
  }

  // 팀원 목록 가져오기
  List<Participant> _getTeamMembers(Team team) {
    return _participants
        .where((p) => p.memberId != null && team.memberIds.contains(p.memberId))
        .toList();
  }

  // 팀 평균 점수 계산
  double _calculateTeamAverage(Team team, {bool withHandicap = false}) {
    if (team.memberIds.isEmpty) return 0.0;

    double totalAverage = 0.0;
    int memberCount = 0;

    for (final memberId in team.memberIds) {
      final memberScores = _scores.where((s) => s.memberId == memberId).toList();
      if (memberScores.isNotEmpty) {
        final memberTotal = memberScores.fold<int>(0, (int sum, score) {
          return sum + (withHandicap ? score.totalWithHandicap : score.totalScore);
        });
        totalAverage += memberTotal / memberScores.length;
        memberCount++;
      }
    }

    return memberCount > 0 ? totalAverage / memberCount : 0.0;
  }
  
  // 팀 핸디캡 계산
  int _calculateTeamHandicap(Team team) {
    if (team.memberIds.isEmpty) return 0;
    
    int totalHandicap = 0;
    int memberCount = 0;
    
    for (final memberId in team.memberIds) {
      final memberScores = _scores.where((s) => s.memberId == memberId).toList();
      if (memberScores.isNotEmpty) {
        final memberHandicap = memberScores.fold<int>(0, (sum, score) => sum + (score.handicap ?? 0)) ~/ memberScores.length;
        totalHandicap += memberHandicap;
        memberCount++;
      }
    }
    
    return memberCount > 0 ? (totalHandicap ~/ memberCount) : 0;
  }

  // 팀 생성 방법
  void _generateTeams() {
    if (_participants.isEmpty) {
      ScaffoldMessenger.of(context).showSnackBar(
        const SnackBar(content: Text('참가자가 없습니다.')),
      );
      return;
    }

    // 기존 팀 삭제
    setState(() {
      _teams.clear();
    });

    // 참가자 셔플
    final shuffledParticipants = List<Participant>.from(_participants);
    shuffledParticipants.shuffle();

    int teamCount;
    int teamSize;

    // 팀 생성 방법에 따른 팀 개수 계산
    if (_teamGenerationMethod == 1) {
      // 팀 인원수로 나누기
      teamSize = int.tryParse(_teamSizeController.text) ?? 4;
      if (teamSize <= 0) teamSize = 4;
      teamCount = (_participants.length / teamSize).ceil();
    } else {
      // 팀 개수로 나누기
      teamCount = int.tryParse(_teamCountController.text) ?? 2;
      if (teamCount <= 0) teamCount = 2;
      teamSize = (_participants.length / teamCount).ceil();
    }
    
    // 팀 생성
    final List<Team> newTeams = [];
    for (int i = 0; i < teamCount; i++) {
      final teamName = String.fromCharCode(65 + i); // A, B, C, ...
      final team = Team(
        id: 'temp_${DateTime.now().millisecondsSinceEpoch}_$i',
        eventId: widget.event.id,
        name: teamName,
        memberIds: [],
      );
      newTeams.add(team);
    }
    
    // 참가자 배정
    for (int i = 0; i < shuffledParticipants.length; i++) {
      final teamIndex = i % teamCount;
      final participant = shuffledParticipants[i];
      if (participant.memberId != null) {
        newTeams[teamIndex].memberIds.add(participant.memberId);
      }
    }
    
    setState(() {
      _teams = newTeams;
    });
    
    ScaffoldMessenger.of(context).showSnackBar(
      SnackBar(content: Text('팀이 생성되었습니다. ($teamCount개 팀)')),
    );
  }
  
  // 팀 저장
  void _saveTeams() async {
    if (_teams.isEmpty) {
      ScaffoldMessenger.of(context).showSnackBar(
        const SnackBar(content: Text('저장할 팀이 없습니다.')),
      );
      return;
    }
    
    setState(() {
      _tabLoadingStates[3] = true;
    });
    
    try {
      // 기존 팀 삭제 및 새 팀 저장 로직 구현
      // TODO: API 연동 구현
      
      ScaffoldMessenger.of(context).showSnackBar(
        const SnackBar(content: Text('팀이 저장되었습니다.')),
      );
    } catch (e) {
      ScaffoldMessenger.of(context).showSnackBar(
        SnackBar(content: Text('팀 저장 중 오류가 발생했습니다: $e')),
      );
    } finally {
      setState(() {
        _tabLoadingStates[3] = false;
      });
    }
  }
  
  // 팀에서 참가자 제거
  void _removeFromTeam(Team team, Participant participant) {
    setState(() {
      team.memberIds.remove(participant.memberId);
    });
    
    ScaffoldMessenger.of(context).showSnackBar(
      SnackBar(content: Text('${participant.name}님이 팀에서 제외되었습니다.')),
    );
  }
  
  // 참가자 선택 다이얼로그 표시
  void _showParticipantSelectionDialog(Team team) {
    final unassignedParticipants = _getUnassignedParticipants();
    if (unassignedParticipants.isEmpty) {
      ScaffoldMessenger.of(context).showSnackBar(
        const SnackBar(content: Text('추가할 참가자가 없습니다.')),
      );
      return;
    }
    
    showDialog(
      context: context,
      builder: (context) => AlertDialog(
        title: Text('팀 ${team.name}에 참가자 추가'),
        content: SizedBox(
          width: double.maxFinite,
          child: ListView.builder(
            shrinkWrap: true,
            itemCount: unassignedParticipants.length,
            itemBuilder: (context, index) {
              final participant = unassignedParticipants[index];
              return ListTile(
                leading: const CircleAvatar(
                  child: Icon(Icons.person, size: 16),
                ),
                title: Text(participant.name ?? '알 수 없음'),
                onTap: () {
                  Navigator.of(context).pop();
                  if (participant.memberId != null) {
                    setState(() {
                      team.memberIds.add(participant.memberId);
                    });
                    ScaffoldMessenger.of(context).showSnackBar(
                      SnackBar(content: Text('${participant.name}님이 팀 ${team.name}에 추가되었습니다.')),
                    );
                  }
                },
              );
            },
          ),
        ),
        actions: [
          TextButton(
            onPressed: () => Navigator.of(context).pop(),
            child: const Text('취소'),
          ),
        ],
      ),
    );
  }
  
  // 참가자를 추가할 팀 선택 다이얼로그 표시
  void _showTeamSelectionDialog(Participant participant) {
    if (_teams.isEmpty) {
      ScaffoldMessenger.of(context).showSnackBar(
        const SnackBar(content: Text('추가할 팀이 없습니다.')),
      );
      return;
    }
    
    showDialog(
      context: context,
      builder: (context) => AlertDialog(
        title: Text('${participant.name}님을 추가할 팀 선택'),
        content: SizedBox(
          width: double.maxFinite,
          child: ListView.builder(
            shrinkWrap: true,
            itemCount: _teams.length,
            itemBuilder: (context, index) {
              final team = _teams[index];
              return ListTile(
                leading: CircleAvatar(
                  backgroundColor: Colors.blue.shade700,
                  child: Text('${index + 1}', style: const TextStyle(color: Colors.white)),
                ),
                title: Text('팀 ${team.name} (${team.memberIds.length}명)'),
                onTap: () {
                  Navigator.of(context).pop();
                  if (participant.memberId != null) {
                    setState(() {
                      team.memberIds.add(participant.memberId);
                    });
                    ScaffoldMessenger.of(context).showSnackBar(
                      SnackBar(content: Text('${participant.name}님이 팀 ${team.name}에 추가되었습니다.')),
                    );
                  }
                },
              );
            },
          ),
        ),
        actions: [
          TextButton(
            onPressed: () => Navigator.of(context).pop(),
            child: const Text('취소'),
          ),
        ],
      ),
    );
  }

  // 이벤트 수정
  void _editEvent() {
    // 이벤트 수정 다이얼로그 또는 화면으로 이동
    Navigator.of(context).pop(true); // 수정을 위해 이전 화면으로 돌아가기
  }

  // 참가자 추가
  void _addParticipant() {
    // 참가자 추가 다이얼로그 표시
    showDialog(
      context: context,
      builder: (context) => AlertDialog(
        title: const Text('참가자 추가'),
        content: const Text('참가자 추가 기능은 아직 구현 중입니다.'),
        actions: [
          TextButton(
            onPressed: () => Navigator.of(context).pop(),
            child: const Text('확인'),
          ),
        ],
      ),
    );
  }

  // 참가자 수정
  void _editParticipant(Participant participant) {
    // 참가자 수정 다이얼로그 표시
    showDialog(
      context: context,
      builder: (context) => AlertDialog(
        title: const Text('참가자 수정'),
        content: Text('${participant.name} 참가자 수정 기능은 아직 구현 중입니다.'),
        actions: [
          TextButton(
            onPressed: () => Navigator.of(context).pop(),
            child: const Text('확인'),
          ),
        ],
      ),
    );
  }

  // 참가자 삭제
  void _removeParticipant(Participant participant) {
    // 참가자 삭제 확인 다이얼로그
    showDialog(
      context: context,
      builder: (context) => AlertDialog(
        title: const Text('참가자 삭제'),
        content: Text('${participant.name} 참가자를 정말 삭제하시겠습니까?'),
        actions: [
          TextButton(
            onPressed: () => Navigator.of(context).pop(),
            child: const Text('취소'),
          ),
          TextButton(
            onPressed: () async {
              Navigator.of(context).pop();
              
              setState(() {
                _tabLoadingStates[1] = true;
              });
              
              try {
                final eventService = Provider.of<EventService>(context, listen: false);
                await eventService.removeParticipant(widget.event.id, participant.id);
                
                if (mounted) {
                  setState(() {
                    _participants.removeWhere((p) => p.id == participant.id);
                    _tabLoadingStates[1] = false;
                  });
                  
                  ScaffoldMessenger.of(context).showSnackBar(
                    const SnackBar(content: Text('참가자가 삭제되었습니다')),
                  );
                }
              } catch (e) {
                if (mounted) {
                  setState(() {
                    _tabLoadingStates[1] = false;
                  });
                  
                  ScaffoldMessenger.of(context).showSnackBar(
                    SnackBar(content: Text('참가자 삭제에 실패했습니다: $e')),
                  );
                }
              }
            },
            style: TextButton.styleFrom(foregroundColor: Colors.red),
            child: const Text('삭제'),
          ),
        ],
      ),
    );
  }

  // 참가자 상세 정보 표시
  void _showParticipantDetails(Participant participant) {
    // 참가자 상세 정보 다이얼로그
    showDialog(
      context: context,
      builder: (context) => AlertDialog(
        title: Text(participant.name ?? '이름 없음'),
        content: Column(
          mainAxisSize: MainAxisSize.min,
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            if (participant.email != null)
              _buildInfoRow(Icons.email, participant.email!),
            if (participant.phoneNumber != null)
              _buildInfoRow(Icons.phone, participant.phoneNumber!),
            
            // 회원 유형 표시
            if (participant.memberType != null && participant.memberType!.isNotEmpty)
              Padding(
                padding: const EdgeInsets.symmetric(vertical: 8.0),
                child: Row(
                  children: [
                    const Icon(Icons.person, size: 20, color: Colors.grey),
                    const SizedBox(width: 8),
                    const Text('회원 유형: ', style: TextStyle(fontWeight: FontWeight.bold)),
                    _buildBadge(
                      text: participant.memberType!,
                      color: _getMemberTypeColor(participant.memberType!),
                      icon: Icons.person,
                    ),
                  ],
                ),
              ),
            
            // 참가 상태 표시
            Padding(
              padding: const EdgeInsets.symmetric(vertical: 8.0),
              child: Row(
                children: [
                  const Icon(Icons.info, size: 20, color: Colors.grey),
                  const SizedBox(width: 8),
                  const Text('참가 상태: ', style: TextStyle(fontWeight: FontWeight.bold)),
                  if (participant.status != null)
                    _buildBadge(
                      text: participant.status!,
                      color: _getParticipantStatusColor(participant.status!),
                      icon: _getParticipantStatusIcon(participant.status!),
                    )
                  else
                    const Text('없음'),
                ],
              ),
            ),
            
            // 결제 상태 표시
            Padding(
              padding: const EdgeInsets.symmetric(vertical: 8.0),
              child: Row(
                children: [
                  const Icon(Icons.payment, size: 20, color: Colors.grey),
                  const SizedBox(width: 8),
                  const Text('결제 상태: ', style: TextStyle(fontWeight: FontWeight.bold)),
                  _buildBadge(
                    text: participant.isPaid ? '결제완료' : '미결제',
                    color: participant.isPaid ? Colors.green : Colors.red,
                    icon: participant.isPaid ? Icons.check_circle : Icons.cancel,
                  ),
                  if (participant.paidAmount != null)
                    Padding(
                      padding: const EdgeInsets.only(left: 8.0),
                      child: Text('(${participant.paidAmount}원)'),
                    ),
                ],
              ),
            ),
            if (participant.notes != null) ...[
              const Divider(),
              const Text('메모:', style: TextStyle(fontWeight: FontWeight.bold)),
              Text(participant.notes!),
            ],
          ],
        ),
        actions: [
          TextButton(
            onPressed: () => Navigator.of(context).pop(),
            child: const Text('닫기'),
          ),
        ],
      ),
    );
  }

  // 점수 추가
  void _addScore() {
    // 점수 추가 다이얼로그 표시
    showDialog(
      context: context,
      builder: (context) => AlertDialog(
        title: const Text('점수 추가'),
        content: const Text('점수 추가 기능은 아직 구현 중입니다.'),
        actions: [
          TextButton(
            onPressed: () => Navigator.of(context).pop(),
            child: const Text('확인'),
          ),
        ],
      ),
    );
  }

  // 점수 수정
  void _editScore(Score score) {
    // 점수 수정 다이얼로그 표시
    showDialog(
      context: context,
      builder: (context) => AlertDialog(
        title: const Text('점수 수정'),
        content: Text('점수 ID: ${score.id} 수정 기능은 아직 구현 중입니다.'),
        actions: [
          TextButton(
            onPressed: () => Navigator.of(context).pop(),
            child: const Text('확인'),
          ),
        ],
      ),
    );
  }

  // 점수 삭제
  void _deleteScore(Score score) {
    // 점수 삭제 확인 다이얼로그
    showDialog(
      context: context,
      builder: (context) => AlertDialog(
        title: const Text('점수 삭제'),
        content: const Text('이 점수를 정말 삭제하시겠습니까?'),
        actions: [
          TextButton(
            onPressed: () => Navigator.of(context).pop(),
            child: const Text('취소'),
          ),
          TextButton(
            onPressed: () async {
              Navigator.of(context).pop();
              
              setState(() {
                _tabLoadingStates[2] = true;
              });
              
              try {
                final eventService = Provider.of<EventService>(context, listen: false);
                await eventService.deleteScore(widget.event.id, score.id);
                
                if (mounted) {
                  setState(() {
                    _scores.removeWhere((s) => s.id == score.id);
                    _tabLoadingStates[2] = false;
                  });
                  
                  ScaffoldMessenger.of(context).showSnackBar(
                    const SnackBar(content: Text('점수가 삭제되었습니다')),
                  );
                }
              } catch (e) {
                if (mounted) {
                  setState(() {
                    _tabLoadingStates[2] = false;
                  });
                  
                  ScaffoldMessenger.of(context).showSnackBar(
                    SnackBar(content: Text('점수 삭제에 실패했습니다: $e')),
                  );
                }
              }
            },
            style: TextButton.styleFrom(foregroundColor: Colors.red),
            child: const Text('삭제'),
          ),
        ],
      ),
    );
  }

  // 점수 상세 정보 표시
  void _showScoreDetails(Score score) {
    // 참가자 이름 찾기
    final participant = _participants.firstWhere(
      (p) => p.memberId == score.memberId,
      orElse: () => Participant(
        id: '',
        eventId: '',
        memberId: score.memberId,
        name: '알 수 없음',
      ),
    );
    
    // 점수 상세 정보 다이얼로그
    showDialog(
      context: context,
      builder: (context) => AlertDialog(
        title: Text('${participant.name} 점수'),
        content: Column(
          mainAxisSize: MainAxisSize.min,
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            _buildInfoRow(Icons.score, '총점: ${score.totalScore}'),
            _buildInfoRow(
              Icons.calendar_today,
              '날짜: ${DateFormat('yyyy-MM-dd').format(score.date)}',
            ),
            const Divider(),
            const Text('프레임별 점수:', style: TextStyle(fontWeight: FontWeight.bold)),
            const SizedBox(height: 8),
            Wrap(
              spacing: 8,
              runSpacing: 8,
              children: score.frames.asMap().entries.map((entry) {
                final frameIndex = entry.key;
                final frameValue = entry.value;
                
                // 스트라이크와 스페어 표시 로직
                String displayText = frameValue.toString();
                Color backgroundColor = Colors.white;
                Color textColor = Colors.black;
                
                // 스트라이크인 경우 (10점)
                if (frameValue == 10) {
                  displayText = 'X';
                  backgroundColor = Colors.red.shade100;
                  textColor = Colors.red;
                }
                // 스페어인 경우 (첫 투구와 두 번째 투구의 합이 10점)
                // 스페어 판별은 이전 프레임과 현재 프레임을 비교해서 추정
                else if (frameIndex > 0 && 
                         score.frames[frameIndex-1] < 10 && 
                         score.frames[frameIndex-1] + frameValue == 10) {
                  displayText = '/';
                  backgroundColor = Colors.blue.shade100;
                  textColor = Colors.blue;
                }
                
                return Container(
                  width: 40,
                  height: 40,
                  decoration: BoxDecoration(
                    border: Border.all(color: Colors.blue),
                    borderRadius: BorderRadius.circular(4),
                    color: backgroundColor,
                  ),
                  child: Center(
                    child: Text(
                      displayText,
                      style: TextStyle(
                        fontSize: 16,
                        fontWeight: FontWeight.bold,
                        color: textColor,
                      ),
                    ),
                  ),
                );
              }).toList(),
            ),
            if (score.notes != null) ...[  
              const Divider(),
              const Text('메모:', style: TextStyle(fontWeight: FontWeight.bold)),
              Text(score.notes ?? ''),
            ],
          ],
        ),
        actions: [
          TextButton(
            onPressed: () => Navigator.of(context).pop(),
            child: const Text('닫기'),
          ),
        ],
      ),
    );
  }

  // 공유 성공 스낵바 표시
}