import 'package:flutter/widgets.dart';

void main() async {
  runApp(const BugReport());  
}

class BugReport extends StatefulWidget {
  const BugReport({super.key});

  @override
  State<BugReport> createState() => _BugReportState();
}

class _BugReportState extends State<BugReport> {
  late final FocusNode leftFocusNode;
  late final FocusNode rightFocusNode;

  void _onFocusChanged() {
    debugPrint('Focus changed to ${FocusManager.instance.primaryFocus?.debugLabel}');
  }

  void focusRightEntry() {
    setState(() {
      /// The [Focus] widget tied to [rightFocusNode] is marked as [skipTraversal],
      /// so this call shouldn't directly focus [rightFocusNode], but rather focus
      /// its first descendant node.
      ///
      /// Thus, in the logs, due to the [_onFocusChanged] handler, we should see
      /// a message that "Focus changed to innerFocusNode::right". This was the
      /// case before #130812, but after that change, we see a message that
      /// "Focus changed to rightFocusNode", which shouldn't happen since this
      /// triggers an explicit call to [FocusTraversalPolicy.next]
      rightFocusNode.nextFocus();
    });
  }

  @override
  void initState() {
    super.initState();
    leftFocusNode = FocusNode(debugLabel: 'leftFocusNode');
    rightFocusNode = FocusNode(debugLabel: 'rightFocusNode');
    FocusManager.instance.addListener(_onFocusChanged);
  }

  @override
  void dispose() {
    FocusManager.instance.removeListener(_onFocusChanged);
    leftFocusNode.dispose();
    rightFocusNode.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Localizations(
      delegates: const [DefaultWidgetsLocalizations.delegate],
      locale: const Locale('en'),
      child: FocusTraversalGroup(
        child: Row(
          crossAxisAlignment: CrossAxisAlignment.stretch,
          children: [
            FocusScope(
              child: Focus(
                focusNode: leftFocusNode,
                skipTraversal: true,
                child: Padding(
                  padding: const EdgeInsets.all(50),
                  child: FocusableArea(
                    autofocus: true,
                    onTap: focusRightEntry,
                    debugLabel: 'left',
                    text: 'Click to transfer focus',
                  ),
                ),
              ),
            ),
            FocusScope(
              child: Focus(
                focusNode: rightFocusNode,
                skipTraversal: true,
                child: const Padding(
                  padding: EdgeInsets.all(50),
                  child: FocusableArea(
                    debugLabel: 'right',
                    text: 'Should gain focus when you click the other one',
                  ),
                ),
              ),
            ),
          ],
        ),
      ),
    );
  }
}

class FocusableArea extends StatefulWidget {
  const FocusableArea({
    super.key,
    this.autofocus = false,
    this.onTap,
    this.debugLabel,
    required this.text,
  });

  final bool autofocus;
  final VoidCallback? onTap;
  final String? debugLabel;
  final String text;

  @override
  State<FocusableArea> createState() => _FocusableAreaState();
}

class _FocusableAreaState extends State<FocusableArea> {
  late final FocusNode _focusNode;
  bool _hasFocus = false;

  void _handleFocusChanged(bool hasFocus) {
    setState(() {
      _hasFocus = hasFocus;
    });
  }

  @override
  void initState() {
    super.initState();
    _focusNode = FocusNode(debugLabel: 'innerFocusNode::${widget.debugLabel}');
  }

  @override
  void dispose() {
    _focusNode.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Focus(
      onFocusChange: _handleFocusChanged,
      autofocus: widget.autofocus,
      focusNode: _focusNode,
      child: GestureDetector(
        onTap: widget.onTap,
        child: Padding(
          padding: const EdgeInsets.fromLTRB(20, 10, 10, 10),
          child: Text('${widget.text}${_hasFocus ? " (FOCUSED)" : ""}'),
        ),
      ),
    );
  }
}

void main() {
  testWidgets('calling', (WidgetTester tester) async {
    final FocusNode outer1 = FocusNode(debugLabel: 'outer1', skipTraversal: true);
    final FocusNode outer2 = FocusNode(debugLabel: 'outer2', skipTraversal: true);
    final FocusNode inner1 = FocusNode(debugLabel: 'inner1', );
    final FocusNode inner2 = FocusNode(debugLabel: 'inner2', );

    addTearDown(() {
      outer1.dispose();
      outer2.dispose();
      inner1.dispose();
      inner2.dispose();
    });

    await tester.pumpWidget(
      Directionality(
        textDirection: TextDirection.ltr,
        child: FocusTraversalGroup(
          child: Row(
            children: <Widget>[
              FocusScope(
                child: Focus(
                  focusNode: outer1,
                  child: Focus(
                    focusNode: inner1,
                    child: const SizedBox(width: 10, height: 10),
                  ),
                ),
              ),
              FocusScope(
                child: Focus(
                  focusNode: outer2,
                  // This [Padding] widget is substantive to the test!
                  // In https://github.com/flutter/flutter/issues/134854,
                  // the regression wasn't seen (and this test passed) without
                  // the [Padding] widget in the tree.
                  child: Padding(
                    padding: const EdgeInsets.all(5),
                    child: Focus(
                      focusNode: inner2,
                      child: const SizedBox(width: 10, height: 10),
                    ),
                  ),
                ),
              ),
            ],
          ),
        ),
      ),
    );

    expect(FocusManager.instance.primaryFocus, isNull);
    inner1.requestFocus();
    await tester.pump();
    expect(FocusManager.instance.primaryFocus, inner1);
    outer2.nextFocus();
    await tester.pump();
    expect(FocusManager.instance.primaryFocus, inner2);
  });
}