Skip to content

Offline gym log for Android. No account, no ads, no internet.

8.9 KB
Raw Blame
import '../catalog/exercise_aliases.dart';
import '../catalog/exercise_catalog.dart' show kFilterMuscles;
import '../models/exercise.dart';

const _stop = {'the', 'a', 'an', 'with', 'on', 'to', 'and', 'or', 'in', 'for', 'v', 'var'};

const _syn = {
  'lat': 'lateral', 'lats': 'lateral',
  'bicep': 'biceps', 'bicepts': 'biceps',
  'tricep': 'triceps', 'tricepts': 'triceps',
  'db': 'dumbbell', 'bb': 'barbell', 'kb': 'kettlebell', 'bw': 'bodyweight',
  'dumbell': 'dumbbell', 'dumbells': 'dumbbell', 'dumbbells': 'dumbbell',
  'barbells': 'barbell', 'cables': 'cable', 'machines': 'machine', 'bands': 'band',
  'ohp': 'overhead press',
  'pushup': 'push up', 'pushups': 'push up', 'pullup': 'pull up', 'pullups': 'pull up',
  'chinup': 'chin up', 'chinups': 'chin up', 'situp': 'sit up', 'situps': 'sit up',
  'curls': 'curl', 'rows': 'row', 'presses': 'press',
  'ups': 'up', 'downs': 'down', 'climbers': 'climber', 'crushers': 'crusher',
  'squats': 'squat', 'raises': 'raise', 'extensions': 'extension',
  'flyes': 'fly', 'flies': 'fly', 'flys': 'fly',
  'deadlifts': 'deadlift', 'lunges': 'lunge', 'dips': 'dip', 'pulldowns': 'pulldown',
  'calves': 'calf', 'calve': 'calf', 'legs': 'leg', 'arms': 'arm', 'abs': 'abdominal', 'delts': 'deltoid',
  'lever': 'machine', 'smith': 'machine', 'skullcrusher': 'lying triceps extension',
  'skullcrushers': 'lying triceps extension',
  'rdl': 'romanian deadlift', 'sldl': 'stiff leg deadlift',
};

const _equipment = {
  'barbell', 'dumbbell', 'cable', 'machine', 'smith', 'kettlebell', 'band',
  'bodyweight', 'lever', 'sled', 'weighted', 'assisted', 'ez',
};

List<String> nameTokens(String raw) {
  final flat = raw
      .toLowerCase()
      .replaceAll(RegExp(r'[àáâãä]'), 'a')
      .replaceAll(RegExp(r'[èéêë]'), 'e')
      .replaceAll(RegExp(r'[ìíîï]'), 'i')
      .replaceAll(RegExp(r'[òóôõö]'), 'o')
      .replaceAll(RegExp(r'[ùúûü]'), 'u')
      .replaceAll('ñ', 'n');
  final out = <String>[];
  for (final part in flat.split(RegExp(r'[^a-z0-9]+'))) {
    if (part.isEmpty || _stop.contains(part)) continue;
    final mapped = _syn[part] ?? part;
    out.addAll(mapped.split(' '));
  }
  return out;
}

String searchKey(String raw) => nameTokens(raw).join(' ');

String sortedKey(String raw) => (nameTokens(raw)..sort()).join(' ');

final Map<String, String> _keyCache = {};

String _keyOf(String name) => _keyCache.putIfAbsent(name, () => searchKey(name));

String _stem(String w) => w.length > 3 && w.endsWith('s') && !w.endsWith('ss') ? w.substring(0, w.length - 1) : w;

final Map<String, List<String>> _wordCache = {};

List<String> _wordsOf(String name) =>
    _wordCache.putIfAbsent(name, () => [for (final w in nameTokens(name)) _stem(w)]);

bool _hasWords(List<String> query, String name) {
  final words = _wordsOf(name);
  return query.every((q) => words.any((w) => w.startsWith(q)));
}

String _fold(String raw) => nameTokens(raw).join(' ');

final Map<String, String> _aliasIndex = {
  for (final entry in kExerciseAliases.entries)
    for (final alias in entry.value) sortedKey(alias): entry.key,
};

typedef ExerciseFilter = bool Function(Exercise);

ExerciseFilter exerciseSearch(String query) {
  final plain = query.trim().toLowerCase();
  if (plain.isEmpty) return (_) => true;
  final key = searchKey(query);
  final words = [for (final w in key.split(' ')) if (w.isNotEmpty) _stem(w)];
  final folded = _fold(query);
  final muscles = {
    for (final m in kFilterMuscles)
      if (folded.length > 2 && (_fold(muscleLabel(m)).startsWith(folded) || _fold(m).startsWith(folded))) m,
  };

  return (e) {
    if (muscles.contains(e.primary)) return true;
    final label = exerciseName(e);
    if (e.name.toLowerCase().contains(plain) || label.toLowerCase().contains(plain)) return true;
    if (e.aliases.any((a) => a.toLowerCase().contains(plain))) return true;
    if (key.isEmpty) return false;
    if (_keyOf(e.name).contains(key) || _keyOf(label).contains(key)) return true;
    if (e.aliases.any((a) => _keyOf(a).contains(key))) return true;
    if (kExerciseAliases[e.name]?.any((a) => _keyOf(a).contains(key)) ?? false) return true;
    if (words.isEmpty) return false;
    return _hasWords(words, e.name) || _hasWords(words, label) || e.aliases.any((a) => _hasWords(words, a));
  };
}

bool _sameEquipment(Set<String> q, Set<String> c) {
  final qe = q.intersection(_equipment);
  final ce = c.intersection(_equipment);
  if (qe.isEmpty || ce.isEmpty) return true;
  return qe.intersection(ce).isNotEmpty;
}

const _modifiers = {
  'one', 'single', 'arm', 'seated', 'sitted', 'standing', 'lying', 'alternate', 'alternating',
  'wide', 'close', 'narrow', 'grip', 'straight', 'bent', 'over', 'both', 'two', 'double', 'hand',
};

bool _fits(Set<String> qCore, Set<String> q, Set<String> c) {
  if (qCore.isNotEmpty && c.containsAll(qCore)) return true;
  final cMeaning = c.difference(_equipment);
  return cMeaning.length >= 2 && cMeaning.difference(_modifiers).isNotEmpty && q.containsAll(cMeaning);
}

const _legs = {'quads', 'glutes', 'hamstrings', 'calves'};

bool _sameMuscle(String? hint, Exercise e) =>
    hint == null ||
    e.primary == hint ||
    e.secondary.contains(hint) ||
    (_legs.contains(hint) && _legs.contains(e.primary)) ||
    (hint == 'lowerback' && (e.primary == 'hamstrings' || e.primary == 'glutes'));

int _score(Set<String> q, Set<String> c) {
  final shared = q.intersection(c);
  if (shared.difference(_equipment).isEmpty) return 0;
  return shared.length * 3 - c.difference(q).length - q.difference(c).length;
}

const _muscleHints = <List<String>, String>{
  ['hyperextension', 'back extension', 'superman', 'lower back', 'erector', 'deadlift']: 'lowerback',
  ['calf', 'calves', 'soleus']: 'calves',
  ['hamstring', 'leg curl', 'good morning', 'nordic']: 'hamstrings',
  ['glute', 'hip thrust', 'bridge', 'kickback']: 'glutes',
  ['quad', 'squat', 'leg press', 'leg extension', 'lunge', 'step up', 'hack']: 'quads',
  ['oblique', 'twist', 'side bend', 'wood chop', 'russian']: 'obliques',
  ['crunch', 'sit up', 'plank', 'abdominal', 'leg raise', 'hollow', 'v up']: 'abdomen',
  ['shrug', 'trap ', 'trapezius', 'upright row']: 'trapezius',
  ['forearm', 'wrist', 'farmer', 'gripper', 'hand grip']: 'forearm',
  ['triceps', 'pushdown', 'skullcrusher', 'kickback', 'dip']: 'triceps',
  ['biceps', 'curl', 'preacher', 'chin up']: 'biceps',
  ['lateral raise', 'shoulder', 'overhead press', 'military', 'arnold', 'face pull', 'delt', 'upright']:
      'shoulders',
  ['row', 'pulldown', 'pull up', 'pullover', 'lateral pull']: 'back',
  ['bench press', 'chest', 'fly', 'pec', 'push up', 'press']: 'chest',
};

String? guessMuscle(String name) {
  final flat = ' ${nameTokens(name).join(' ')} ';
  for (final entry in _muscleHints.entries) {
    for (final needle in entry.key) {
      if (flat.contains(' $needle') || flat.contains('$needle ')) return entry.value;
    }
  }
  return null;
}

final _labelled = RegExp(r'^(.+?)\s*\(([^()]+)\)\s*$');

Exercise? matchExercise(String name, Iterable<Exercise> pool) {
  final whole = _matchExact(name, pool);
  if (whole != null) return whole;
  final parts = _labelled.firstMatch(name.trim());
  if (parts != null) {
    final outer = parts.group(1)!, inner = parts.group(2)!;
    final hit = _matchExact(outer, pool) ?? _matchExact(inner, pool);
    if (hit != null) return hit;
  }
  final loose = _matchLoose(name, pool);
  if (loose != null || parts == null) return loose;
  return matchExercise(parts.group(1)!, pool) ?? matchExercise(parts.group(2)!, pool);
}

Exercise? _matchExact(String name, Iterable<Exercise> pool) {
  final key = searchKey(name);
  if (key.isEmpty) return null;

  for (final e in pool) {
    if (_keyOf(e.name) == key) return e;
  }

  for (final e in pool) {
    if (e.aliases.any((a) => _keyOf(a) == key)) return e;
  }

  final alias = _aliasIndex[sortedKey(name)];
  if (alias != null) {
    final wanted = searchKey(alias);
    for (final e in pool) {
      if (searchKey(e.name) == wanted) return e;
    }
  }

  for (final e in pool) {
    final label = exerciseName(e);
    if (label != e.name && _keyOf(label) == key) return e;
  }
  return null;
}

Exercise? _matchLoose(String name, Iterable<Exercise> pool) {
  final key = searchKey(name);
  if (key.isEmpty) return null;
  final q = key.split(' ').toSet();
  final qMeaning = q.difference(_equipment);
  if (qMeaning.isEmpty) return null;
  final qCore = qMeaning.difference(_modifiers);
  final hint = guessMuscle(name);

  Exercise? exact;
  var exactExtra = 1 << 30;
  Exercise? loose;
  var looseScore = 0;

  for (final e in pool) {
    final c = nameTokens(e.name).toSet();
    if (c.isEmpty || !_sameEquipment(q, c) || !_sameMuscle(hint, e)) continue;
    if (c.containsAll(qMeaning)) {
      final extra = c.difference(q).length;
      if (extra < exactExtra) {
        exact = e;
        exactExtra = extra;
      }
    } else if (_fits(qCore, q, c)) {
      final s = _score(q, c);
      if (s > looseScore) {
        loose = e;
        looseScore = s;
      }
    }
  }
  return exact ?? (looseScore >= 3 ? loose : null);
}