end_location_chooser_screen.dart

Go to the documentation of this file.

import 'package:easy_localization/easy_localization.dart';
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:flutter_screenutil/flutter_screenutil.dart';
import 'package:google_maps_flutter/google_maps_flutter.dart';
import 'package:geolocator/geolocator.dart';
import 'package:geocoding/geocoding.dart';
import 'package:go_router/go_router.dart';
import 'package:fluentui_system_icons/fluentui_system_icons.dart';
import 'dart:async';
 
import '../../../../../core/ui/theme/color_palette.dart';
import '../../../../../core/ui/widgets/custom_scaffold.dart';
import '../../../../../core/router/routes.dart';
import '../../bloc/planning_bloc/routing_planning_bloc.dart';
import '../../../../auth/presentation/bloc/authentication_bloc/authentication_bloc.dart';
import 'models/saved_location.dart';
import 'widgets/location_search_bar.dart';
import 'widgets/saved_locations_list.dart';
import 'widgets/custom_pin_widget.dart';
import 'widgets/address_info_widget.dart';
import 'widgets/map_overlay_buttons.dart';
import 'widgets/confirm_location_button.dart';
 
class EndLocationChooserScreen extends StatefulWidget {
  const EndLocationChooserScreen({super.key});
 
  @override
  State<EndLocationChooserScreen> createState() => _EndLocationChooserScreenState();
}
 
class _EndLocationChooserScreenState extends State<EndLocationChooserScreen> {
  GoogleMapController? _mapController;
  bool _isMapLoaded = false;
  final TextEditingController _searchController = TextEditingController();
  LatLng _initialPosition = const LatLng(51.5074, -0.1278);
  LatLng _currentCameraPosition = const LatLng(51.5074, -0.1278);
  bool _isBottomSheetExpanded = false;
  bool _isBottomSheetVisible = false;
  String _currentAddress = 'scheduling.choose_end_location'.tr();
  bool _isLoadingAddress = false;
  bool _isSearchVisible = false;
  Timer? _debounceTimer;
 
  final String mapStyle = '''
    [
      {
        "featureType": "poi",
        "elementType": "labels.icon",
        "stylers": [
          {
            "visibility": "off"
          }
        ]
      },
      {
        "featureType": "transit",
        "stylers": [
          {
            "visibility": "off"
          }
        ]
      }
    ]
    ''';
 
  final List<SavedLocation> _savedLocations = [
    SavedLocation(
      name: 'Dammam Warehouse',
      address: 'Al-Dammam, Saudi Arabia',
      latLng: LatLng(26.251011, 49.971146),
      icon: FluentIcons.building_16_filled,
    ),
    SavedLocation(
      name: 'Jeddah Warehouse',
      address: 'Prince Abdulmajeed, Jeddah Saudi Arabia',
      latLng: LatLng(21.418327917324838, 39.25912328519525),
      icon: FluentIcons.building_16_filled,
    ),
    SavedLocation(
      name: 'Riyadh Warehouse',
      address: 'Al Misfat, Riyad Arabie saoudite',
      latLng: LatLng(24.5518913, 46.8818212),
      icon: FluentIcons.building_16_filled,
    ),
  ];
 
  @override
  void initState() {
    super.initState();
    _getCurrentLocationForInit();
  }
 
  Future<void> _getCurrentLocationForInit() async {
    try {
      bool serviceEnabled = await Geolocator.isLocationServiceEnabled();
      if (!serviceEnabled) return;
 
      LocationPermission permission = await Geolocator.checkPermission();
      if (permission == LocationPermission.denied) {
        permission = await Geolocator.requestPermission();
        if (permission == LocationPermission.denied) return;
      }
 
      if (permission == LocationPermission.deniedForever) return;
 
      final position = await Geolocator.getCurrentPosition(
        locationSettings: const LocationSettings(
          accuracy: LocationAccuracy.high,
          timeLimit: Duration(seconds: 10),
        ),
      );
 
      setState(() {
        _initialPosition = LatLng(position.latitude, position.longitude);
        _currentCameraPosition = _initialPosition;
      });
 
      // Get initial address
      _getAddressFromLocation(_initialPosition);
 
      if (_mapController != null) {
        await _mapController!.animateCamera(
          CameraUpdate.newCameraPosition(
            CameraPosition(
              target: _initialPosition,
              zoom: 15,
            ),
          ),
        );
      }
    } catch (e) {
      // Handle error silently, keep default position
    }
  }
 
  void _onCameraMove(CameraPosition position) {
    _currentCameraPosition = position.target;
    setState(() {
      _isLoadingAddress = true;
    });
 
    // Cancel previous timer
    _debounceTimer?.cancel();
 
    // Set new timer to debounce the address lookup
    _debounceTimer = Timer(const Duration(milliseconds: 500), () {
      _getAddressFromLocation(position.target);
    });
  }
 
  void _onCameraIdle() {
    setState(() {
      _isBottomSheetExpanded = false; // Collapse bottom sheet when map is moved
      _isBottomSheetVisible = false; // Hide bottom sheet when map is moved
    });
  }
 
  Future<void> _getAddressFromLocation(LatLng location) async {
    setState(() {
      _isLoadingAddress = true;
    });
 
    try {
      List<Placemark> placemarks = await placemarkFromCoordinates(
        location.latitude,
        location.longitude,
      );
 
      if (placemarks.isNotEmpty && mounted) {
        final placemark = placemarks.first;
        String address = '';
 
        if (placemark.street != null && placemark.street!.isNotEmpty) {
          address += placemark.street!;
        }
 
        if (placemark.locality != null && placemark.locality!.isNotEmpty) {
          if (address.isNotEmpty) address += ', ';
          address += placemark.locality!;
        }
 
        if (placemark.administrativeArea != null &&
            placemark.administrativeArea!.isNotEmpty) {
          if (address.isNotEmpty) address += ', ';
          address += placemark.administrativeArea!;
        }
 
        if (placemark.country != null && placemark.country!.isNotEmpty) {
          if (address.isNotEmpty) address += ', ';
          address += placemark.country!;
        }
 
        setState(() {
          _currentAddress = address.isNotEmpty ? address : 'scheduling.selected_location'.tr();
          _isLoadingAddress = false;
        });
      }
    } catch (e) {
      if (mounted) {
        setState(() {
          _currentAddress = 'scheduling.selected_location'.tr();
          _isLoadingAddress = false;
        });
      }
    }
  }
 
  void _onSavedLocationSelected(SavedLocation location) async {
    if (_mapController != null) {
      await _mapController!.animateCamera(
        CameraUpdate.newCameraPosition(
          CameraPosition(
            target: location.latLng,
            zoom: 15,
          ),
        ),
      );
    }
    // Close bottom sheet after selecting location
    setState(() {
      _isBottomSheetVisible = false;
      _isBottomSheetExpanded = false;
    });
  }
 
  void _confirmLocation() {
    // Set end location in routing planning bloc
    context.read<RoutingPlanningBloc>().add(
      SetEndLocationEvent(
        location: _currentCameraPosition,
        address: _currentAddress,
      ),
    );
 
    // Get authenticated user and create routing
    final authState = context.read<AuthenticationBloc>().state;
    if (authState is AuthenticatedState) {
      context.read<RoutingPlanningBloc>().add(
        CreateRoutingEvent(
          driverId: (authState.session.uid)?.toInt() ?? 0,
          duration: 60,
        ),
      );
    }
  }
 
  @override
  Widget build(BuildContext context) {
    return BlocListener<RoutingPlanningBloc, RoutingPlanningState>(
      listener: (context, state) {
        if (state is RoutingPlanningError) {
          ScaffoldMessenger.of(context).showSnackBar(
            SnackBar(
              content: Text(state.failure.message),
              backgroundColor: state.failure.color,
            ),
          );
        } else if (state is RoutingPlanningSuccess) {
          // Clear the navigation stack and navigate to schedule confirmation
          context.go(Routes.scheduleConfirmationScreen.route);
        }
      },
      child: CustomScaffold(
        title: 'scheduling.choose_end_location'.tr(),
        backgroundColor: ColorPalette.antiFlashWhite,
        body: Column(
          children: [
            Expanded(
              child: Stack(
                children: [
                  GoogleMap(
                    style: mapStyle,
                    initialCameraPosition: CameraPosition(
                      target: _initialPosition,
                      zoom: 10,
                    ),
                    onMapCreated: (GoogleMapController controller) {
                      _mapController = controller;
                      setState(() {
                        _isMapLoaded = true;
                      });
                    },
                    onCameraMove: _onCameraMove,
                    onCameraIdle: _onCameraIdle,
                    myLocationEnabled: true,
                    myLocationButtonEnabled: false,
                    zoomControlsEnabled: false,
                    zoomGesturesEnabled: true,
                    mapToolbarEnabled: false,
                    compassEnabled: true,
                  ),
                  _buildCenterPin(),
                  _buildCenterDot(),
                  // Search bar overlay (when visible)
                  if (_isSearchVisible)
                    Positioned(
                      top: 20.h,
                      left: 16.w,
                      right: 16.w,
                      child: LocationSearchBar(
                        controller: _searchController,
                        isVisible: _isSearchVisible,
                        onLocationSelected: (location) {
                          if (_mapController != null) {
                            _mapController!.animateCamera(
                              CameraUpdate.newCameraPosition(
                                CameraPosition(
                                  target: location,
                                  zoom: 15,
                                ),
                              ),
                            );
                          }
                        },
                        onClose: () {
                          setState(() {
                            _isSearchVisible = false;
                          });
                        },
                      ),
                    ),
                  if (!_isSearchVisible)
                    Positioned(
                      top: 20.h,
                      left: 16.w,
                      right: 16.w,
                      child: AddressInfoWidget(
                        address: _currentAddress,
                        isLoading: _isLoadingAddress,
                      ),
                    ),
                  if (!_isMapLoaded)
                    Container(
                      color: Colors.white.withValues(alpha: 0.7),
                      child: const Center(
                        child: CircularProgressIndicator(),
                      ),
                    ),
                  Positioned(
                    right: 16,
                    bottom: 115.h,
                    child: MapOverlayButtons(
                      onSearchPressed: () {
                        setState(() {
                          _isSearchVisible = !_isSearchVisible;
                        });
                      },
                      onSavedLocationsPressed: () {
                        setState(() {
                          _isBottomSheetVisible = !_isBottomSheetVisible;
                          if (_isBottomSheetVisible) {
                            _isBottomSheetExpanded = true;
                          }
                        });
                      },
                    ),
                  ),
                  Positioned(
                    bottom: 20.h,
                    left: 16.w,
                    right: 16.w,
                    child: BlocBuilder<RoutingPlanningBloc, RoutingPlanningState>(
                      builder: (context, state) {
                        final isLoading = state is RoutingPlanningLoading;
                        return ConfirmLocationButton(
                          onPressed: isLoading ? null : _confirmLocation,
                          isLoading: isLoading,
                        );
                      },
                    ),
                  ),
                ],
              ),
            ),
            if (_isBottomSheetVisible)
              AnimatedContainer(
                duration: const Duration(milliseconds: 300),
                curve: Curves.easeInOut,
                height: _isBottomSheetExpanded ? 280.h : 60.h,
                child: SavedLocationsList(
                  savedLocations: _savedLocations,
                  onLocationSelected: _onSavedLocationSelected,
                  isExpanded: _isBottomSheetExpanded,
                  onToggle: () {
                    setState(() {
                      _isBottomSheetExpanded = !_isBottomSheetExpanded;
                    });
                  },
                  onClose: () {
                    setState(() {
                      _isBottomSheetVisible = false;
                      _isBottomSheetExpanded = false;
                    });
                  },
                ),
              ),
          ],
        ),
      ),
    );
  }
 
  Widget _buildCenterPin() {
    return Center(
      child: Transform.translate(
        offset: Offset(0, -24.5.sp),
        child: AnimatedContainer(
          duration: const Duration(milliseconds: 200),
          transform:
              Matrix4.translationValues(0, _isLoadingAddress ? -5 : 0, 0),
          child: CustomPinWidget(
            color: ColorPalette.lightGreen,
            size: 35.sp,
            hasShadow: _isLoadingAddress,
          ),
        ),
      ),
    );
  }
 
  Widget _buildCenterDot() {
    return Center(
      child: Container(
        width: 4.sp,
        height: 4.sp,
        decoration: BoxDecoration(
          color: _isLoadingAddress
              ? ColorPalette.lightGreen
              : ColorPalette.lightGreen.withValues(alpha: 0.6),
          shape: BoxShape.circle,
          boxShadow: _isLoadingAddress
              ? [
                  BoxShadow(
                    color: Colors.black.withValues(alpha: 0.3),
                    offset: const Offset(0, 2),
                    blurRadius: 2,
                    spreadRadius: 2,
                  ),
                ]
              : [],
        ),
      ),
    );
  }
 
  @override
  void dispose() {
    _mapController?.dispose();
    _searchController.dispose();
    _debounceTimer?.cancel();
    super.dispose();
  }
}