import 'dart:async';
import 'package:flame/components.dart';
import 'package:flame/game.dart';
import 'package:flutter/material.dart';

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

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      debugShowCheckedModeBanner: false,
      home: Scaffold(
        appBar: AppBar(
          title: Text('Flame Rotation Bug Test'),
          backgroundColor: Colors.blue,
        ),
        body: SafeArea(
          child: OrientationBuilder(
            builder: (context, orientation) {
              return orientation == Orientation.portrait
                  ? _buildPortraitLayout()
                  : _buildLandscapeLayout();
            },
          ),
        ),
      ),
    );
  }

  RotationTestGameWithButton game = RotationTestGameWithButton();

  Widget _buildPortraitLayout() {
    return Column(
      children: [
        Expanded(
          flex: 1,
          child: GameWidget(game: game),
        ),
        Expanded(
          flex: 1,
          child: TestControlsContainer(game: game),
        ),
      ],
    );
  }

  Widget _buildLandscapeLayout() {
    return Row(
      children: [
        Expanded(
          flex: 1,
          child: GameWidget(game: game),
        ),
        Expanded(
          flex: 1,
          child: TestControlsContainer(game: game),
        ),
      ],
    );
  }
}

class TestControlsContainer extends StatelessWidget {
  final RotationTestGameWithButton game;

  TestControlsContainer({required this.game});

  @override
  Widget build(BuildContext context) {
    return Container(
      color: Colors.grey[200],
      child: Column(
        mainAxisAlignment: MainAxisAlignment.center,
        children: [
          Text(
            'Rotation Bug Test Controls',
            style: TextStyle(fontSize: 18, fontWeight: FontWeight.bold),
          ),
          SizedBox(height: 20),
          ElevatedButton(
            onPressed: () => game.toggleTestVisibility(),
            child: Text('Toggle Visibility'),
          ),
          SizedBox(height: 10),
          Text(
            'Rotate device to test!\nWatch debug console for render counts.',
            textAlign: TextAlign.center,
            style: TextStyle(fontSize: 14),
          ),
          SizedBox(height: 20),
          Container(
            padding: EdgeInsets.all(16),
            margin: EdgeInsets.all(16),
            decoration: BoxDecoration(
              color: Colors.blue[50],
              borderRadius: BorderRadius.circular(8),
              border: Border.all(color: Colors.blue),
            ),
            child: Text(
              'Expected Bug:\n'
                  '1. Before rotation: render() runs continuously\n'
                  '2. After rotation: render() stops or runs only once\n'
                  '3. Toggle button may not work properly',
              style: TextStyle(fontSize: 12),
            ),
          ),
        ],
      ),
    );
  }
}

class RotationTestGameWithButton extends FlameGame {
  TestRenderComponent? _testComponent;

  @override
  Color backgroundColor() => const Color(0xFF222222);

  @override
  FutureOr<void> onLoad() async {
    debugPrint('=== GAME ONLOAD ===');

    final camera = CameraComponent(world: world);
    camera.viewfinder.anchor = Anchor.topLeft;
    camera.viewport.anchor = Anchor.topLeft;
    await addAll([world, camera]);

    _testComponent = TestRenderComponent();
    world.add(_testComponent!);

    debugPrint('=== GAME ONLOAD COMPLETE ===');
  }

  @override
  void onGameResize(Vector2 size) {
    debugPrint('=== GAME RESIZE: $size ===');
    super.onGameResize(size);
    _testComponent?.onParentResize(size);
  }

  void toggleTestVisibility() {
    debugPrint('=== TOGGLE VISIBILITY CALLED ===');
    _testComponent?.toggleVisibility();
  }
}

class TestRenderComponent extends Component {
  int renderCount = 0;
  bool visible = true;

  @override
  void render(Canvas canvas) {
    renderCount++;
    debugPrint('TestRenderComponent.render() called #$renderCount, visible: $visible');

    if (!visible) return;

    final paint = Paint()..color = Colors.green;
    final size = Vector2(100, 100);

    canvas.drawRect(
        Rect.fromLTWH(50, 50, size.x, size.y),
        paint
    );

    final textStyle = TextStyle(
      color: Colors.white,
      fontSize: 20,
      fontWeight: FontWeight.bold,
    );

    final textPainter = TextPainter(
      text: TextSpan(text: 'Renders: $renderCount', style: textStyle),
      textAlign: TextAlign.center,
      textDirection: TextDirection.ltr,
    );

    textPainter.layout();
    textPainter.paint(canvas, Offset(60, 170));
  }

  @override
  void update(double dt) {
    super.update(dt);

    if (renderCount % 60 == 0 && renderCount > 0) {
      debugPrint('TestRenderComponent.update() - renderCount: $renderCount');
    }
  }

  void onParentResize(Vector2 newSize) {
    debugPrint('TestRenderComponent: Parent resized to $newSize');
  }

  void toggleVisibility() {
    visible = !visible;
    debugPrint('TestRenderComponent: visibility toggled to $visible');
  }
}