import 'dart:async';
import 'dart:typed_data';
import 'dart:ui';

import 'package:flutter/material.dart';
import 'package:flutter/rendering.dart';
import 'package:flutter/widgets.dart';

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

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

  @override
  State<Root> createState() => _RootState();
}

class _RootState extends State<Root> {
  Timer? _timer;
  double _scale = 1.0;
  
  @override
  void initState() {
    super.initState();
    _timer = Timer.periodic(const Duration(milliseconds: 16), _update);
  }

  void _update(Timer timer) {
    setState(() {
      _scale *= 1.5;
      if (_scale > 1e38) {
        _scale = 1e-15; // this should work all the way down to 1e-38 at least, but currently it crashes for really small scales
      }
    });
  }
  
  @override
  void dispose() {
    _timer?.cancel();
    super.dispose();
  }
  
  @override
  Widget build(BuildContext context) {
    return Stack(
      textDirection: TextDirection.ltr,
      children: [
        TestWidget(scale: _scale),
        Positioned(
          top: 60.0,
          left: 20.0,
          child: Text(_scale.toStringAsExponential(1), textDirection: TextDirection.ltr),
        ),
      ],
    );
  }
}

class TestWidget extends LeafRenderObjectWidget {
  const TestWidget({
    super.key,
    this.scale = 1.0,
  });

  final double scale;
  
  @override
  RenderTest createRenderObject(BuildContext context) {
    return RenderTest(scale: scale);
  }

  @override
  void updateRenderObject(BuildContext context, RenderTest renderObject) {
    renderObject.scale = scale;
  }
}

class RenderTest extends RenderBox {
  RenderTest({ double scale = 1.0 }) : _scale = scale;

  double get scale => _scale;
  double _scale;
  set scale(double value) {
    if (_scale != value) {
      _scale = value;
      markNeedsPaint();
    }
  }
  
  @override
  void performLayout() {
    size = constraints.biggest;
  }

  TransformLayer? _transformLayer;
  
  @override
  void paint(PaintingContext context, Offset offset) {
    final transform = Matrix4.identity()
      ..scale(100 / scale);
    _transformLayer = context.pushTransform(
      needsCompositing,
      offset,
      transform,
      _paintDots,
      oldLayer: _transformLayer,
    );
  }
  
  void _paintDots(PaintingContext context, Offset offset) {
    // context.canvas.scale(100 / scale); // scaling here instead, for values bigger than about 1e13, causes a crash, sometimes of the entire phone
    final coordinates = Float32List.fromList(<double>[
      1 * scale, 3 * scale,
      2 * scale, 4 * scale,
      3 * scale, 5 * scale,
    ]);
    final paint = Paint()
      ..color = const Color(0x7f00cc66)
      ..strokeWidth = scale;
    context.canvas.drawRawPoints(PointMode.points, coordinates, paint);

    // control
    context.canvas.drawCircle(Offset.zero, 10.0 * scale / 8.0, Paint()..color = const Color(0xFF663399));
  }
}