1666 lines
54 KiB
Dart
1666 lines
54 KiB
Dart
import 'dart:async';
|
|
import 'dart:convert';
|
|
|
|
import 'package:collection/collection.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter/services.dart';
|
|
import 'package:intl/intl.dart';
|
|
import 'package:mileograph_flutter/components/calculator/calculator.dart';
|
|
import 'package:mileograph_flutter/components/pages/traction.dart';
|
|
import 'package:mileograph_flutter/objects/objects.dart';
|
|
import 'package:mileograph_flutter/services/apiService.dart';
|
|
import 'package:mileograph_flutter/services/dataService.dart';
|
|
import 'package:mileograph_flutter/services/navigation_guard.dart';
|
|
import 'package:provider/provider.dart';
|
|
import 'package:shared_preferences/shared_preferences.dart';
|
|
|
|
class NewEntryPage extends StatefulWidget {
|
|
const NewEntryPage({super.key, this.editLegId});
|
|
|
|
final int? editLegId;
|
|
|
|
@override
|
|
State<NewEntryPage> createState() => _NewEntryPageState();
|
|
}
|
|
|
|
class _NewEntryPageState extends State<NewEntryPage> {
|
|
static const _draftPrefsKey = 'new_entry_draft';
|
|
static const _draftListPrefsKey = 'new_entry_drafts_list';
|
|
|
|
final _formKey = GlobalKey<FormState>();
|
|
DateTime _selectedDate = DateTime.now();
|
|
TimeOfDay _selectedTime = TimeOfDay.now();
|
|
final _startController = TextEditingController();
|
|
final _endController = TextEditingController();
|
|
final _headcodeController = TextEditingController();
|
|
final _notesController = TextEditingController();
|
|
final _mileageController = TextEditingController();
|
|
final _networkController = TextEditingController();
|
|
bool _submitting = false;
|
|
bool _useManualMileage = false;
|
|
RouteResult? _routeResult;
|
|
final List<_TractionItem> _tractionItems = [_TractionItem.marker()];
|
|
int? _selectedTripId;
|
|
bool _restoringDraft = false;
|
|
bool _loadingEdit = false;
|
|
String? _loadError;
|
|
Map<String, dynamic>? _lastSubmittedSnapshot;
|
|
Map<String, dynamic>? _loadedDraftSnapshot;
|
|
final DeepCollectionEquality _snapshotEquality =
|
|
const DeepCollectionEquality();
|
|
String? _activeDraftId;
|
|
|
|
bool get _isEditing => widget.editLegId != null;
|
|
bool get _draftPersistenceEnabled => false; // legacy single draft disabled in favor of draft list
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
NavigationGuard.register(_handleExitIntent);
|
|
// legacy single-draft auto-save listeners removed in favor of explicit multi-draft flow
|
|
Future.microtask(() {
|
|
if (!mounted) return;
|
|
final data = context.read<DataService>();
|
|
data.fetchClassList();
|
|
data.fetchTrips();
|
|
if (_draftPersistenceEnabled) {
|
|
_loadDraft();
|
|
}
|
|
if (_isEditing && widget.editLegId != null) {
|
|
_loadLegForEdit(widget.editLegId!);
|
|
}
|
|
});
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
NavigationGuard.unregister(_handleExitIntent);
|
|
_startController.dispose();
|
|
_endController.dispose();
|
|
_headcodeController.dispose();
|
|
_notesController.dispose();
|
|
_mileageController.dispose();
|
|
_networkController.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
Widget _buildTripSelector(BuildContext context) {
|
|
final trips = context.watch<DataService>().tripList;
|
|
final sorted = [...trips]..sort((a, b) => b.tripId.compareTo(a.tripId));
|
|
final tripIds = sorted.map((t) => t.tripId).toSet();
|
|
final selectedValue =
|
|
(_selectedTripId != null && tripIds.contains(_selectedTripId))
|
|
? _selectedTripId
|
|
: null;
|
|
return Row(
|
|
children: [
|
|
Expanded(
|
|
child: DropdownButtonFormField<int?>(
|
|
value: selectedValue,
|
|
decoration: const InputDecoration(
|
|
labelText: 'Trip',
|
|
border: OutlineInputBorder(),
|
|
),
|
|
items: [
|
|
const DropdownMenuItem(value: null, child: Text('No trip')),
|
|
...sorted.map(
|
|
(t) => DropdownMenuItem<int?>(
|
|
value: t.tripId,
|
|
child: Text(t.tripName),
|
|
),
|
|
),
|
|
],
|
|
onChanged: (val) {
|
|
setState(() => _selectedTripId = val);
|
|
_saveDraft();
|
|
},
|
|
),
|
|
),
|
|
const SizedBox(width: 8),
|
|
ElevatedButton.icon(
|
|
onPressed: () => _showAddTripDialog(context),
|
|
icon: const Icon(Icons.add),
|
|
label: const Text('New Trip'),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
|
|
Future<void> _showAddTripDialog(BuildContext context) async {
|
|
final controller = TextEditingController();
|
|
final result = await showDialog<String>(
|
|
context: context,
|
|
builder: (context) => AlertDialog(
|
|
title: const Text('New Trip'),
|
|
content: TextField(
|
|
controller: controller,
|
|
decoration: const InputDecoration(labelText: 'Trip name'),
|
|
autofocus: true,
|
|
),
|
|
actions: [
|
|
TextButton(
|
|
onPressed: () => Navigator.of(context).pop(),
|
|
child: const Text('Cancel'),
|
|
),
|
|
ElevatedButton(
|
|
onPressed: () => Navigator.of(context).pop(controller.text.trim()),
|
|
child: const Text('Add'),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
if (!mounted) return;
|
|
if (result != null && result.isNotEmpty) {
|
|
final api = context.read<ApiService>();
|
|
final data = context.read<DataService>();
|
|
final messenger = ScaffoldMessenger.of(context);
|
|
try {
|
|
await api.put('/trips/new', {"trip_name": result});
|
|
await data.fetchTrips();
|
|
if (!mounted) return;
|
|
final trips = data.tripList;
|
|
final match = trips.firstWhere(
|
|
(t) => t.tripName == result,
|
|
orElse: () => trips.isNotEmpty
|
|
? trips.first
|
|
: TripSummary(tripId: 0, tripName: result, tripMileage: 0),
|
|
);
|
|
setState(() => _selectedTripId = match.tripId);
|
|
_saveDraft();
|
|
} catch (e) {
|
|
if (!mounted) return;
|
|
messenger.showSnackBar(
|
|
SnackBar(content: Text('Failed to add trip: $e')),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
Future<void> _openCalculator() async {
|
|
final result = await Navigator.of(context).push<RouteResult>(
|
|
MaterialPageRoute(
|
|
builder: (_) => _CalculatorPickerPage(
|
|
onResult: (res) => Navigator.of(context).pop(res),
|
|
),
|
|
),
|
|
);
|
|
if (result != null) {
|
|
setState(() {
|
|
_routeResult = result;
|
|
_mileageController.text = result.distance.toStringAsFixed(2);
|
|
_useManualMileage = false;
|
|
});
|
|
_saveDraft();
|
|
}
|
|
}
|
|
|
|
Future<void> _openTractionPicker() async {
|
|
final selectedKeys = _tractionItems
|
|
.where((e) => !e.isMarker && e.loco != null)
|
|
.map((e) => '${e.loco!.locoClass}-${e.loco!.number}')
|
|
.toSet();
|
|
await Navigator.of(context).push(
|
|
MaterialPageRoute(
|
|
builder: (_) => TractionPage(
|
|
selectionMode: true,
|
|
selectedKeys: selectedKeys,
|
|
onSelect: (loco) {
|
|
final markerIndex = _tractionItems.indexWhere(
|
|
(element) => element.isMarker,
|
|
);
|
|
final key = '${loco.locoClass}-${loco.number}';
|
|
setState(() {
|
|
final existingIndex = _tractionItems.indexWhere(
|
|
(e) =>
|
|
!e.isMarker &&
|
|
e.loco != null &&
|
|
'${e.loco!.locoClass}-${e.loco!.number}' == key,
|
|
);
|
|
if (existingIndex != -1) {
|
|
_tractionItems.removeAt(existingIndex);
|
|
} else {
|
|
_tractionItems.insert(
|
|
markerIndex,
|
|
_TractionItem(loco: loco, powering: true),
|
|
);
|
|
}
|
|
});
|
|
_saveDraft();
|
|
},
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
Future<void> _pickDate() async {
|
|
final picked = await showDatePicker(
|
|
context: context,
|
|
initialDate: _selectedDate,
|
|
firstDate: DateTime(1970),
|
|
lastDate: DateTime.now().add(const Duration(days: 365)),
|
|
);
|
|
if (picked != null) setState(() => _selectedDate = picked);
|
|
_saveDraft();
|
|
}
|
|
|
|
Future<void> _pickTime() async {
|
|
final picked = await showTimePicker(
|
|
context: context,
|
|
initialTime: _selectedTime,
|
|
);
|
|
if (picked != null) {
|
|
setState(() => _selectedTime = picked);
|
|
_saveDraft();
|
|
}
|
|
}
|
|
|
|
Future<void> _loadLegForEdit(int legId) async {
|
|
setState(() {
|
|
_loadingEdit = true;
|
|
_loadError = null;
|
|
});
|
|
try {
|
|
final api = context.read<ApiService>();
|
|
final json = await api.get('/legs/by-id/$legId');
|
|
if (!mounted) return;
|
|
if (json is! Map<String, dynamic>) {
|
|
throw Exception('Unexpected response for leg $legId');
|
|
}
|
|
final beginTime = DateTime.tryParse(json['leg_begin_time'] ?? '') ??
|
|
_selectedDate;
|
|
final routeStations = _parseRouteStations(json['leg_route']);
|
|
final mileageVal = (json['leg_mileage'] as num?)?.toDouble() ?? 0.0;
|
|
final useManual = routeStations.isEmpty;
|
|
final routeResult = useManual
|
|
? null
|
|
: RouteResult(
|
|
inputRoute: routeStations,
|
|
calculatedRoute: routeStations,
|
|
costs: const <double>[],
|
|
distance: mileageVal,
|
|
);
|
|
final tractionItems = _buildTractionFromApi(
|
|
(json['locos'] as List? ?? [])
|
|
.whereType<Map>()
|
|
.map((e) => Map<String, dynamic>.from(e))
|
|
.toList(),
|
|
);
|
|
|
|
_restoringDraft = true;
|
|
setState(() {
|
|
final tripRaw = json['leg_trip'];
|
|
final tripId = tripRaw is num ? tripRaw.toInt() : null;
|
|
_selectedTripId = tripId == null || tripId == 0 ? null : tripId;
|
|
_selectedDate = beginTime;
|
|
_selectedTime = TimeOfDay.fromDateTime(beginTime);
|
|
_useManualMileage = useManual;
|
|
_routeResult = routeResult;
|
|
_startController.text = json['leg_start'] ?? '';
|
|
_endController.text = json['leg_end'] ?? '';
|
|
_headcodeController.text =
|
|
(json['leg_headcode'] as String? ?? '').toUpperCase();
|
|
_notesController.text = json['leg_notes'] ?? '';
|
|
_networkController.text =
|
|
(json['leg_network'] as String? ?? '').toUpperCase();
|
|
_mileageController.text =
|
|
mileageVal == 0 ? '' : mileageVal.toStringAsFixed(2);
|
|
_tractionItems
|
|
..clear()
|
|
..addAll(tractionItems);
|
|
if (_tractionItems.where((e) => e.isMarker).isEmpty) {
|
|
_tractionItems.insert(0, _TractionItem.marker());
|
|
}
|
|
_lastSubmittedSnapshot = null;
|
|
});
|
|
} catch (e) {
|
|
if (!mounted) return;
|
|
setState(() {
|
|
_loadError = 'Failed to load entry: $e';
|
|
});
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
SnackBar(content: Text('Failed to load entry: $e')),
|
|
);
|
|
} finally {
|
|
_restoringDraft = false;
|
|
if (mounted) {
|
|
setState(() => _loadingEdit = false);
|
|
}
|
|
}
|
|
}
|
|
|
|
List<String> _parseRouteStations(dynamic raw) {
|
|
if (raw is List) {
|
|
return raw.map((e) => e.toString()).toList();
|
|
}
|
|
if (raw is String) {
|
|
final trimmed = raw.trim();
|
|
if (trimmed.isEmpty) return [];
|
|
try {
|
|
final decoded = jsonDecode(trimmed);
|
|
if (decoded is List) {
|
|
return decoded.map((e) => e.toString()).toList();
|
|
}
|
|
} catch (_) {
|
|
// ignore and try alternative parsing
|
|
}
|
|
if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
|
|
try {
|
|
final replaced = trimmed.replaceAll("'", '"');
|
|
final decoded = jsonDecode(replaced);
|
|
if (decoded is List) {
|
|
return decoded.map((e) => e.toString()).toList();
|
|
}
|
|
} catch (_) {}
|
|
}
|
|
if (trimmed.contains('->')) {
|
|
return trimmed
|
|
.split('->')
|
|
.map((e) => e.trim())
|
|
.where((e) => e.isNotEmpty)
|
|
.toList();
|
|
}
|
|
if (trimmed.contains(',')) {
|
|
return trimmed
|
|
.split(',')
|
|
.map((e) => e.trim())
|
|
.where((e) => e.isNotEmpty)
|
|
.toList();
|
|
}
|
|
return [trimmed];
|
|
}
|
|
return [];
|
|
}
|
|
|
|
List<_TractionItem> _buildTractionFromApi(
|
|
List<Map<String, dynamic>> locoData,
|
|
) {
|
|
if (locoData.isEmpty) return [_TractionItem.marker()];
|
|
final sorted = [...locoData]
|
|
..sort((a, b) {
|
|
return _allocPos(b).compareTo(_allocPos(a));
|
|
});
|
|
final leading = sorted.where((e) => _allocPos(e) >= 0);
|
|
final trailing = sorted.where((e) => _allocPos(e) < 0);
|
|
return [
|
|
...leading.map(_mapLocoToTractionItem),
|
|
_TractionItem.marker(),
|
|
...trailing.map(_mapLocoToTractionItem),
|
|
];
|
|
}
|
|
|
|
int _allocPos(Map<String, dynamic> loco) =>
|
|
(loco['alloc_pos'] as num?)?.toInt() ?? 0;
|
|
|
|
_TractionItem _mapLocoToTractionItem(Map<String, dynamic> loco) {
|
|
final poweringRaw = loco['alloc_powering'];
|
|
final powering = poweringRaw == true || poweringRaw == 1;
|
|
return _TractionItem(
|
|
loco: LocoSummary.fromJson(loco),
|
|
powering: powering,
|
|
);
|
|
}
|
|
|
|
DateTime get _legDateTime => DateTime(
|
|
_selectedDate.year,
|
|
_selectedDate.month,
|
|
_selectedDate.day,
|
|
_selectedTime.hour,
|
|
_selectedTime.minute,
|
|
);
|
|
|
|
List<Map<String, dynamic>> _buildTractionPayload() {
|
|
final markerIndex = _tractionItems.indexWhere(
|
|
(element) => element.isMarker,
|
|
);
|
|
final payload = <Map<String, dynamic>>[];
|
|
for (var i = 0; i < _tractionItems.length; i++) {
|
|
final item = _tractionItems[i];
|
|
if (item.isMarker || item.loco == null) continue;
|
|
int allocPos;
|
|
if (i > markerIndex) {
|
|
allocPos = -(i - markerIndex);
|
|
} else {
|
|
allocPos = (markerIndex - 1) - i;
|
|
}
|
|
payload.add({
|
|
"loco_type": item.loco!.type,
|
|
"loco_number": item.loco!.number,
|
|
"alloc_pos": allocPos,
|
|
"alloc_powering": item.powering ? 1 : 0,
|
|
});
|
|
}
|
|
return payload;
|
|
}
|
|
|
|
Future<bool> _handleExitIntent() async {
|
|
if (!mounted) return false;
|
|
if (_isEditing) return true;
|
|
if (_formIsEmpty()) return true;
|
|
if (_activeDraftId != null && !_draftChangedFromBaseline()) {
|
|
return true;
|
|
}
|
|
final choice = await _promptSaveDraft();
|
|
if (choice == _ExitChoice.cancel) return false;
|
|
if (choice == _ExitChoice.save) {
|
|
await _saveDraftEntry(draftId: _activeDraftId);
|
|
} else if (choice == _ExitChoice.discard) {
|
|
await _resetFormState(clearDraft: true);
|
|
_activeDraftId = null;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool _draftChangedFromBaseline() {
|
|
if (_loadedDraftSnapshot == null) return true;
|
|
final current = _normalizeDraftSnapshot(
|
|
_buildDraftSnapshot(
|
|
id: _activeDraftId ?? 'temp',
|
|
includeTimestamp: false,
|
|
),
|
|
);
|
|
final baseline = _normalizeDraftSnapshot(_loadedDraftSnapshot!);
|
|
return !_snapshotEquality.equals(baseline, current);
|
|
}
|
|
|
|
Map<String, dynamic> _normalizeDraftSnapshot(Map<String, dynamic> snapshot) {
|
|
final normalized = Map<String, dynamic>.from(snapshot);
|
|
normalized.remove('saved_at');
|
|
return normalized;
|
|
}
|
|
|
|
bool _formIsEmpty() {
|
|
return _startController.text.trim().isEmpty &&
|
|
_endController.text.trim().isEmpty &&
|
|
_headcodeController.text.trim().isEmpty &&
|
|
_notesController.text.trim().isEmpty &&
|
|
_networkController.text.trim().isEmpty &&
|
|
_mileageController.text.trim().isEmpty &&
|
|
_routeResult == null &&
|
|
_tractionItems.length <= 1;
|
|
}
|
|
|
|
Future<_ExitChoice> _promptSaveDraft() async {
|
|
if (!mounted) return _ExitChoice.cancel;
|
|
final result = await showDialog<_ExitChoice>(
|
|
context: context,
|
|
barrierDismissible: false,
|
|
useRootNavigator: false,
|
|
builder: (_) => AlertDialog(
|
|
title: const Text('Save draft?'),
|
|
content:
|
|
const Text('Do you want to save this entry as a draft before leaving?'),
|
|
actions: [
|
|
TextButton(
|
|
onPressed: () => Navigator.of(context).pop(_ExitChoice.discard),
|
|
child: const Text('No'),
|
|
),
|
|
TextButton(
|
|
onPressed: () => Navigator.of(context).pop(_ExitChoice.save),
|
|
child: const Text('Yes'),
|
|
),
|
|
TextButton(
|
|
onPressed: () => Navigator.of(context).pop(_ExitChoice.cancel),
|
|
child: const Text('Cancel'),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
return result ?? _ExitChoice.cancel;
|
|
}
|
|
|
|
Future<void> _openDrafts() async {
|
|
final selected = await Navigator.of(context).push<_StoredDraft>(
|
|
MaterialPageRoute(
|
|
builder: (_) => _DraftListPage(
|
|
loadDrafts: _loadSavedDrafts,
|
|
onDeleteDraft: _deleteDraft,
|
|
),
|
|
),
|
|
);
|
|
if (selected != null) {
|
|
_activeDraftId = selected.id;
|
|
await _loadDraftEntry(selected.data);
|
|
}
|
|
}
|
|
|
|
Future<bool> _validateRequiredFields() async {
|
|
final missing = <String>[];
|
|
|
|
if (_useManualMileage) {
|
|
if (_startController.text.trim().isEmpty) missing.add('From');
|
|
if (_endController.text.trim().isEmpty) missing.add('To');
|
|
final mileageText = _mileageController.text.trim();
|
|
if (double.tryParse(mileageText) == null) {
|
|
missing.add('Mileage');
|
|
}
|
|
} else {
|
|
if (_routeResult == null || _routeResult!.calculatedRoute.isEmpty) {
|
|
missing.add('Route');
|
|
}
|
|
}
|
|
|
|
if (_networkController.text.trim().isEmpty) {
|
|
missing.add('Network');
|
|
}
|
|
|
|
if (missing.isEmpty) return true;
|
|
if (!mounted) return false;
|
|
|
|
final fieldList = missing.join(', ');
|
|
await showDialog<void>(
|
|
context: context,
|
|
builder: (_) => AlertDialog(
|
|
title: const Text('Required field missing'),
|
|
content: Text(
|
|
missing.length == 1
|
|
? 'Please fill the following field: $fieldList.'
|
|
: 'Please fill the following fields: $fieldList.',
|
|
),
|
|
actions: [
|
|
TextButton(
|
|
onPressed: () => Navigator.of(context).pop(),
|
|
child: const Text('OK'),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
return false;
|
|
}
|
|
|
|
Future<void> _submit() async {
|
|
if (!_formKey.currentState!.validate()) return;
|
|
if (!await _validateRequiredFields()) return;
|
|
final routeStations = _routeResult?.calculatedRoute ?? [];
|
|
final startVal = _useManualMileage
|
|
? _startController.text.trim()
|
|
: (routeStations.isNotEmpty ? routeStations.first : '');
|
|
final endVal = _useManualMileage
|
|
? _endController.text.trim()
|
|
: (routeStations.isNotEmpty ? routeStations.last : '');
|
|
final mileageVal = _useManualMileage
|
|
? double.tryParse(_mileageController.text.trim()) ?? 0
|
|
: (_routeResult?.distance ?? 0);
|
|
final tractionPayload = _buildTractionPayload();
|
|
final snapshot = _buildSubmissionSnapshot(
|
|
routeStations: routeStations,
|
|
startVal: startVal,
|
|
endVal: endVal,
|
|
mileageVal: mileageVal,
|
|
tractionPayload: tractionPayload,
|
|
);
|
|
if (_lastSubmittedSnapshot != null &&
|
|
_snapshotEquality.equals(_lastSubmittedSnapshot, snapshot)) {
|
|
final confirmed = await _confirmDuplicateSubmission();
|
|
if (!confirmed) return;
|
|
}
|
|
setState(() => _submitting = true);
|
|
final api = context.read<ApiService>();
|
|
final isEditingExisting = _isEditing && widget.editLegId != null;
|
|
|
|
try {
|
|
if (_useManualMileage) {
|
|
final body = {
|
|
if (isEditingExisting) "leg_id": widget.editLegId,
|
|
"leg_trip": _selectedTripId,
|
|
"leg_start": startVal,
|
|
"leg_end": endVal,
|
|
"leg_begin_time": _legDateTime.toIso8601String(),
|
|
"leg_network": _networkController.text.trim(),
|
|
"leg_distance": mileageVal,
|
|
"isKilometers": false,
|
|
"leg_notes": _notesController.text.trim(),
|
|
"leg_headcode": _headcodeController.text.trim(),
|
|
"locos": tractionPayload,
|
|
};
|
|
if (isEditingExisting) {
|
|
await api.put('/update', body);
|
|
} else {
|
|
await api.post('/add/manual', body);
|
|
}
|
|
} else {
|
|
final body = {
|
|
if (isEditingExisting) "leg_id": widget.editLegId,
|
|
"leg_trip": _selectedTripId,
|
|
"leg_begin_time": _legDateTime.toIso8601String(),
|
|
"leg_route": routeStations,
|
|
"leg_notes": _notesController.text.trim(),
|
|
"leg_headcode": _headcodeController.text.trim(),
|
|
"leg_network": _networkController.text.trim(),
|
|
"locos": tractionPayload,
|
|
};
|
|
if (isEditingExisting) {
|
|
await api.put('/update', body);
|
|
} else {
|
|
await api.post('/add', body);
|
|
}
|
|
}
|
|
if (!mounted) return;
|
|
context.read<DataService>().refreshLegs();
|
|
if (!mounted) return;
|
|
ScaffoldMessenger.of(
|
|
context,
|
|
).showSnackBar(
|
|
SnackBar(
|
|
content: Text(isEditingExisting ? 'Entry updated' : 'Entry submitted'),
|
|
),
|
|
);
|
|
_lastSubmittedSnapshot = snapshot;
|
|
_activeDraftId = null;
|
|
} catch (e) {
|
|
if (!mounted) return;
|
|
ScaffoldMessenger.of(
|
|
context,
|
|
).showSnackBar(SnackBar(content: Text('Failed to submit: $e')));
|
|
} finally {
|
|
if (mounted) setState(() => _submitting = false);
|
|
}
|
|
}
|
|
|
|
Map<String, dynamic> _buildSubmissionSnapshot({
|
|
required List<String> routeStations,
|
|
required String startVal,
|
|
required String endVal,
|
|
required double mileageVal,
|
|
required List<Map<String, dynamic>> tractionPayload,
|
|
}) {
|
|
return {
|
|
"legId": widget.editLegId,
|
|
"useManualMileage": _useManualMileage,
|
|
"tripId": _selectedTripId,
|
|
"legDateTime": _legDateTime.toIso8601String(),
|
|
"start": startVal,
|
|
"end": endVal,
|
|
"routeStations": routeStations,
|
|
"mileage": mileageVal,
|
|
"network": _networkController.text.trim(),
|
|
"notes": _notesController.text.trim(),
|
|
"headcode": _headcodeController.text.trim(),
|
|
"locos": tractionPayload,
|
|
"routeResult": _routeResult == null
|
|
? null
|
|
: {
|
|
"input_route": _routeResult!.inputRoute,
|
|
"calculated_route": _routeResult!.calculatedRoute,
|
|
"costs": _routeResult!.costs,
|
|
"distance": _routeResult!.distance,
|
|
},
|
|
};
|
|
}
|
|
|
|
Future<bool> _confirmDuplicateSubmission() async {
|
|
if (!mounted) return false;
|
|
final result = await showDialog<bool>(
|
|
context: context,
|
|
builder: (_) => AlertDialog(
|
|
title: const Text('Duplicate entry?'),
|
|
content: const Text('Entry already added, are you sure?'),
|
|
actions: [
|
|
TextButton(
|
|
onPressed: () => Navigator.of(context).pop(false),
|
|
child: const Text('Cancel'),
|
|
),
|
|
ElevatedButton(
|
|
onPressed: () => Navigator.of(context).pop(true),
|
|
child: const Text('Submit anyway'),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
return result ?? false;
|
|
}
|
|
|
|
Future<void> _resetFormState({bool clearDraft = false}) async {
|
|
_formKey.currentState?.reset();
|
|
_startController.clear();
|
|
_endController.clear();
|
|
_headcodeController.clear();
|
|
_notesController.clear();
|
|
_mileageController.clear();
|
|
_networkController.clear();
|
|
final now = DateTime.now();
|
|
setState(() {
|
|
_selectedDate = now;
|
|
_selectedTime = TimeOfDay.fromDateTime(now);
|
|
_useManualMileage = false;
|
|
_routeResult = null;
|
|
_tractionItems
|
|
..clear()
|
|
..add(_TractionItem.marker());
|
|
_selectedTripId = null;
|
|
_submitting = false;
|
|
_activeDraftId = null;
|
|
});
|
|
if (clearDraft) {
|
|
await _clearDraft();
|
|
}
|
|
}
|
|
|
|
Future<void> _saveDraft() async {
|
|
if (_restoringDraft || !_draftPersistenceEnabled) return;
|
|
final prefs = await SharedPreferences.getInstance();
|
|
final draft = {
|
|
"date": _selectedDate.toIso8601String(),
|
|
"time": {"hour": _selectedTime.hour, "minute": _selectedTime.minute},
|
|
"start": _startController.text,
|
|
"end": _endController.text,
|
|
"headcode": _headcodeController.text,
|
|
"notes": _notesController.text,
|
|
"mileage": _mileageController.text,
|
|
"network": _networkController.text,
|
|
"useManualMileage": _useManualMileage,
|
|
"selectedTripId": _selectedTripId,
|
|
"routeResult": _routeResult == null
|
|
? null
|
|
: {
|
|
"input_route": _routeResult!.inputRoute,
|
|
"calculated_route": _routeResult!.calculatedRoute,
|
|
"costs": _routeResult!.costs,
|
|
"distance": _routeResult!.distance,
|
|
},
|
|
"tractionItems": _serializeTractionItems(),
|
|
};
|
|
await prefs.setString(_draftPrefsKey, jsonEncode(draft));
|
|
}
|
|
|
|
Future<void> _clearDraft() async {
|
|
if (!_draftPersistenceEnabled) return;
|
|
final prefs = await SharedPreferences.getInstance();
|
|
await prefs.remove(_draftPrefsKey);
|
|
}
|
|
|
|
Future<List<_StoredDraft>> _loadSavedDrafts() async {
|
|
final prefs = await SharedPreferences.getInstance();
|
|
final raw = prefs.getString(_draftListPrefsKey);
|
|
if (raw == null || raw.isEmpty) return [];
|
|
try {
|
|
final decoded = jsonDecode(raw);
|
|
if (decoded is! List) return [];
|
|
return decoded
|
|
.whereType<Map>()
|
|
.map((e) => _StoredDraft.fromJson(Map<String, dynamic>.from(e)))
|
|
.toList()
|
|
..sort((a, b) => b.savedAt.compareTo(a.savedAt));
|
|
} catch (_) {
|
|
return [];
|
|
}
|
|
}
|
|
|
|
Future<void> _deleteDraft(String id) async {
|
|
final drafts = await _loadSavedDrafts();
|
|
drafts.removeWhere((d) => d.id == id);
|
|
final prefs = await SharedPreferences.getInstance();
|
|
await prefs.setString(
|
|
_draftListPrefsKey,
|
|
jsonEncode(drafts.map((e) => e.toJson()).toList()),
|
|
);
|
|
if (_activeDraftId == id) {
|
|
_activeDraftId = null;
|
|
}
|
|
}
|
|
|
|
Future<String> _saveDraftEntry({String? draftId}) async {
|
|
final id = draftId ?? DateTime.now().microsecondsSinceEpoch.toString();
|
|
final snapshot = _buildDraftSnapshot(id: id);
|
|
final drafts = await _loadSavedDrafts();
|
|
final now = DateTime.now();
|
|
final existingIndex = drafts.indexWhere((d) => d.id == id);
|
|
final newDraft = _StoredDraft(id: id, savedAt: now, data: snapshot);
|
|
if (existingIndex >= 0) {
|
|
drafts[existingIndex] = newDraft;
|
|
} else {
|
|
drafts.insert(0, newDraft);
|
|
}
|
|
final prefs = await SharedPreferences.getInstance();
|
|
await prefs.setString(
|
|
_draftListPrefsKey,
|
|
jsonEncode(drafts.map((e) => e.toJson()).toList()),
|
|
);
|
|
_activeDraftId = id;
|
|
_loadedDraftSnapshot =
|
|
_normalizeDraftSnapshot(_buildDraftSnapshot(id: id, includeTimestamp: false));
|
|
return id;
|
|
}
|
|
|
|
Map<String, dynamic> _buildDraftSnapshot({
|
|
required String id,
|
|
bool includeTimestamp = true,
|
|
}) {
|
|
final routeStations = _routeResult?.calculatedRoute ?? [];
|
|
final startVal = _useManualMileage
|
|
? _startController.text.trim()
|
|
: (routeStations.isNotEmpty ? routeStations.first : '');
|
|
final endVal = _useManualMileage
|
|
? _endController.text.trim()
|
|
: (routeStations.isNotEmpty ? routeStations.last : '');
|
|
final mileageVal = _useManualMileage
|
|
? double.tryParse(_mileageController.text.trim()) ?? 0
|
|
: (_routeResult?.distance ?? 0);
|
|
final tractionPayload = _buildTractionPayload();
|
|
final payload = _useManualMileage
|
|
? {
|
|
"leg_trip": _selectedTripId,
|
|
"leg_start": startVal,
|
|
"leg_end": endVal,
|
|
"leg_begin_time": _legDateTime.toIso8601String(),
|
|
"leg_network": _networkController.text.trim(),
|
|
"leg_distance": mileageVal,
|
|
"isKilometers": false,
|
|
"leg_notes": _notesController.text.trim(),
|
|
"leg_headcode": _headcodeController.text.trim(),
|
|
"locos": tractionPayload,
|
|
}
|
|
: {
|
|
"leg_trip": _selectedTripId,
|
|
"leg_begin_time": _legDateTime.toIso8601String(),
|
|
"leg_route": routeStations,
|
|
"leg_notes": _notesController.text.trim(),
|
|
"leg_headcode": _headcodeController.text.trim(),
|
|
"leg_network": _networkController.text.trim(),
|
|
"locos": tractionPayload,
|
|
"leg_mileage": _routeResult?.distance ?? mileageVal,
|
|
};
|
|
return {
|
|
"id": id,
|
|
if (includeTimestamp) "saved_at": DateTime.now().toIso8601String(),
|
|
"mode": _useManualMileage ? 'manual' : 'auto',
|
|
"payload": payload,
|
|
"routeResult": _routeResult == null
|
|
? null
|
|
: {
|
|
"input_route": _routeResult!.inputRoute,
|
|
"calculated_route": _routeResult!.calculatedRoute,
|
|
"costs": _routeResult!.costs,
|
|
"distance": _routeResult!.distance,
|
|
},
|
|
"tractionItems": _serializeTractionItems(),
|
|
};
|
|
}
|
|
|
|
Future<void> _loadDraftEntry(Map<String, dynamic> data) async {
|
|
if (!mounted) return;
|
|
final payloadRaw = data['payload'];
|
|
if (payloadRaw is! Map) return;
|
|
final payload = Map<String, dynamic>.from(payloadRaw);
|
|
final mode = data['mode'] as String?;
|
|
final useManual = mode == 'manual' ||
|
|
(payload.containsKey('leg_distance') && !payload.containsKey('leg_route'));
|
|
final beginStr = payload['leg_begin_time'] as String?;
|
|
final beginTime =
|
|
beginStr == null ? DateTime.now() : DateTime.tryParse(beginStr) ?? DateTime.now();
|
|
final tripRaw = payload['leg_trip'];
|
|
final tripId = tripRaw is num ? tripRaw.toInt() : null;
|
|
|
|
List<String> routeStations = [];
|
|
RouteResult? restoredRouteResult;
|
|
if (!useManual) {
|
|
if (payload['leg_route'] is List) {
|
|
routeStations = (payload['leg_route'] as List).map((e) => e.toString()).toList();
|
|
}
|
|
final rr = data['routeResult'];
|
|
if (rr is Map<String, dynamic>) {
|
|
restoredRouteResult = RouteResult(
|
|
inputRoute:
|
|
(rr['input_route'] as List?)?.map((e) => e.toString()).toList() ??
|
|
routeStations,
|
|
calculatedRoute:
|
|
(rr['calculated_route'] as List?)?.map((e) => e.toString()).toList() ??
|
|
routeStations,
|
|
costs: (rr['costs'] as List?)?.map((e) => (e as num).toDouble()).toList() ?? [],
|
|
distance: (rr['distance'] as num?)?.toDouble() ??
|
|
(payload['leg_mileage'] as num?)?.toDouble() ??
|
|
0,
|
|
);
|
|
} else if (routeStations.isNotEmpty) {
|
|
restoredRouteResult = RouteResult(
|
|
inputRoute: routeStations,
|
|
calculatedRoute: routeStations,
|
|
costs: const [],
|
|
distance: (payload['leg_mileage'] as num?)?.toDouble() ?? 0,
|
|
);
|
|
}
|
|
}
|
|
|
|
_restoringDraft = true;
|
|
setState(() {
|
|
_useManualMileage = useManual;
|
|
_selectedDate = beginTime;
|
|
_selectedTime = TimeOfDay.fromDateTime(beginTime);
|
|
_selectedTripId = tripId == null || tripId == 0 ? null : tripId;
|
|
_routeResult = restoredRouteResult;
|
|
_headcodeController.text =
|
|
(payload['leg_headcode'] as String? ?? '').toUpperCase();
|
|
_networkController.text =
|
|
(payload['leg_network'] as String? ?? '').toUpperCase();
|
|
_notesController.text = payload['leg_notes'] ?? '';
|
|
|
|
if (useManual) {
|
|
_startController.text = payload['leg_start'] ?? '';
|
|
_endController.text = payload['leg_end'] ?? '';
|
|
final miles = (payload['leg_distance'] as num?)?.toDouble();
|
|
_mileageController.text =
|
|
miles == null || miles == 0 ? '' : miles.toStringAsFixed(2);
|
|
} else {
|
|
_startController.text = routeStations.isNotEmpty ? routeStations.first : '';
|
|
_endController.text = routeStations.isNotEmpty ? routeStations.last : '';
|
|
final dist = _routeResult?.distance ?? 0;
|
|
_mileageController.text = dist == 0 ? '' : dist.toStringAsFixed(2);
|
|
}
|
|
|
|
final tractionRaw = data['tractionItems'];
|
|
if (tractionRaw is List) {
|
|
_restoreTractionItems(
|
|
List<Map<String, dynamic>>.from(tractionRaw.cast<Map>()),
|
|
);
|
|
} else {
|
|
_tractionItems
|
|
..clear()
|
|
..add(_TractionItem.marker());
|
|
}
|
|
_lastSubmittedSnapshot = null;
|
|
final idRaw = data['id'];
|
|
if (idRaw != null) {
|
|
_activeDraftId = idRaw.toString();
|
|
}
|
|
});
|
|
final baselineId =
|
|
_activeDraftId ?? data['id']?.toString() ?? DateTime.now().toString();
|
|
_loadedDraftSnapshot = _normalizeDraftSnapshot(
|
|
_buildDraftSnapshot(
|
|
id: baselineId,
|
|
includeTimestamp: false,
|
|
),
|
|
);
|
|
_restoringDraft = false;
|
|
}
|
|
|
|
Future<void> _loadDraft() async {
|
|
// legacy single draft no-op
|
|
}
|
|
|
|
List<Map<String, dynamic>> _serializeTractionItems() {
|
|
return _tractionItems
|
|
.map(
|
|
(item) => {
|
|
"isMarker": item.isMarker,
|
|
"powering": item.powering,
|
|
"loco": item.loco == null
|
|
? null
|
|
: {
|
|
"id": item.loco!.id,
|
|
"type": item.loco!.type,
|
|
"number": item.loco!.number,
|
|
"class": item.loco!.locoClass,
|
|
"name": item.loco!.name,
|
|
"operator": item.loco!.operator,
|
|
"notes": item.loco!.notes,
|
|
"evn": item.loco!.evn,
|
|
},
|
|
},
|
|
)
|
|
.toList();
|
|
}
|
|
|
|
void _restoreTractionItems(List<Map<String, dynamic>> items) {
|
|
final restored = <_TractionItem>[];
|
|
for (final item in items) {
|
|
final locoData = item['loco'] as Map<String, dynamic>?;
|
|
LocoSummary? loco;
|
|
if (locoData != null) {
|
|
loco = LocoSummary(
|
|
locoId: locoData['id'] ?? 0,
|
|
locoType: locoData['type'] ?? '',
|
|
locoNumber: locoData['number'] ?? '',
|
|
locoName: locoData['name'] ?? '',
|
|
locoClass: locoData['class'] ?? '',
|
|
locoOperator: locoData['operator'] ?? '',
|
|
locoNotes: locoData['notes'],
|
|
locoEvn: locoData['evn'],
|
|
);
|
|
}
|
|
restored.add(
|
|
_TractionItem(
|
|
loco: loco,
|
|
powering: item['powering'] ?? true,
|
|
isMarker: item['isMarker'] ?? false,
|
|
),
|
|
);
|
|
}
|
|
if (restored.where((e) => e.isMarker).isEmpty) {
|
|
restored.insert(0, _TractionItem.marker());
|
|
}
|
|
_tractionItems
|
|
..clear()
|
|
..addAll(restored);
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
Widget body;
|
|
if (_isEditing && _loadingEdit) {
|
|
body = const Center(child: CircularProgressIndicator());
|
|
} else if (_isEditing && _loadError != null) {
|
|
body = Center(child: Text(_loadError!));
|
|
} else {
|
|
final isMobile = MediaQuery.of(context).size.width < 700;
|
|
body = Form(
|
|
key: _formKey,
|
|
child: LayoutBuilder(
|
|
builder: (context, constraints) {
|
|
final twoCol = !isMobile && constraints.maxWidth > 1000;
|
|
final tractionEmpty = _tractionItems.length == 1;
|
|
final mileageEmpty = !_useManualMileage && _routeResult == null;
|
|
final balancePanels = twoCol && tractionEmpty && mileageEmpty;
|
|
final balancedHeight = balancePanels ? 165.0 : null;
|
|
|
|
final detailPanel = _section('Details', [
|
|
Row(
|
|
children: [
|
|
TextButton.icon(
|
|
style: TextButton.styleFrom(
|
|
padding: EdgeInsets.zero,
|
|
minimumSize: const Size(0, 36),
|
|
tapTargetSize: MaterialTapTargetSize.shrinkWrap,
|
|
),
|
|
onPressed: _isEditing ? null : _openDrafts,
|
|
icon: const Icon(Icons.list_alt, size: 16),
|
|
label: const Text('Drafts'),
|
|
),
|
|
const Spacer(),
|
|
TextButton.icon(
|
|
style: TextButton.styleFrom(
|
|
padding: EdgeInsets.zero,
|
|
minimumSize: const Size(0, 36),
|
|
tapTargetSize: MaterialTapTargetSize.shrinkWrap,
|
|
),
|
|
onPressed:
|
|
_submitting ? null : () => _resetFormState(clearDraft: true),
|
|
icon: const Icon(Icons.clear, size: 16),
|
|
label: const Text('Clear form'),
|
|
),
|
|
],
|
|
),
|
|
_buildTripSelector(context),
|
|
Row(
|
|
children: [
|
|
Expanded(
|
|
child: OutlinedButton.icon(
|
|
onPressed: _pickDate,
|
|
icon: const Icon(Icons.calendar_today),
|
|
label: Text(DateFormat.yMMMd().format(_selectedDate)),
|
|
),
|
|
),
|
|
const SizedBox(width: 12),
|
|
Expanded(
|
|
child: OutlinedButton.icon(
|
|
onPressed: _pickTime,
|
|
icon: const Icon(Icons.schedule),
|
|
label: Text(_selectedTime.format(context)),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
if (_useManualMileage)
|
|
Row(
|
|
children: [
|
|
Expanded(
|
|
child: TextFormField(
|
|
controller: _startController,
|
|
decoration: const InputDecoration(
|
|
labelText: 'From',
|
|
border: OutlineInputBorder(),
|
|
),
|
|
validator: (v) => !_useManualMileage
|
|
? null
|
|
: (v == null || v.isEmpty ? 'Required' : null),
|
|
),
|
|
),
|
|
const SizedBox(width: 12),
|
|
Expanded(
|
|
child: TextFormField(
|
|
controller: _endController,
|
|
decoration: const InputDecoration(
|
|
labelText: 'To',
|
|
border: OutlineInputBorder(),
|
|
),
|
|
validator: (v) => !_useManualMileage
|
|
? null
|
|
: (v == null || v.isEmpty ? 'Required' : null),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
TextFormField(
|
|
controller: _headcodeController,
|
|
textCapitalization: TextCapitalization.characters,
|
|
inputFormatters: const [_UpperCaseTextFormatter()],
|
|
decoration: const InputDecoration(
|
|
labelText: 'Headcode',
|
|
border: OutlineInputBorder(),
|
|
),
|
|
),
|
|
TextFormField(
|
|
controller: _networkController,
|
|
textCapitalization: TextCapitalization.characters,
|
|
inputFormatters: const [_UpperCaseTextFormatter()],
|
|
decoration: const InputDecoration(
|
|
labelText: 'Network',
|
|
border: OutlineInputBorder(),
|
|
),
|
|
),
|
|
TextFormField(
|
|
controller: _notesController,
|
|
maxLines: 3,
|
|
decoration: const InputDecoration(
|
|
labelText: 'Notes',
|
|
border: OutlineInputBorder(),
|
|
),
|
|
),
|
|
]);
|
|
|
|
final tractionPanel = _section('Traction', [
|
|
Align(
|
|
alignment: Alignment.centerLeft,
|
|
child: ElevatedButton.icon(
|
|
onPressed: _openTractionPicker,
|
|
icon: const Icon(Icons.search),
|
|
label: const Text('Search traction'),
|
|
),
|
|
),
|
|
_buildTractionList(),
|
|
], minHeight: balancedHeight);
|
|
|
|
final mileagePanel = _section(
|
|
'Mileage',
|
|
[
|
|
if (!_useManualMileage)
|
|
Align(
|
|
alignment: Alignment.centerLeft,
|
|
child: TextButton.icon(
|
|
style: TextButton.styleFrom(
|
|
padding: const EdgeInsets.symmetric(
|
|
horizontal: 10,
|
|
vertical: 6,
|
|
),
|
|
minimumSize: const Size(0, 32),
|
|
),
|
|
onPressed: _openCalculator,
|
|
icon: const Icon(Icons.calculate, size: 18),
|
|
label: const Text('Open mileage calculator'),
|
|
),
|
|
),
|
|
if (_useManualMileage)
|
|
TextFormField(
|
|
controller: _mileageController,
|
|
keyboardType: const TextInputType.numberWithOptions(
|
|
decimal: true,
|
|
),
|
|
decoration: const InputDecoration(
|
|
labelText: 'Mileage (mi)',
|
|
border: OutlineInputBorder(),
|
|
),
|
|
)
|
|
else if (_routeResult != null)
|
|
ListTile(
|
|
contentPadding: EdgeInsets.zero,
|
|
title: const Text('Calculated mileage'),
|
|
subtitle: Text(
|
|
'${_routeResult!.distance.toStringAsFixed(2)} mi',
|
|
),
|
|
)
|
|
else
|
|
const Padding(
|
|
padding: EdgeInsets.symmetric(vertical: 8.0),
|
|
child: Text(
|
|
'No route selected. Use the calculator to add a route.',
|
|
),
|
|
),
|
|
],
|
|
trailing: FilterChip(
|
|
label: Text(_useManualMileage ? 'Manual' : 'Automatic'),
|
|
selected: _useManualMileage,
|
|
onSelected: (val) {
|
|
setState(() => _useManualMileage = val);
|
|
_saveDraft();
|
|
},
|
|
),
|
|
minHeight: balancedHeight,
|
|
);
|
|
|
|
return SingleChildScrollView(
|
|
padding: const EdgeInsets.all(16),
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.stretch,
|
|
children: [
|
|
detailPanel,
|
|
const SizedBox(height: 16),
|
|
twoCol
|
|
? Row(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Expanded(child: tractionPanel),
|
|
const SizedBox(width: 16),
|
|
Expanded(child: mileagePanel),
|
|
],
|
|
)
|
|
: Column(
|
|
children: [
|
|
tractionPanel,
|
|
const SizedBox(height: 16),
|
|
mileagePanel,
|
|
],
|
|
),
|
|
const SizedBox(height: 12),
|
|
ElevatedButton.icon(
|
|
onPressed: _submitting ? null : _submit,
|
|
icon: _submitting
|
|
? const SizedBox(
|
|
height: 16,
|
|
width: 16,
|
|
child: CircularProgressIndicator(strokeWidth: 2),
|
|
)
|
|
: const Icon(Icons.send),
|
|
label: Text(
|
|
_submitting
|
|
? (_isEditing ? 'Saving...' : 'Submitting...')
|
|
: (_isEditing ? 'Save changes' : 'Submit entry'),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
return WillPopScope(
|
|
onWillPop: () => _handleExitIntent(),
|
|
child: Scaffold(
|
|
appBar: _isEditing
|
|
? AppBar(
|
|
leading: IconButton(
|
|
icon: const Icon(Icons.arrow_back),
|
|
onPressed: () async {
|
|
if (!await _handleExitIntent()) return;
|
|
if (!mounted) return;
|
|
Navigator.of(context).maybePop();
|
|
},
|
|
),
|
|
title: const Text('Edit entry'),
|
|
)
|
|
: null,
|
|
body: body,
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _buildTractionList() {
|
|
if (_tractionItems.length == 1) {
|
|
return const Padding(
|
|
padding: EdgeInsets.symmetric(vertical: 8.0),
|
|
child: Text('No traction selected yet.'),
|
|
);
|
|
}
|
|
return ReorderableListView.builder(
|
|
shrinkWrap: true,
|
|
physics: const NeverScrollableScrollPhysics(),
|
|
buildDefaultDragHandles: false,
|
|
onReorder: (oldIndex, newIndex) {
|
|
if (newIndex > oldIndex) newIndex -= 1;
|
|
setState(() {
|
|
final item = _tractionItems.removeAt(oldIndex);
|
|
_tractionItems.insert(newIndex, item);
|
|
});
|
|
_saveDraft();
|
|
},
|
|
itemCount: _tractionItems.length,
|
|
itemBuilder: (context, index) {
|
|
final item = _tractionItems[index];
|
|
if (item.isMarker) {
|
|
return Card(
|
|
key: const ValueKey('marker'),
|
|
color: Theme.of(context).colorScheme.surfaceContainerHighest,
|
|
child: const ListTile(
|
|
leading: Icon(Icons.train),
|
|
title: Text('Rolling stock marker'),
|
|
subtitle: Text(
|
|
'Place locomotives above/below. Positions set relative to this.',
|
|
),
|
|
),
|
|
);
|
|
}
|
|
final loco = item.loco!;
|
|
final markerIndex = _tractionItems.indexWhere(
|
|
(element) => element.isMarker,
|
|
);
|
|
final pos = index > markerIndex
|
|
? -(index - markerIndex)
|
|
: (markerIndex - 1) - index;
|
|
return Card(
|
|
key: ValueKey('${loco.locoClass}-${loco.number}-$index'),
|
|
child: ListTile(
|
|
leading: ReorderableDragStartListener(
|
|
index: index,
|
|
child: const Icon(Icons.drag_indicator),
|
|
),
|
|
title: Text('${loco.locoClass} ${loco.number}'),
|
|
subtitle: Text('${loco.name ?? ''} · Position $pos'),
|
|
trailing: Row(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
const Text('Powering'),
|
|
Switch(
|
|
value: item.powering,
|
|
onChanged: (v) {
|
|
setState(() {
|
|
_tractionItems[index] = item.copyWith(powering: v);
|
|
});
|
|
_saveDraft();
|
|
},
|
|
),
|
|
IconButton(
|
|
icon: const Icon(Icons.delete),
|
|
onPressed: () {
|
|
setState(() {
|
|
_tractionItems.removeAt(index);
|
|
});
|
|
_saveDraft();
|
|
},
|
|
),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
},
|
|
);
|
|
}
|
|
|
|
Widget _section(
|
|
String title,
|
|
List<Widget> children, {
|
|
Widget? trailing,
|
|
double? minHeight,
|
|
}) {
|
|
Widget card = Card(
|
|
child: Padding(
|
|
padding: const EdgeInsets.all(12.0),
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.stretch,
|
|
children: [
|
|
Row(
|
|
mainAxisAlignment: MainAxisAlignment.spaceBetween,
|
|
children: [
|
|
Text(
|
|
title,
|
|
style: Theme.of(context).textTheme.titleMedium?.copyWith(
|
|
fontWeight: FontWeight.bold,
|
|
),
|
|
),
|
|
if (trailing != null) trailing,
|
|
],
|
|
),
|
|
const SizedBox(height: 8),
|
|
...children.map(
|
|
(w) => Padding(
|
|
padding: const EdgeInsets.symmetric(vertical: 6),
|
|
child: w,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
|
|
if (minHeight != null) {
|
|
card = ConstrainedBox(
|
|
constraints: BoxConstraints(minHeight: minHeight),
|
|
child: card,
|
|
);
|
|
}
|
|
|
|
return card;
|
|
}
|
|
}
|
|
|
|
class _UpperCaseTextFormatter extends TextInputFormatter {
|
|
const _UpperCaseTextFormatter();
|
|
|
|
@override
|
|
TextEditingValue formatEditUpdate(
|
|
TextEditingValue oldValue,
|
|
TextEditingValue newValue,
|
|
) {
|
|
return newValue.copyWith(
|
|
text: newValue.text.toUpperCase(),
|
|
selection: newValue.selection,
|
|
);
|
|
}
|
|
}
|
|
|
|
enum _ExitChoice { save, discard, cancel }
|
|
|
|
class _StoredDraft {
|
|
final String id;
|
|
final DateTime savedAt;
|
|
final Map<String, dynamic> data;
|
|
|
|
_StoredDraft({
|
|
required this.id,
|
|
required this.savedAt,
|
|
required this.data,
|
|
});
|
|
|
|
factory _StoredDraft.fromJson(Map<String, dynamic> json) {
|
|
final savedAt = DateTime.tryParse(json['saved_at'] ?? '') ?? DateTime.now();
|
|
final data = Map<String, dynamic>.from(json['data'] as Map? ?? {});
|
|
final embeddedId = data['id']?.toString();
|
|
return _StoredDraft(
|
|
id: json['id']?.toString() ??
|
|
embeddedId ??
|
|
savedAt.microsecondsSinceEpoch.toString(),
|
|
savedAt: savedAt,
|
|
data: data,
|
|
);
|
|
}
|
|
|
|
Map<String, dynamic> toJson() {
|
|
return {
|
|
"id": id,
|
|
"saved_at": savedAt.toIso8601String(),
|
|
"data": data,
|
|
};
|
|
}
|
|
}
|
|
|
|
class _DraftListPage extends StatelessWidget {
|
|
const _DraftListPage({required this.loadDrafts, required this.onDeleteDraft});
|
|
final Future<List<_StoredDraft>> Function() loadDrafts;
|
|
final Future<void> Function(String id) onDeleteDraft;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Scaffold(
|
|
appBar: AppBar(title: const Text('Drafts')),
|
|
body: FutureBuilder<List<_StoredDraft>>(
|
|
future: loadDrafts(),
|
|
builder: (context, snapshot) {
|
|
if (snapshot.connectionState == ConnectionState.waiting) {
|
|
return const Center(child: CircularProgressIndicator());
|
|
}
|
|
final drafts = snapshot.data ?? const [];
|
|
if (drafts.isEmpty) {
|
|
return const Center(child: Text('No drafts saved yet.'));
|
|
}
|
|
return _DraftListBody(
|
|
drafts: drafts,
|
|
onDelete: onDeleteDraft,
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _DraftListBody extends StatefulWidget {
|
|
const _DraftListBody({required this.drafts, required this.onDelete});
|
|
final List<_StoredDraft> drafts;
|
|
final Future<void> Function(String id) onDelete;
|
|
|
|
@override
|
|
State<_DraftListBody> createState() => _DraftListBodyState();
|
|
}
|
|
|
|
class _DraftListBodyState extends State<_DraftListBody> {
|
|
late List<_StoredDraft> _drafts = widget.drafts;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return ListView.separated(
|
|
itemCount: _drafts.length,
|
|
separatorBuilder: (_, __) => const Divider(height: 0),
|
|
itemBuilder: (context, index) {
|
|
final draft = _drafts[index];
|
|
final routeLine = _draftSubtitle(draft);
|
|
final metaLine = _draftMetaLine(draft);
|
|
return ListTile(
|
|
title: Text(DateFormat.yMMMd().add_jm().format(draft.savedAt)),
|
|
subtitle: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
if (routeLine != null) Text(routeLine),
|
|
if (metaLine.isNotEmpty) Text(metaLine),
|
|
],
|
|
),
|
|
trailing: Row(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
IconButton(
|
|
tooltip: 'Delete draft',
|
|
icon: const Icon(Icons.delete),
|
|
onPressed: () => _confirmDelete(context, draft),
|
|
),
|
|
const Icon(Icons.chevron_right),
|
|
],
|
|
),
|
|
onTap: () => Navigator.of(context).pop(draft),
|
|
);
|
|
},
|
|
);
|
|
}
|
|
|
|
Future<void> _confirmDelete(BuildContext context, _StoredDraft draft) async {
|
|
final confirmed = await showDialog<bool>(
|
|
context: context,
|
|
builder: (_) => AlertDialog(
|
|
title: const Text('Delete draft?'),
|
|
content: const Text('This draft will be removed permanently.'),
|
|
actions: [
|
|
TextButton(
|
|
onPressed: () => Navigator.of(context).pop(false),
|
|
child: const Text('Cancel'),
|
|
),
|
|
TextButton(
|
|
onPressed: () => Navigator.of(context).pop(true),
|
|
child: const Text('Delete'),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
if (confirmed != true) return;
|
|
await widget.onDelete(draft.id);
|
|
if (!mounted) return;
|
|
setState(() {
|
|
_drafts.removeWhere((d) => d.id == draft.id);
|
|
});
|
|
}
|
|
|
|
String? _draftSubtitle(_StoredDraft draft) {
|
|
final payload = draft.data['payload'];
|
|
if (payload is! Map) return null;
|
|
final map = Map<String, dynamic>.from(payload);
|
|
String start = map['leg_start']?.toString() ?? '';
|
|
String end = map['leg_end']?.toString() ?? '';
|
|
if (start.isEmpty && end.isEmpty) {
|
|
if (map['leg_route'] is List && (map['leg_route'] as List).isNotEmpty) {
|
|
start = (map['leg_route'] as List).first.toString();
|
|
end = (map['leg_route'] as List).last.toString();
|
|
}
|
|
}
|
|
if (start.isEmpty && end.isEmpty) return null;
|
|
if (start.isNotEmpty && end.isNotEmpty) {
|
|
return '$start → $end';
|
|
}
|
|
return start.isNotEmpty ? start : end;
|
|
}
|
|
|
|
String _draftMetaLine(_StoredDraft draft) {
|
|
final payload = draft.data['payload'];
|
|
if (payload is! Map) return '';
|
|
final map = Map<String, dynamic>.from(payload);
|
|
final parts = <String>[];
|
|
if ((map['leg_trip'] as int? ?? 0) != 0) {
|
|
parts.add('Trip ${map['leg_trip']}');
|
|
}
|
|
final headcode = (map['leg_headcode'] as String? ?? '').trim();
|
|
if (headcode.isNotEmpty) parts.add('Headcode $headcode');
|
|
final network = (map['leg_network'] as String? ?? '').trim();
|
|
if (network.isNotEmpty) parts.add('Network $network');
|
|
final notes = (map['leg_notes'] as String? ?? '').trim();
|
|
if (notes.isNotEmpty) parts.add('Notes');
|
|
final mileage = (map['leg_distance'] as num?)?.toDouble() ??
|
|
(map['leg_mileage'] as num?)?.toDouble();
|
|
if (mileage != null && mileage > 0) {
|
|
parts.add('${mileage.toStringAsFixed(1)} mi');
|
|
} else if (map['leg_route'] is List && (map['leg_route'] as List).isNotEmpty) {
|
|
parts.add('Route ${(map['leg_route'] as List).length} stops');
|
|
}
|
|
final locos = map['locos'];
|
|
if (locos is List && locos.isNotEmpty) {
|
|
parts.add('${locos.length} traction');
|
|
}
|
|
return parts.join(' • ');
|
|
}
|
|
}
|
|
|
|
class _CalculatorPickerPage extends StatelessWidget {
|
|
const _CalculatorPickerPage({required this.onResult});
|
|
final ValueChanged<RouteResult> onResult;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Scaffold(
|
|
appBar: AppBar(
|
|
leading: IconButton(
|
|
icon: const Icon(Icons.arrow_back),
|
|
onPressed: () => Navigator.of(context).pop(),
|
|
),
|
|
title: const Text('Mileage calculator'),
|
|
),
|
|
body: RouteCalculator(onApplyRoute: onResult),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _TractionItem {
|
|
final LocoSummary? loco;
|
|
final bool powering;
|
|
final bool isMarker;
|
|
|
|
_TractionItem({
|
|
required this.loco,
|
|
this.powering = true,
|
|
this.isMarker = false,
|
|
});
|
|
|
|
factory _TractionItem.marker() =>
|
|
_TractionItem(loco: null, powering: false, isMarker: true);
|
|
|
|
_TractionItem copyWith({LocoSummary? loco, bool? powering, bool? isMarker}) {
|
|
return _TractionItem(
|
|
loco: loco ?? this.loco,
|
|
powering: powering ?? this.powering,
|
|
isMarker: isMarker ?? this.isMarker,
|
|
);
|
|
}
|
|
}
|