kaptan/ground-suite/lib/features/diagnostics/presentation/diagnostics_page.dart

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';

import '../../../core/observations/observed_event.dart';
import '../../../shared/widgets/severity_badge.dart';
import '../../../shared/widgets/glass_panel.dart';
import '../../observability/presentation/observability_controller.dart';

enum _DiagnosticFilter { all, logs, errors, shutdowns }

class DiagnosticsPage extends ConsumerStatefulWidget {
  const DiagnosticsPage({super.key});

  @override
  ConsumerState<DiagnosticsPage> createState() => _DiagnosticsPageState();
}

class _DiagnosticsPageState extends ConsumerState<DiagnosticsPage> {
  _DiagnosticFilter _filter = _DiagnosticFilter.all;
  String _query = '';

  @override
  Widget build(BuildContext context) {
    final state = ref.watch(observabilityControllerProvider);
    final events = state.events.where(_matches).toList(growable: false);

    return CustomScrollView(
      slivers: [
        SliverPadding(
          padding: const EdgeInsets.fromLTRB(24, 24, 24, 16),
          sliver: SliverToBoxAdapter(
            child: Column(
              crossAxisAlignment: CrossAxisAlignment.start,
              children: [
                Text(
                  'Diagnostics',
                  style: Theme.of(context).textTheme.headlineMedium,
                ),
                const SizedBox(height: 8),
                const Text(
                  'Messages remain distinct by protocol class. A configuration '
                  'result will remain authoritative when configuration support '
                  'is added.',
                ),
                const SizedBox(height: 16),
                Wrap(
                  spacing: 8,
                  runSpacing: 8,
                  children: _DiagnosticFilter.values
                      .map(
                        (filter) => ChoiceChip(
                          label: Text(_labelFor(filter)),
                          selected: _filter == filter,
                          onSelected: (_) => setState(() => _filter = filter),
                        ),
                      )
                      .toList(growable: false),
                ),
                const SizedBox(height: 12),
                TextField(
                  decoration: const InputDecoration(
                    border: OutlineInputBorder(),
                    labelText: 'Filter diagnostics',
                    prefixIcon: Icon(Icons.search),
                  ),
                  onChanged: (value) {
                    setState(() => _query = value.trim().toLowerCase());
                  },
                ),
              ],
            ),
          ),
        ),
        if (events.isEmpty)
          const SliverPadding(
            padding: EdgeInsets.fromLTRB(24, 0, 24, 24),
            sliver: SliverToBoxAdapter(
              child: GlassPanel(
                child: Padding(
                  padding: EdgeInsets.all(20),
                  child: Text('No diagnostic observations match this filter.'),
                ),
              ),
            ),
          )
        else
          SliverPadding(
            padding: const EdgeInsets.fromLTRB(24, 0, 24, 24),
            sliver: SliverList.builder(
              itemCount: events.length,
              itemBuilder: (context, index) =>
                  _DiagnosticCard(event: events[index]),
            ),
          ),
      ],
    );
  }

  bool _matches(ObservedEvent event) {
    final typeMatches = switch (_filter) {
      _DiagnosticFilter.all =>
        event is LogEvent || event is ErrorEvent || event is ShutdownEvent,
      _DiagnosticFilter.logs => event is LogEvent,
      _DiagnosticFilter.errors => event is ErrorEvent,
      _DiagnosticFilter.shutdowns => event is ShutdownEvent,
    };
    if (!typeMatches) {
      return false;
    }
    if (_query.isEmpty) {
      return true;
    }
    return _searchableText(event).toLowerCase().contains(_query);
  }
}

class _DiagnosticCard extends StatelessWidget {
  const _DiagnosticCard({required this.event});

  final ObservedEvent event;

  @override
  Widget build(BuildContext context) {
    final theme = Theme.of(context);
    final content = switch (event) {
      LogEvent(:final level, :final message, :final flags) => _LogContent(
        level: level,
        message: message,
        flags: flags,
      ),
      ErrorEvent(:final path, :final additionalInformation, :final flags) =>
        _ErrorContent(
          path: path,
          additionalInformation: additionalInformation,
          flags: flags,
        ),
      ShutdownEvent(:final reason) => _ShutdownContent(reason: reason),
      _ => null,
    };
    if (content == null) {
      return const SizedBox.shrink();
    }

    return Semantics(
      container: true,
      label: content.semanticLabel,
      child: Padding(
        padding: const EdgeInsets.only(bottom: 12),
        child: GlassListItem(
          child: Padding(
            padding: const EdgeInsets.all(16),
            child: Row(
              crossAxisAlignment: CrossAxisAlignment.start,
              children: [
                content.leading,
                const SizedBox(width: 12),
                Expanded(
                  child: SelectionArea(
                    child: Column(
                      crossAxisAlignment: CrossAxisAlignment.start,
                      children: [
                        Text(content.title, style: theme.textTheme.titleMedium),
                        const SizedBox(height: 4),
                        Text(content.detail),
                        if (content.additionalDetail case final detail?) ...[
                          const SizedBox(height: 8),
                          Text(detail),
                        ],
                        const SizedBox(height: 8),
                        Text(
                          event.receivedAt.toIso8601String(),
                          style: theme.textTheme.bodySmall,
                        ),
                      ],
                    ),
                  ),
                ),
              ],
            ),
          ),
        ),
      ),
    );
  }
}

class _DiagnosticContent {
  const _DiagnosticContent({
    required this.leading,
    required this.title,
    required this.detail,
    required this.semanticLabel,
    this.additionalDetail,
  });

  final Widget leading;
  final String title;
  final String detail;
  final String? additionalDetail;
  final String semanticLabel;
}

class _LogContent extends _DiagnosticContent {
  _LogContent({
    required MavSeverity level,
    required String message,
    required int flags,
  }) : super(
         leading: SeverityBadge(level: level),
         title: 'Log — ${level.label}',
         detail: message,
         additionalDetail: _formatLogFlags(flags),
         semanticLabel: _semanticLogLabel(level, message, flags),
       );
}

class _ErrorContent extends _DiagnosticContent {
  _ErrorContent({
    required String path,
    required String additionalInformation,
    required int flags,
  }) : super(
         leading: const SeverityBadge(level: MavSeverity.error),
         title: 'Error',
         detail: path,
         additionalDetail: _formatErrorDetail(additionalInformation, flags),
         semanticLabel: _semanticErrorLabel(path, additionalInformation, flags),
       );
}

class _ShutdownContent extends _DiagnosticContent {
  _ShutdownContent({required KaptanShutdownReason reason})
    : super(
        leading: const Icon(Icons.power_settings_new_outlined),
        title: 'Orderly shutdown observed',
        detail: 'Reason: ${reason.label}',
        semanticLabel: 'Orderly shutdown observed: ${reason.label}',
      );
}

String _labelFor(_DiagnosticFilter filter) => switch (filter) {
  _DiagnosticFilter.all => 'All',
  _DiagnosticFilter.logs => 'Logs',
  _DiagnosticFilter.errors => 'Errors',
  _DiagnosticFilter.shutdowns => 'Shutdowns',
};

String _searchableText(ObservedEvent event) => switch (event) {
  LogEvent(:final level, :final message) => '${level.label} $message',
  ErrorEvent(:final path, :final additionalInformation) =>
    '$path $additionalInformation',
  ShutdownEvent(:final reason) => reason.label,
  _ => '',
};

String? _formatLogFlags(int flags) {
  final labels = <String>[
    if (flags & LogEvent.traceFlag != 0) 'Trace',
    if (flags & LogEvent.truncatedFlag != 0) 'Truncated',
    if (flags & LogEvent.coalescedFlag != 0) 'Coalesced',
    if (flags & ~LogEvent.knownFlags != 0)
      'Unknown bits 0x${(flags & ~LogEvent.knownFlags).toRadixString(16)}',
  ];
  return labels.isEmpty ? null : 'Flags: ${labels.join(', ')}';
}

String? _formatErrorDetail(String additionalInformation, int flags) {
  final flagDetail = _formatErrorFlags(flags);
  final details = <String>[
    if (additionalInformation.isNotEmpty) additionalInformation,
    ?flagDetail,
  ];
  return details.isEmpty ? null : details.join('\n');
}

String? _formatErrorFlags(int flags) {
  final labels = <String>[
    if (flags & ErrorEvent.truncatedFlag != 0) 'Truncated',
    if (flags & ErrorEvent.coalescedFlag != 0) 'Coalesced',
    if (flags & ~ErrorEvent.knownFlags != 0)
      'Unknown bits 0x${(flags & ~ErrorEvent.knownFlags).toRadixString(16)}',
  ];
  return labels.isEmpty ? null : 'Flags: ${labels.join(', ')}';
}

String _semanticLogLabel(MavSeverity level, String message, int flags) {
  final flagDetail = _formatLogFlags(flags);
  return flagDetail == null
      ? '${level.label} log: $message'
      : '${level.label} log: $message. $flagDetail';
}

String _semanticErrorLabel(
  String path,
  String additionalInformation,
  int flags,
) {
  final detail = _formatErrorDetail(additionalInformation, flags);
  return detail == null ? 'Error: $path' : 'Error: $path. $detail';
}