class LenormandReading {
  final String source;
  final String label;
  final String text;
  final int? left;
  final int? right;

  const LenormandReading({
    required this.source,
    required this.label,
    required this.text,
    this.left,
    this.right,
  });

  factory LenormandReading.fromMap(Map<String, dynamic> map) {
    return LenormandReading(
      source: map['source'] as String? ?? '',
      label: map['label'] as String? ?? '',
      text: map['text'] as String? ?? '',
      left: (map['left'] as num?)?.toInt(),
      right: (map['right'] as num?)?.toInt(),
    );
  }
}

class LenormandPairLink {
  final int n;
  final String id;
  final String name;
  final String symbol;
  final String preview;
  final String text;
  final List<LenormandReading> readings;

  const LenormandPairLink({
    required this.n,
    required this.id,
    required this.name,
    required this.symbol,
    required this.preview,
    this.text = '',
    required this.readings,
  });

  String get displayText {
    if (text.trim().isNotEmpty) return text.trim();
    if (preview.trim().isNotEmpty) return preview.trim();
    return readings.map((r) => r.text).where((t) => t.trim().isNotEmpty).join('\n\n');
  }

  factory LenormandPairLink.fromMap(Map<String, dynamic> map) {
    final raw = map['readings'];
    return LenormandPairLink(
      n: (map['n'] as num?)?.toInt() ?? 0,
      id: map['id'] as String? ?? '',
      name: map['name'] as String? ?? '',
      symbol: map['symbol'] as String? ?? '',
      preview: map['preview'] as String? ?? '',
      text: map['text'] as String? ?? '',
      readings: raw is List
          ? raw
              .whereType<Map<String, dynamic>>()
              .map(LenormandReading.fromMap)
              .toList()
          : const [],
    );
  }
}

class LenormandCardEntry {
  final int n;
  final String id;
  final String name;
  final String symbol;
  final String lore;
  final String group;
  final String meaning;
  final String shadow;
  final List<LenormandReading> meanings;
  final List<LenormandPairLink> pairs;

  const LenormandCardEntry({
    required this.n,
    required this.id,
    required this.name,
    required this.symbol,
    required this.lore,
    required this.group,
    this.meaning = '',
    this.shadow = '',
    required this.meanings,
    required this.pairs,
  });

  String get displayMeaning {
    if (meaning.trim().isNotEmpty) return meaning.trim();
    return meanings.map((m) => m.text).where((t) => t.trim().isNotEmpty).join('\n\n');
  }

  factory LenormandCardEntry.fromMap(Map<String, dynamic> map) {
    return LenormandCardEntry(
      n: (map['n'] as num?)?.toInt() ?? 0,
      id: map['id'] as String? ?? '',
      name: map['name'] as String? ?? '',
      symbol: map['symbol'] as String? ?? '',
      lore: map['lore'] as String? ?? '',
      group: map['group'] as String? ?? '',
      meaning: map['meaning'] as String? ?? '',
      shadow: map['shadow'] as String? ?? '',
      meanings: (map['meanings'] as List? ?? const [])
          .whereType<Map<String, dynamic>>()
          .map(LenormandReading.fromMap)
          .toList(),
      pairs: (map['pairs'] as List? ?? const [])
          .whereType<Map<String, dynamic>>()
          .map(LenormandPairLink.fromMap)
          .toList(),
    );
  }
}

class LenormandTriad {
  final List<int> cards;
  final List<String> names;
  final String text;

  const LenormandTriad({
    required this.cards,
    required this.names,
    required this.text,
  });

  factory LenormandTriad.fromMap(Map<String, dynamic> map) {
    return LenormandTriad(
      cards: (map['cards'] as List? ?? const [])
          .map((e) => (e as num).toInt())
          .toList(),
      names: (map['names'] as List? ?? const []).map((e) => '$e').toList(),
      text: map['text'] as String? ?? '',
    );
  }
}

class LenormandExtra {
  final String source;
  final String title;
  final String text;

  const LenormandExtra({
    required this.source,
    required this.title,
    required this.text,
  });

  factory LenormandExtra.fromMap(Map<String, dynamic> map) {
    return LenormandExtra(
      source: map['source'] as String? ?? '',
      title: map['title'] as String? ?? '',
      text: map['text'] as String? ?? '',
    );
  }
}