Llm

// 1. Dart core libraries (alphabetically)
import 'dart:async';
import 'dart:convert';
import 'dart:math';

// 2. Flutter and package imports (alphabetically)
import 'package:flutter/material.dart';
import 'package:http/http.dart' as http;
import 'package:provider/provider.dart';

// 3. Relative imports (alphabetically)
import '../models/user.dart';
import '../widgets/custom_button.dart';
import 'user_repository.dart';

// 4. Exports (if any, in separate section)
export 'src/my_library.dart';

class MyWidget extends StatefulWidget {
  // 1. Constructors first
  const MyWidget({
    super.key,
    required this.title,
    this.isEnabled = true,
  });

  // 2. Public constants
  static const double kDefaultHeight = 48.0;

  // 3. Public fields
  final String title;
  final bool isEnabled;

  // 4. Private constants
  static const double _defaultPadding = 16.0;

  // 5. Private fields
  String? _cachedValue;

  // 6. Getters and setters
  bool get isDisabled => !isEnabled;

  // 7. Public methods
  @override
  State<MyWidget> createState() => _MyWidgetState();

  // 8. Private methods
  void _updateCache() {
    // Implementation
  }
}

// Good - always use braces
if (condition) {
  print('hello');
}

// Bad - missing braces
if (condition) print('hello');

// Use "=>" for short functions and getters
String get displayName => '$firstName $lastName';
int get age => DateTime.now().year - birthYear;

// Use braces for longer functions
String formatUserName(String first, String last) {
  if (first.isEmpty && last.isEmpty) {
    return 'Anonymous';
  }
  return '$first $last'.trim();
}

var longMessage = 'This is a very long message '
    'that spans multiple lines.';

// DO annotate return types on function declarations
String formatName(String first, String last) {
  return '$first $last';
}

// DO annotate parameter types on function declarations
void updateUser(String id, Map<String, dynamic> data) {
  // Implementation
}

// DO use explicit types for variables (avoid var/dynamic)
final List<User> users = [];
final Map<String, int> scores = {};

// DON'T explicitly initialize variables to null
String? name; // Good
String? name = null; // Bad

// DO use proper null-aware operators
final displayName = user?.name ?? 'Unknown';

// DO use late for non-nullable fields initialized later
class MyWidget extends StatefulWidget {
  late final AnimationController controller;
}

// DO use Future<void> for async functions that don't return values
Future<void> saveUser(User user) async {
  await repository.save(user);
}

// DO prefer async/await over raw futures
Future<List<User>> loadUsers() async {
  final response = await http.get('/api/users');
  return parseUsers(response.body);
}

/// A custom button widget that provides enhanced styling and behavior.
/// 
/// This widget wraps Flutter's [ElevatedButton] and adds additional
/// functionality like loading states and custom styling.
/// 
/// The [onPressed] callback is called when the button is tapped.
/// Set [isEnabled] to false to disable the button.
/// 
/// Example usage:
/// ```dart
/// CustomButton(
///   onPressed: () => print('Pressed'),
///   child: Text('Click me'),
///   isEnabled: true,
/// )
/// ```
class CustomButton extends StatelessWidget {
  /// Creates a custom button.
  /// 
  /// The [onPressed] and [child] parameters are required.
  /// The [isEnabled] parameter defaults to true.
  const CustomButton({
    super.key,
    required this.onPressed,
    required this.child,
    this.isEnabled = true,
  });

  /// Called when the button is pressed.
  final VoidCallback? onPressed;

  /// The widget to display inside the button.
  final Widget child;

  /// Whether the button is enabled for interaction.
  final bool isEnabled;
}

/// Validates the given email address format.
/// 
/// Returns `true` if the [email] is valid according to RFC standards.
/// Returns `false` if the format is invalid.
/// 
/// Throws [ArgumentError] if [email] is null or empty.
/// 
/// Example:
/// ```dart
/// final isValid = validateEmail('[email protected]'); // true
/// ```
bool validateEmail(String email) {
  if (email.isEmpty) {
    throw ArgumentError('Email cannot be empty');
  }
  return RegExp(r'^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$').hasMatch(email);
}

class CustomCard extends StatelessWidget {
  const CustomCard({
    super.key,
    required this.title,
    required this.content,
    this.elevation = 2.0,
    this.onTap,
  });

  final String title;
  final Widget content;
  final double elevation;
  final VoidCallback? onTap;

  @override
  Widget build(BuildContext context) {
    return Card(
      elevation: elevation,
      child: InkWell(
        onTap: onTap,
        child: Padding(
          padding: const EdgeInsets.all(16.0),
          child: Column(
            crossAxisAlignment: CrossAxisAlignment.start,
            children: [
              Text(
                title,
                style: Theme.of(context).textTheme.titleLarge,
              ),
              const SizedBox(height: 8.0),
              content,
            ],
          ),
        ),
      ),
    );
  }
}

// PREFER using interpolation to compose strings
final name = 'John Doe';
final age = 25;
final message = 'Hello, $name! You are $age years old.';
final calculation = 'Next year you will be ${age + 1}.';

// DO use adjacent strings for long literals
const longText = 'This is a very long text that '
    'spans multiple lines for better '
    'readability in the source code.';

// DO use collection literals
final List<String> names = [];
final Map<String, int> scores = {};
final Set<int> uniqueIds = {};

// DON'T use .length to check if empty
if (names.isEmpty) { // Good
  print('No names');
}

if (names.length == 0) { // Bad
  print('No names');
}

// DO use collection methods effectively
final activeUsers = users.where((user) => user.isActive).toList();
final userNames = users.map((user) => user.name).toList();

// DON'T create lambdas when tear-offs work
final numbers = [1, 2, 3, 4, 5];

// Good - use tear-off
numbers.forEach(print);

// Bad - unnecessary lambda
numbers.forEach((number) {
  print(number);
});

// Good: Specific and actionable
throw ArgumentError('Email must contain @ symbol');
throw StateError('Cannot call increment() after dispose()');

// Bad: Vague and unhelpful
throw ArgumentError('Invalid input');
throw Exception('Error occurred');

Future<User> fetchUser(String id) async {
  try {
    final response = await api.getUser(id);
    return User.fromJson(response.data);
  } on NetworkException catch (e) {
    throw UserFetchException('Failed to fetch user: ${e.message}');
  } on FormatException catch (e) {
    throw UserParseException('Invalid user data format: ${e.message}');
  } catch (e) {
    throw UserFetchException('Unexpected error: ${e.toString()}');
  }
}

testWidgets('CustomButton should call onPressed when tapped', (tester) async {
  bool wasPressed = false;
  
  await tester.pumpWidget(
    MaterialApp(
      home: Scaffold(
        body: CustomButton(
          onPressed: () => wasPressed = true,
          child: const Text('Test Button'),
        ),
      ),
    ),
  );
  
  await tester.tap(find.byType(CustomButton));
  await tester.pump();
  
  expect(wasPressed, isTrue);
});

group('UserRepository', () {
  late UserRepository repository;
  late MockApiClient mockApi;
  
  setUp(() {
    mockApi = MockApiClient();
    repository = UserRepository(api: mockApi);
  });
  
  group('getUser', () {
    test('should return user when valid ID provided', () async {
      // Arrange
      const userId = '123';
      final expectedUser = User(id: userId, name: 'John');
      when(() => mockApi.getUser(userId))
          .thenAnswer((_) async => expectedUser.toJson());
      
      // Act
      final user = await repository.getUser(userId);
      
      // Assert
      expect(user.id, equals(userId));
      expect(user.name, equals('John'));
    });
    
    test('should throw exception when user not found', () async {
      // Arrange
      const userId = 'invalid';
      when(() => mockApi.getUser(userId))
          .thenThrow(NotFoundException());
      
      // Act & Assert
      expect(
        () => repository.getUser(userId),
        throwsA(isA<UserNotFoundException>()),
      );
    });
  });
});

class User {
  const User({
    required this.id,
    required this.name,
    required this.email,
    this.isActive = true,
  });
  
  final String id;
  final String name;
  final String email;
  final bool isActive;
  
  // Use copyWith for immutable updates
  User copyWith({
    String? id,
    String? name,
    String? email,
    bool? isActive,
  }) {
    return User(
      id: id ?? this.id,
      name: name ?? this.name,
      email: email ?? this.email,
      isActive: isActive ?? this.isActive,
    );
  }
  
  // Override equality
  @override
  bool operator ==(Object other) =>
      other is User &&
      runtimeType == other.runtimeType &&
      id == other.id;
  
  @override
  int get hashCode => id.hashCode;
  
  @override
  String toString() => 'User(id: $id, name: $name, email: $email)';
}

enum ConnectionState {
  disconnected,
  connecting,
  connected,
  error,
}

// Use switch without default to catch all cases
Widget buildConnectionIndicator(ConnectionState state) {
  switch (state) {
    case ConnectionState.disconnected:
      return const Icon(Icons.wifi_off, color: Colors.grey);
    case ConnectionState.connecting:
      return const CircularProgressIndicator();
    case ConnectionState.connected:
      return const Icon(Icons.wifi, color: Colors.green);
    case ConnectionState.error:
      return const Icon(Icons.error, color: Colors.red);
  }
}

class Rectangle {
  const Rectangle({
    required this.width,
    required this.height,
  }) : assert(width > 0, 'Width must be positive'),
       assert(height > 0, 'Height must be positive');

  final double width;
  final double height;

  double get area {
    assert(width > 0 && height > 0, 'Invalid rectangle dimensions');
    return width * height;
  }
}

// Use const constructors when possible
const EdgeInsets.all(16.0);
const SizedBox(height: 8.0);

// Create const widgets for better performance
class LoadingIndicator extends StatelessWidget {
  const LoadingIndicator({super.key});

  @override
  Widget build(BuildContext context) {
    return const Center(
      child: CircularProgressIndicator(),
    );
  }
}

class ProductList extends StatelessWidget {
  const ProductList({
    super.key,
    required this.products,
  });

  final List<Product> products;

  @override
  Widget build(BuildContext context) {
    // Don't do heavy computation in build method
    return ListView.builder(
      itemCount: products.length,
      itemBuilder: (context, index) {
        final product = products[index];
        return ProductTile(
          key: ValueKey(product.id),
          product: product,
        );
      },
    );
  }
}

// DON'T use double negatives
bool get isNotDisabled => !disabled; // Confusing

// DO use positive naming
bool get isEnabled => !disabled; // Clear

// DON'T use global state
var globalCounter = 0; // Avoid

// DO use proper state management
class CounterProvider extends ChangeNotifier {
  int _counter = 0;
  int get counter => _counter;
}

// DON'T create classes with only static members
class MathUtils {
  static double pi = 3.14159;
  static double circleArea(double radius) => pi * radius * radius;
}

// DO use top-level functions and constants
const double pi = 3.14159;
double circleArea(double radius) => pi * radius * radius;

// DON'T avoid using APIs as intended
class TimeSlot {
  TimeSlot(this.start, this.end);
  DateTime start;
  DateTime end;
}

// DO follow API design principles
class TimeSlot {
  const TimeSlot({
    required this.start,
    required this.end,
  }) : assert(start.isBefore(end), 'Start must be before end');
  
  final DateTime start;
  final DateTime end;
}