import 'package:flutter/material.dart';

void main() {
  runApp(const MyApp());
}

final class OneIntent extends Intent {
  const OneIntent();
}

final class TwoIntent extends Intent {
  const TwoIntent();
}

final class ThreeIntent extends Intent {
  const ThreeIntent();
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        useMaterial3: true,
      ),
      home: const MyHomePage(),
    );
  }
}

final contentFocus = FocusNode(debugLabel: 'content');

final class MenuItemInfo {
  final String title;
  final Intent intent;

  const MenuItemInfo(this.title, this.intent);
}

const menuItems = [
  MenuItemInfo('Intent 1', OneIntent()),
  MenuItemInfo('Intent 2', TwoIntent()),
  MenuItemInfo('Intent 3', ThreeIntent()),
];

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

  @override
  State<MyHomePage> createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  final _MenuOpenedNotifier _menuOpenedNotifier = _MenuOpenedNotifier();
  FocusNode? _actionTarget;
  final List<FocusNode> _actionButtonFocus = [FocusNode(), FocusNode(), FocusNode()];

  void _onOpenMenu() {
    final primaryFocus = FocusManager.instance.primaryFocus;
    if (primaryFocus != null) {
      var parent = primaryFocus.parent;
      while (parent != null) {
        if (parent == contentFocus) {
          _actionTarget = primaryFocus;
          break;
        }
        parent = parent.parent;
      }
    }

    _menuOpenedNotifier.onOpen(_actionTarget);
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        backgroundColor: Theme.of(context).colorScheme.inversePrimary,
        title: MenuBar(children: [
          SubmenuButton(
            menuChildren: menuItems.map(
              (m) {
                return _IntentDriver(
                    intent: m.intent,
                    builder: (context, {required active, required actionTarget}) {
                      return MenuItemButton(
                          onPressed: active
                              ? () {
                                  if (actionTarget?.context != null) {
                                    Actions.invoke(actionTarget!.context!, m.intent);
                                  }
                                }
                              : null,
                          child: Text(m.title));
                    },
                    changeNotifier: _menuOpenedNotifier);
              },
            ).toList(growable: false),
            onOpen: _onOpenMenu,
            child: const Text('Menu 1'),
          ),
          SubmenuButton(
            menuChildren: const [MenuItemButton(child: Text('just a placeholder'))],
            onOpen: _onOpenMenu,
            child: const Text('Menu 2'),
          ),
        ]),
      ),
      body: Focus(
        focusNode: contentFocus,
        canRequestFocus: false,
        child: Center(
          child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: <Widget>[
              ActionButton(
                title: 'Item 1',
                intent: OneIntent,
                autofocus: true,
                focusNode: _actionButtonFocus[0],
              ),
              ActionButton(
                title: 'Item 2',
                intent: TwoIntent,
                focusNode: _actionButtonFocus[1],
              ),
              ActionButton(
                title: 'Item 3',
                intent: ThreeIntent,
                focusNode: _actionButtonFocus[2],
              ),
            ],
          ),
        ),
      ),
    );
  }
}

class ActionButton extends StatelessWidget {
  const ActionButton({
    super.key,
    this.autofocus = false,
    required this.title,
    required this.intent,
    this.focusNode,
  });

  final String title;
  final bool autofocus;
  final Type intent;
  final FocusNode? focusNode;

  @override
  Widget build(BuildContext context) {
    return Actions(
      actions: {
        intent: CallbackAction(onInvoke: (intent) {
          print('Action fired!');
          return null;
        })
      },
      child: InkWell(
        focusNode: focusNode,
        onTap: () {
          focusNode?.requestFocus();
        },
        autofocus: autofocus,
        focusColor: Colors.red,
        child: Padding(
          padding: const EdgeInsets.all(8.0),
          child: Text(title),
        ),
      ),
    );
  }
}

class _MenuOpenedNotifier extends ChangeNotifier {
  FocusNode? actionTarget;

  void onOpen(FocusNode? primaryFocus) {
    actionTarget = primaryFocus;
    notifyListeners();
  }
}

class _IntentDriver extends StatefulWidget {
  const _IntentDriver({required this.intent, required this.builder, required this.changeNotifier});

  final _MenuOpenedNotifier changeNotifier;
  final Intent intent;
  final Widget Function(BuildContext context, {required bool active, required FocusNode? actionTarget}) builder;

  @override
  State<_IntentDriver> createState() => _IntentDriverState();
}

class _IntentDriverState extends State<_IntentDriver> {
  bool _active = false;
  FocusNode? _actionTarget;

  @override
  void initState() {
    super.initState();
    widget.changeNotifier.addListener(_refresh);
    _refresh();
  }

  @override
  void didUpdateWidget(_IntentDriver oldWidget) {
    super.didUpdateWidget(oldWidget);
    oldWidget.changeNotifier.removeListener(_refresh);
    widget.changeNotifier.addListener(_refresh);
  }

  @override
  void dispose() {
    widget.changeNotifier.removeListener(_refresh);
    super.dispose();
  }

  void _refresh() {
    final focus = widget.changeNotifier.actionTarget;
    final context = focus?.context;
    if (context != null) {
      final active = Actions.maybeFind(context, intent: widget.intent) != null;
      if (active != _active || _actionsTarget != focus) {
        setState(() {
          _active = active;
          _actionTarget = focus;
        });
      }
    }
  }

  @override
  Widget build(BuildContext context) {
    return widget.builder(context, active: _active, actionTarget: _actionTarget);
  }
}