import 'package:flutter/material.dart';

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

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

  @override
  Widget build(BuildContext context) {
    return Center(
      child: Container(
        width: 300,
        height: 100,
        decoration: BoxDecoration(
          gradient: EllipticalGradient(
            colors: [
              Color(0xFF01F6BB).withOpacity(0.15),
              Color(0xFF01F6BB).withOpacity(0),
            ],
            stops: const [0.0, 1.0],
            ellipseRelativeCenter: const Offset(0.5, 1),
            ellipseScale: const Scale(widthFactor: 0.9, heightFactor: 0.6),
            backgroundColor: Color(0xFF1C2B3E),
          ),
        ),
      ),
    );
  }
}

class EllipticalGradient extends Gradient {
  final Color backgroundColor;

  /// This offset is relative to top left of the widget, [0,0] means top left and [1,1] bottom right.
  ///
  /// The range is not limited to [0,1] for both x and y axis.
  final Offset ellipseRelativeCenter;
  final Scale ellipseScale;

  const EllipticalGradient({
    required super.colors,
    required this.backgroundColor,
    required this.ellipseRelativeCenter,
    required this.ellipseScale,
    super.stops,
  });

  @override
  Shader createShader(Rect rect, {TextDirection? textDirection}) {
    return RadialGradient(
      center: Alignment(ellipseRelativeCenter.dx * 2 - 1, ellipseRelativeCenter.dy * 2 - 1),
      colors: colors.map((color) => Color.alphaBlend(color, backgroundColor)).toList(),
      radius: 1,
      stops: stops,
      transform: _EllipseTransform(
        ellipseRelativeCenter: ellipseRelativeCenter,
        ellipseScale: ellipseScale,
      ),
    ).createShader(rect, textDirection: textDirection);
  }

  @override
  EllipticalGradient scale(double factor) {
    return EllipticalGradient(
      backgroundColor: backgroundColor,
      colors: colors.map<Color>((Color color) => Color.lerp(null, color, factor)!).toList(),
      ellipseRelativeCenter: ellipseRelativeCenter,
      ellipseScale: ellipseScale,
    );
  }
}

class _EllipseTransform extends GradientTransform {
  final Offset ellipseRelativeCenter;
  final Scale ellipseScale;

  const _EllipseTransform({
    required this.ellipseRelativeCenter,
    required this.ellipseScale,
  });

  @override
  Matrix4? transform(Rect bounds, {TextDirection? textDirection}) {
    final double widthFactor;
    final double heightFactor;
    if (bounds.width > bounds.height) {
      heightFactor = ellipseScale.heightFactor;
      widthFactor = ellipseScale.widthFactor * bounds.width / bounds.height;
    } else {
      heightFactor = ellipseScale.heightFactor * bounds.height / bounds.width;
      widthFactor = ellipseScale.widthFactor;
    }
    final transformMatrix = Matrix4.identity()..scale(widthFactor, heightFactor);
    final Offset originalCenterOffset = Offset(
      bounds.left + bounds.width * ellipseRelativeCenter.dx,
      bounds.top + bounds.height * ellipseRelativeCenter.dy,
    );

    final List<double> offsetLocation =
        transformMatrix.applyToVector3Array([originalCenterOffset.dx, originalCenterOffset.dy, 0.0]);
    final dx = originalCenterOffset.dx - offsetLocation[0];
    final dy = originalCenterOffset.dy - offsetLocation[1];
    return transformMatrix..translate(dx / widthFactor, dy / heightFactor);
  }
}

@immutable
class Scale {
  final double heightFactor;
  final double widthFactor;

  const Scale({
    required this.heightFactor,
    required this.widthFactor,
  });
}