353 lines
11 KiB
Dart
353 lines
11 KiB
Dart
import 'package:flutter/material.dart';
|
|
import 'package:go_router/go_router.dart';
|
|
import 'package:provider/provider.dart';
|
|
import 'package:mileograph_flutter/objects/objects.dart';
|
|
import 'package:mileograph_flutter/services/api_service.dart';
|
|
import 'package:mileograph_flutter/services/data_service.dart';
|
|
import './route_summary_widget.dart';
|
|
|
|
class StationAutocomplete extends StatefulWidget {
|
|
const StationAutocomplete({
|
|
super.key,
|
|
required this.allStations,
|
|
this.initialValue,
|
|
required this.onChanged,
|
|
});
|
|
|
|
final List<Station> allStations;
|
|
final String? initialValue;
|
|
final ValueChanged<String> onChanged;
|
|
|
|
@override
|
|
State<StationAutocomplete> createState() => _StationAutocompleteState();
|
|
}
|
|
|
|
class _StationAutocompleteState extends State<StationAutocomplete> {
|
|
late final TextEditingController _controller;
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
_controller = TextEditingController(text: widget.initialValue ?? '');
|
|
_controller.addListener(() {
|
|
widget.onChanged(_controller.text);
|
|
});
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_controller.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Autocomplete<String>(
|
|
optionsBuilder: (TextEditingValue textEditingValue) {
|
|
if (textEditingValue.text.isEmpty) {
|
|
return const Iterable<String>.empty();
|
|
}
|
|
return _findTopMatches(textEditingValue.text);
|
|
},
|
|
onSelected: (String selection) {
|
|
_controller.text = selection;
|
|
widget.onChanged(selection);
|
|
},
|
|
fieldViewBuilder:
|
|
(context, textEditingController, focusNode, onFieldSubmitted) {
|
|
textEditingController.value = _controller.value;
|
|
|
|
return TextField(
|
|
controller: textEditingController,
|
|
focusNode: focusNode,
|
|
textInputAction: TextInputAction.done,
|
|
onSubmitted: (_) {
|
|
final matches = _findTopMatches(textEditingController.text);
|
|
final firstMatch = matches.isEmpty ? null : matches.first;
|
|
if (firstMatch == null) return;
|
|
_controller.text = firstMatch;
|
|
widget.onChanged(firstMatch);
|
|
focusNode.unfocus(); // optionally close keyboard
|
|
},
|
|
decoration: const InputDecoration(
|
|
labelText: 'Select station',
|
|
border: OutlineInputBorder(),
|
|
),
|
|
);
|
|
},
|
|
);
|
|
}
|
|
|
|
Iterable<String> _findTopMatches(String rawQuery) {
|
|
final query = rawQuery.trim().toLowerCase();
|
|
if (query.isEmpty) return const <String>[];
|
|
|
|
// Keep a bounded, sorted list (by shortest name, then alpha) without
|
|
// sorting the entire match set.
|
|
final best = <String>[];
|
|
for (final station in widget.allStations) {
|
|
final name = station.name;
|
|
if (name.isEmpty) continue;
|
|
if (!name.toLowerCase().contains(query)) continue;
|
|
|
|
_insertCandidate(best, name, max: 10);
|
|
}
|
|
return best;
|
|
}
|
|
|
|
void _insertCandidate(List<String> best, String candidate, {required int max}) {
|
|
final existingIndex = best.indexOf(candidate);
|
|
if (existingIndex >= 0) return;
|
|
|
|
int insertAt = 0;
|
|
while (insertAt < best.length &&
|
|
_candidateCompare(best[insertAt], candidate) <= 0) {
|
|
insertAt++;
|
|
}
|
|
best.insert(insertAt, candidate);
|
|
if (best.length > max) best.removeLast();
|
|
}
|
|
|
|
int _candidateCompare(String a, String b) {
|
|
final byLength = a.length.compareTo(b.length);
|
|
if (byLength != 0) return byLength;
|
|
return a.compareTo(b);
|
|
}
|
|
}
|
|
|
|
class RouteCalculator extends StatefulWidget {
|
|
const RouteCalculator({
|
|
super.key,
|
|
this.onDistanceComputed,
|
|
this.onApplyRoute,
|
|
this.initialStations,
|
|
});
|
|
|
|
final ValueChanged<double>? onDistanceComputed;
|
|
final ValueChanged<RouteResult>? onApplyRoute;
|
|
final List<String>? initialStations;
|
|
|
|
@override
|
|
State<RouteCalculator> createState() => _RouteCalculatorState();
|
|
}
|
|
|
|
class _RouteCalculatorState extends State<RouteCalculator> {
|
|
List<Station> allStations = [];
|
|
|
|
RouteResult? _routeResult;
|
|
RouteResult? get result => _routeResult;
|
|
String? _errorMessage;
|
|
|
|
bool _fetched = false;
|
|
|
|
@override
|
|
void didChangeDependencies() {
|
|
super.didChangeDependencies();
|
|
if (!_fetched) {
|
|
_fetched = true;
|
|
if (widget.initialStations != null && widget.initialStations!.isNotEmpty) {
|
|
context.read<DataService>().stations = List.from(widget.initialStations!);
|
|
}
|
|
WidgetsBinding.instance.addPostFrameCallback((_) async {
|
|
final data = context.read<DataService>();
|
|
final result = await data.fetchStations();
|
|
if (mounted) {
|
|
setState(() => allStations = result);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
Future<void> _calculateRoute(List<String> stations) async {
|
|
setState(() {
|
|
_errorMessage = null;
|
|
_routeResult = null;
|
|
});
|
|
final api = context.read<ApiService>(); // context is valid here
|
|
try {
|
|
final res = await api.post('/route/distance2', {
|
|
'route': stations.where((s) => s.trim().isNotEmpty).toList(),
|
|
});
|
|
|
|
if (res is Map && res['error'] == false) {
|
|
setState(() {
|
|
_routeResult = RouteResult.fromJson(Map<String, dynamic>.from(res));
|
|
});
|
|
final distance = (_routeResult?.distance ?? 0);
|
|
widget.onDistanceComputed?.call(distance);
|
|
} else if (res is Map && res['error_obj'] is List && res['error_obj'].isNotEmpty) {
|
|
setState(() {
|
|
_errorMessage = RouteError.fromJson(
|
|
Map<String, dynamic>.from(res['error_obj'][0] as Map),
|
|
).msg;
|
|
});
|
|
} else {
|
|
setState(() => _errorMessage = 'Failed to calculate route.');
|
|
}
|
|
} catch (e) {
|
|
setState(() => _errorMessage = 'Failed to calculate route: $e');
|
|
}
|
|
}
|
|
|
|
void _addStation() {
|
|
final data = context.read<DataService>();
|
|
setState(() {
|
|
data.stations.add('');
|
|
});
|
|
}
|
|
|
|
void _removeStation(int index) {
|
|
final data = context.read<DataService>();
|
|
setState(() {
|
|
data.stations.removeAt(index);
|
|
});
|
|
}
|
|
|
|
void _updateStation(int index, String value) {
|
|
final data = context.read<DataService>();
|
|
setState(() {
|
|
data.stations[index] = value;
|
|
});
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final data = context.watch<DataService>();
|
|
return Column(
|
|
children: [
|
|
Expanded(
|
|
child: ReorderableListView(
|
|
buildDefaultDragHandles: false,
|
|
padding: const EdgeInsets.symmetric(vertical: 8),
|
|
onReorder: (oldIndex, newIndex) {
|
|
if (newIndex > oldIndex) newIndex -= 1;
|
|
setState(() {
|
|
final moved = data.stations.removeAt(oldIndex);
|
|
data.stations.insert(newIndex, moved);
|
|
});
|
|
},
|
|
children: List.generate(data.stations.length, (index) {
|
|
return Container(
|
|
key: ValueKey('$index-${data.stations[index]}'),
|
|
margin: const EdgeInsets.symmetric(horizontal: 16, vertical: 4),
|
|
child: Row(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
ReorderableDragStartListener(
|
|
index: index,
|
|
child: const Padding(
|
|
padding: EdgeInsets.only(top: 28),
|
|
child: Icon(Icons.drag_indicator),
|
|
),
|
|
),
|
|
const SizedBox(width: 8),
|
|
Expanded(
|
|
child: Card(
|
|
child: Padding(
|
|
padding: const EdgeInsets.all(12),
|
|
child: Row(
|
|
children: [
|
|
Expanded(
|
|
child: StationAutocomplete(
|
|
allStations: allStations,
|
|
initialValue: data.stations[index],
|
|
onChanged: (val) =>
|
|
_updateStation(index, val),
|
|
),
|
|
),
|
|
IconButton(
|
|
icon: const Icon(Icons.close),
|
|
onPressed: () => _removeStation(index),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}),
|
|
),
|
|
),
|
|
if (_errorMessage != null)
|
|
Padding(
|
|
padding: const EdgeInsets.all(8.0),
|
|
child: Text(
|
|
_errorMessage!,
|
|
style: TextStyle(color: Theme.of(context).colorScheme.error),
|
|
),
|
|
)
|
|
else if (_routeResult != null) ...[
|
|
RouteSummaryWidget(
|
|
distance: _routeResult!.distance,
|
|
onDetailsPressed: () {
|
|
final result = _routeResult;
|
|
if (result == null) return;
|
|
context.push('/calculator/details', extra: result);
|
|
},
|
|
),
|
|
if (widget.onApplyRoute != null)
|
|
Padding(
|
|
padding: const EdgeInsets.symmetric(horizontal: 16.0),
|
|
child: ElevatedButton.icon(
|
|
onPressed: () => widget.onApplyRoute!(_routeResult!),
|
|
icon: const Icon(Icons.check),
|
|
label: const Text('Apply to entry'),
|
|
),
|
|
),
|
|
]
|
|
else
|
|
SizedBox.shrink(),
|
|
const SizedBox(height: 10),
|
|
LayoutBuilder(
|
|
builder: (context, constraints) {
|
|
double screenWidth = constraints.maxWidth;
|
|
|
|
return Padding(
|
|
padding: EdgeInsets.only(right: screenWidth < 450 ? 70 : 0),
|
|
child: Row(
|
|
mainAxisAlignment: MainAxisAlignment.center,
|
|
children: [
|
|
ElevatedButton.icon(
|
|
icon: const Icon(Icons.add),
|
|
label: const Text('Add Station'),
|
|
onPressed: _addStation,
|
|
),
|
|
const SizedBox(width: 16),
|
|
ElevatedButton.icon(
|
|
icon: const Icon(Icons.route),
|
|
label: const Text('Calculate Route'),
|
|
onPressed: () async {
|
|
await _calculateRoute(data.stations);
|
|
},
|
|
),
|
|
],
|
|
),
|
|
);
|
|
},
|
|
),
|
|
|
|
const SizedBox(height: 16),
|
|
],
|
|
);
|
|
}
|
|
}
|
|
|
|
Widget debugPanel(List<String> stations) {
|
|
return Padding(
|
|
padding: const EdgeInsets.symmetric(horizontal: 16.0, vertical: 8.0),
|
|
child: Wrap(
|
|
crossAxisAlignment: WrapCrossAlignment.center,
|
|
spacing: 8,
|
|
children: [
|
|
const Text(
|
|
'Current Order:',
|
|
style: TextStyle(fontWeight: FontWeight.bold),
|
|
),
|
|
...stations.map((s) => Chip(label: Text(s.isEmpty ? '<empty>' : s))),
|
|
],
|
|
),
|
|
);
|
|
}
|