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 = [];
  List<String> _networks = [];
  List<String> _countries = [];
  List<String> _selectedNetworks = [];
  List<String> _selectedCountries = [];
  bool _loadingStations = false;

  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>();
        await data.fetchStationFilters();
        if (!mounted) return;
        setState(() {
          _networks = data.stationNetworks;
          _countries = data.stationCountryNetworks.keys.toList();
        });
        await _loadStations();
      });
    }
  }

  Future<void> _loadStations() async {
    setState(() => _loadingStations = true);
    final data = context.read<DataService>();
    final stations = await data.fetchStations(
      countries: _selectedCountries,
      networks: _selectedNetworks,
    );
    if (!mounted) return;
    setState(() {
      allStations = stations;
      _loadingStations = false;
    });
  }

  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: [
        Padding(
          padding: const EdgeInsets.symmetric(horizontal: 16.0, vertical: 8),
          child: Wrap(
            spacing: 12,
            runSpacing: 12,
            crossAxisAlignment: WrapCrossAlignment.center,
            children: [
              _MultiSelectFilter(
                label: 'Countries',
                options: _countries,
                selected: _selectedCountries,
                onChanged: (vals) {
                  setState(() => _selectedCountries = vals);
                  _loadStations();
                },
              ),
              _MultiSelectFilter(
                label: 'Networks',
                options: _networks,
                selected: _selectedNetworks,
                onChanged: (vals) {
                  setState(() => _selectedNetworks = vals);
                  _loadStations();
                },
              ),
              if (_loadingStations)
                const Padding(
                  padding: EdgeInsets.only(left: 8.0),
                  child: SizedBox(
                    height: 20,
                    width: 20,
                    child: CircularProgressIndicator(strokeWidth: 2),
                  ),
                ),
            ],
          ),
        ),
        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),
        Padding(
          padding: const EdgeInsets.symmetric(horizontal: 16.0),
          child: Wrap(
            alignment: WrapAlignment.center,
            spacing: 12,
            runSpacing: 8,
            children: [
              ElevatedButton.icon(
                icon: const Icon(Icons.add),
                label: const Text('Add Station'),
                onPressed: _addStation,
              ),
              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))),
      ],
    ),
  );
}

class _MultiSelectFilter extends StatefulWidget {
  const _MultiSelectFilter({
    required this.label,
    required this.options,
    required this.selected,
    required this.onChanged,
  });

  final String label;
  final List<String> options;
  final List<String> selected;
  final ValueChanged<List<String>> onChanged;

  @override
  State<_MultiSelectFilter> createState() => _MultiSelectFilterState();
}

class _MultiSelectFilterState extends State<_MultiSelectFilter> {
  late List<String> _tempSelected;
  String _query = '';

  @override
  void initState() {
    super.initState();
    _tempSelected = List.from(widget.selected);
  }

  @override
  void didUpdateWidget(covariant _MultiSelectFilter oldWidget) {
    super.didUpdateWidget(oldWidget);
    if (oldWidget.selected != widget.selected) {
      _tempSelected = List.from(widget.selected);
    }
  }

  void _openPicker() async {
    _tempSelected = List.from(widget.selected);
    _query = '';
    await showModalBottomSheet<void>(
      context: context,
      isScrollControlled: true,
      builder: (ctx) {
        return StatefulBuilder(
          builder: (ctx, setModalState) {
            final filtered = widget.options
                .where((opt) =>
                    _query.isEmpty || opt.toLowerCase().contains(_query.toLowerCase()))
                .toList();
            return SafeArea(
              child: Padding(
                padding: const EdgeInsets.all(16.0),
                child: Column(
                  mainAxisSize: MainAxisSize.min,
                  crossAxisAlignment: CrossAxisAlignment.start,
                  children: [
                    Row(
                      children: [
                        Text(
                          'Select ${widget.label.toLowerCase()}',
                          style: Theme.of(context).textTheme.titleMedium?.copyWith(
                                fontWeight: FontWeight.w700,
                              ),
                        ),
                        const Spacer(),
                        TextButton(
                          onPressed: () {
                            setModalState(() {
                              _tempSelected.clear();
                            });
                            Navigator.of(ctx).pop();
                            widget.onChanged(const []);
                          },
                          child: const Text('Clear'),
                        ),
                      ],
                    ),
                    const SizedBox(height: 8),
                    TextField(
                      decoration: const InputDecoration(
                        labelText: 'Search',
                        border: OutlineInputBorder(),
                      ),
                      onChanged: (val) {
                        setModalState(() {
                          _query = val;
                        });
                      },
                    ),
                    const SizedBox(height: 12),
                    SizedBox(
                      height: 320,
                      child: ListView.builder(
                        itemCount: filtered.length,
                        itemBuilder: (_, index) {
                          final option = filtered[index];
                          final selected = _tempSelected.contains(option);
                          return CheckboxListTile(
                            value: selected,
                            title: Text(option),
                            onChanged: (val) {
                              setModalState(() {
                                if (val == true) {
                                  if (!_tempSelected.contains(option)) {
                                    _tempSelected.add(option);
                                  }
                                } else {
                                  _tempSelected.removeWhere((e) => e == option);
                                }
                              });
                              widget.onChanged(List.from(_tempSelected.toSet()));
                            },
                          );
                        },
                      ),
                    ),
                    const SizedBox(height: 12),
                    Align(
                      alignment: Alignment.centerRight,
                      child: FilledButton.icon(
                        onPressed: () {
                          widget.onChanged(List.from(_tempSelected.toSet()));
                          Navigator.of(ctx).pop();
                        },
                        icon: const Icon(Icons.check),
                        label: const Text('Apply'),
                      ),
                    ),
                  ],
                ),
              ),
            );
          },
        );
      },
    );
  }

  @override
  Widget build(BuildContext context) {
    final hasSelection = widget.selected.isNotEmpty;
    final display =
        hasSelection ? widget.selected.join(', ') : 'Any ${widget.label.toLowerCase()}';
    return OutlinedButton.icon(
      onPressed: _openPicker,
      icon: const Icon(Icons.filter_alt),
      label: SizedBox(
        width: 180,
        child: Text(
          '${widget.label}: $display',
          overflow: TextOverflow.ellipsis,
        ),
      ),
    );
  }
}