import 'dart:async';

import 'package:desktop_multi_window/desktop_multi_window.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:window_manager/window_manager.dart';

const manualChildArgument = 'child-manual-close';
const automaticCloseChildArgument = 'child-auto-close';
const automaticDestroyChildArgument = 'child-auto-destroy';

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();
  final controller = await WindowController.fromCurrentEngine();

  final argument = controller.arguments;
  if (argument == manualChildArgument ||
      argument == automaticCloseChildArgument ||
      argument == automaticDestroyChildArgument) {
    await windowManager.ensureInitialized();
    final currentWindow = await WindowController.fromCurrentEngine();
    await currentWindow.setWindowMethodHandler((call) async {
      switch (call.method) {
        case 'window_close':
          await windowManager.close();
          return null;
        case 'window_destroy':
          await windowManager.destroy();
          return null;
        default:
          throw MissingPluginException('Not implemented: ${call.method}');
      }
    });
    runApp(ChildApp(mode: argument));
    return;
  }

  runApp(const HostApp());
}

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

  Future<void> _openChild(String argument) async {
    await Future<void>.delayed(const Duration(milliseconds: 500));
    final controller = await WindowController.create(
      WindowConfiguration(arguments: argument, hiddenAtLaunch: false),
    );
    await controller.show();
    if (argument == automaticCloseChildArgument) {
      await Future<void>.delayed(const Duration(seconds: 3));
      await controller.invokeMethod('window_close');
    } else if (argument == automaticDestroyChildArgument) {
      await Future<void>.delayed(const Duration(seconds: 3));
      await controller.invokeMethod('window_destroy');
    }
  }

  @override
  Widget build(BuildContext context) => MaterialApp(
        home: Scaffold(
          body: Center(
            child: Wrap(
              spacing: 12,
              children: [
                ElevatedButton(
                  onPressed: () => unawaited(_openChild(automaticCloseChildArgument)),
                  child: const Text('Automatic close'),
                ),
                ElevatedButton(
                  onPressed: () => unawaited(_openChild(automaticDestroyChildArgument)),
                  child: const Text('Automatic destroy'),
                ),
                ElevatedButton(
                  onPressed: () => unawaited(_openChild(manualChildArgument)),
                  child: const Text('Manual X close'),
                ),
              ],
            ),
          ),
        ),
      );
}

class ChildApp extends StatelessWidget {
  const ChildApp({required this.mode, super.key});

  final String mode;

  @override
  Widget build(BuildContext context) => MaterialApp(
        home: ChildSession(mode: widget.mode),
      );
}

class ChildSession extends StatefulWidget {
  const ChildSession({required this.mode, super.key});

  final String mode;

  @override
  State<ChildSession> createState() => _ChildSessionState();
}

class _ChildSessionState extends State<ChildSession> {
  Timer? timer;
  int frame = 0;

  @override
  void initState() {
    super.initState();
    timer = Timer.periodic(const Duration(milliseconds: 16), (_) {
      if (mounted) setState(() => frame++);
    });
  }

  @override
  void dispose() {
    timer?.cancel();
    debugPrint('Child session disposed');
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: Center(
        child: ColoredBox(
          color: Colors.primaries[frame % Colors.primaries.length],
          child: SizedBox(
            width: 240,
            height: 120,
            child: Center(
              child: Text(switch (mode) {
                automaticCloseChildArgument => 'Automatic close test',
                automaticDestroyChildArgument => 'Automatic destroy test',
                _ => 'Manual X close test',
              }),
            ),
          ),
        ),
      ),
    );
  }
}