src/bible.py

'''

Parse scriptural references and fetch source texts.

TODO:
- [ ] separate out tests
- [ ] refactor and clean up

'''

from dataclasses import dataclass
from functools import reduce
from typing import Dict, List, Optional, Tuple, Union
import re

from parsy import (
    Parser,
    alt,
    fail,
    generate,
    regex,
    seq,
    string,
    string_from,
    whitespace
)

# Verses are saved as one per line
paths = {
    'KJV': 'curated/bible/kjv_king_james_version.txt',
    'ASV': 'curated/bible/asv_american_standard_version.txt',
    'CSB': 'curated/bible/csb_christian_standard_bible.txt',
}

# KJV
#    Genesis 1:1 KJV In the beginning God created the heaven and the earth.
#    Genesis 1:2 KJV And the earth was without form, and void; and darkness was upon the face of the deep. And the Spirit of God moved upon the face of the waters.
#    Genesis 1:3 KJV And God said, Let there be light: and there was light.
#
# ASV
#    Genesis 1:1 ASV In the beginning God created the heavens and the earth.
#    Genesis 1:2 ASV And the earth was waste and void; and darkness was upon the face of the deep: and the Spirit of God moved upon the face of the waters.
#    Genesis 1:3 ASV And God said, Let there be light: and there was light.
#
# CSB
#    Genesis 1:1 CSB In the beginning God created the heavens and the earth.
#    Genesis 1:2 CSB Now the earth was formless and empty, darkness covered the surface of the watery depths, and the Spirit of God was hovering over the surface of the waters.
#    Genesis 1:3 CSB Then God said, Let there be light, and there was light.

bible_structure = [
    {
        'testament': 'OT',
        'verse_counts': [31, 25, 24, 26, 32, 22, 24, 22, 29, 32, 32, 20, 18, 24, 21, 16, 27, 33, 38, 18, 34, 24, 20, 67, 34, 35, 46, 22, 35, 43, 55, 32, 20, 31, 29, 43, 36, 30, 23, 23, 57, 38, 34, 34, 28, 34, 31, 22, 33, 26],
        'name': 'Genesis',
        'abbrs': ['gen', 'ge', 'gn']
    },
    {
        'testament': 'OT',
        'verse_counts': [22, 25, 22, 31, 23, 30, 25, 32, 35, 29, 10, 51, 22, 31, 27, 36, 16, 27, 25, 26, 36, 31, 33, 18, 40, 37, 21, 43, 46, 38, 18, 35, 23, 35, 35, 38, 29, 31, 43, 38],
        'name': 'Exodus',
        'abbrs': ['exod', 'exo', 'ex']
    },
    {
        'testament': 'OT',
        'verse_counts': [17, 16, 17, 35, 19, 30, 38, 36, 24, 20, 47, 8, 59, 57, 33, 34, 16, 30, 37, 27, 24, 33, 44, 23, 55, 46, 34],
        'name': 'Leviticus',
        'abbrs': ['lev', 'lv', 'le']
    },
    {
        'testament': 'OT',
        'verse_counts': [54, 34, 51, 49, 31, 27, 89, 26, 23, 36, 35, 16, 33, 45, 41, 50, 13, 32, 22, 29, 35, 41, 30, 25, 18, 65, 23, 31, 40, 16, 54, 42, 56, 29, 34, 13],
        'name': 'Numbers',
        'abbrs': ['num', 'nm', 'nu']
    },
    {
        'testament': 'OT',
        'verse_counts': [46, 37, 29, 49, 33, 25, 26, 20, 29, 22, 32, 32, 18, 29, 23, 22, 20, 22, 21, 20, 23, 30, 25, 22, 19, 19, 26, 68, 29, 20, 30, 52, 29, 12],
        'name': 'Deuteronomy',
        'abbrs': ['deut', 'deu', 'de', 'du', 'dt']
    },
    {
        'testament': 'OT',
        'verse_counts': [18, 24, 17, 24, 15, 27, 26, 35, 27, 43, 23, 24, 33, 15, 63, 10, 18, 28, 51, 9, 45, 34, 16, 33],
        'name': 'Joshua',
        'abbrs': ['josh', 'jos']
    },
    {
        'testament': 'OT',
        'verse_counts': [36, 23, 31, 24, 31, 40, 25, 35, 57, 18, 40, 15, 25, 20, 20, 31, 13, 31, 30, 48, 25],
        'name': 'Judges',
        'abbrs': ['judg', 'jgs', 'jdg']},
    {
        'testament': 'OT',
        'verse_counts': [22, 23, 18, 22],
        'name': 'Ruth',
        'abbrs': ['rut', 'ru']
    },
    {
        'testament': 'OT',
        'verse_counts': [28, 36, 21, 22, 12, 21, 17, 22, 27, 27, 15, 25, 23, 52, 35, 23, 58, 30, 24, 42, 15, 23, 29, 22, 44, 25, 12, 25, 11, 31, 13],
        'name': '1 Samuel',
        'abbrs': ['1samuel', '1sam', '1 sam', '1sm', '1 sm' , '1sa', '1 sa']
    },
    {
        'testament': 'OT',
        'verse_counts': [27, 32, 39, 12, 25, 23, 29, 18, 13, 19, 27, 31, 39, 33, 37, 23, 29, 33, 43, 26, 22, 51, 39, 25],
        'name': '2 Samuel',
        'abbrs': ['2samuel', '2sam', '2 sam', '2sm', '2 sm', '2sa', '2 sa']
    },
    {
        'testament': 'OT',
        'verse_counts': [53, 46, 28, 34, 18, 38, 51, 66, 28, 29, 43, 33, 34, 31, 34, 34, 24, 46, 21, 43, 29, 53],
        'name': '1 Kings',
        'abbrs': ['1kings', '1king', '1kgs', '1kg', '1 kg', '1 kgs', '1ki', '1 ki']
    },
    {
        'testament': 'OT',
        'verse_counts': [18, 25, 27, 44, 27, 33, 20, 29, 37, 36, 21, 21, 25, 29, 38, 20, 41, 37, 37, 21, 26, 20, 37, 20, 30],
        'name': '2 Kings',
        'abbrs': ['2kings', '2king' '2kg 2', 'kg', '2ki', '2 ki']},
    {
        'testament': 'OT',
        'verse_counts': [54, 55, 24, 43, 26, 81, 40, 40, 44, 14, 47, 40, 14, 17, 29, 43, 27, 17, 19, 8, 30, 19, 32, 31, 31, 32, 34, 21, 30],
        'name': '1 Chronicles',
        'abbrs': ['1chronicles', '1chron', '1 chron', '1ch', '1 ch']
    },
    {
        'testament': 'OT',
        'verse_counts': [17, 18, 17, 22, 14, 42, 22, 18, 31, 19, 23, 16, 22, 15, 19, 14, 19, 34, 11, 37, 20, 12, 21, 27, 28, 23, 9, 27, 36, 27, 21, 33, 25, 33, 27, 23],
        'name': '2 Chronicles',
        'abbrs': ['2chronicles', '2chron', '2 chron', '2 ch', '2ch']
    },
    {
        'testament': 'OT',
        'verse_counts': [11, 70, 13, 24, 17, 22, 28, 36, 15, 44],
        'name': 'Ezra',
        'abbrs': ['ezr', 'ez']
    },
    {
        'testament': 'OT',
        'verse_counts': [11, 20, 32, 23, 19, 19, 73, 18, 38, 39, 36, 47, 31],
        'name': 'Nehemiah',
        'abbrs': ['nehem', 'neh', 'ne']
    },
    {
        'testament': 'OT',
        'verse_counts': [22, 23, 15, 17, 14, 14, 10, 17, 32, 3],
        'name': 'Esther',
        'abbrs': ['esth', 'est', 'es']
    },
    {
        'testament': 'OT',
        'verse_counts': [22, 13, 26, 21, 27, 30, 21, 22, 35, 22, 20, 25, 28, 22, 35, 22, 16, 21, 29, 29, 34, 30, 17, 25, 6, 14, 23, 28, 25, 31, 40, 22, 33, 37, 16, 33, 24, 41, 30, 24, 34, 17],
        'name': 'Job',
        'abbrs': ['jb']
    },
    {
        'testament': 'OT',
        'verse_counts': [6, 12, 8, 8, 12, 10, 17, 9, 20, 18, 7, 8, 6, 7, 5, 11, 15, 50, 14, 9, 13, 31, 6, 10, 22, 12, 14, 9, 11, 12, 24, 11, 22, 22, 28, 12, 40, 22, 13, 17, 13, 11, 5, 26, 17, 11, 9, 14, 20, 23, 19, 9, 6, 7, 23, 13, 11, 11, 17, 12, 8, 12, 11, 10, 13, 20, 7, 35, 36, 5, 24, 20, 28, 23, 10, 12, 20, 72, 13, 19, 16, 8, 18, 12, 13, 17, 7, 18, 52, 17, 16, 15, 5, 23, 11, 13, 12, 9, 9, 5, 8, 28, 22, 35, 45, 48, 43, 13, 31, 7, 10, 10, 9, 8, 18, 19, 2, 29, 176, 7, 8, 9, 4, 8, 5, 6, 5, 6, 8, 8, 3, 18, 3, 3, 21, 26, 9, 8, 24, 13, 10, 7, 12, 15, 21, 10, 20, 14, 9, 6],
        'name': 'Psalms',
        'abbrs': ['psalm', 'psa', 'pss', 'ps']
    },
    {
        'testament': 'OT',
        'verse_counts': [33, 22, 35, 27, 23, 35, 27, 36, 18, 32, 31, 28, 25, 35, 33, 33, 28, 24, 29, 30, 31, 29, 35, 34, 28, 28, 27, 28, 27, 33, 31],
        'name': 'Proverbs',
        'abbrs': ['prov', 'prv', 'pv', 'pro']},
    {
        'testament': 'OT',
        'verse_counts': [18, 26, 22, 16, 20, 12, 29, 17, 18, 20, 10, 14],
        'name': 'Ecclesiastes',
        'abbrs': ['eccles', 'ecc', 'ec']
    },
    {
        'testament': 'OT',
        'verse_counts': [17, 17, 11, 16, 16, 13, 13, 14],
        'name': 'Song of Solomon',
        'abbrs': [ 'song of sol', 'song', 'son', 'sos', 'ss', 'so', 'sg']
    },
    {
        'testament': 'OT',
        'verse_counts': [31, 22, 26, 6, 30, 13, 25, 22, 21, 34, 16, 6, 22, 32, 9, 14, 14, 7, 25, 6, 17, 25, 18, 23, 12, 21, 13, 29, 24, 33, 9, 20, 24, 17, 10, 22, 38, 22, 8, 31, 29, 25, 28, 28, 25, 13, 15, 22, 26, 11, 23, 15, 12, 17, 13, 12, 21, 14, 21, 22, 11, 12, 19, 12, 25, 24],
        'name': 'Isaiah',
        'abbrs': ['isa', 'is']
    },
    {
        'testament': 'OT',
        'verse_counts': [19, 37, 25, 31, 31, 30, 34, 22, 26, 25, 23, 17, 27, 22, 21, 21, 27, 23, 15, 18, 14, 30, 40, 10, 38, 24, 22, 17, 32, 24, 40, 44, 26, 22, 19, 32, 21, 28, 18, 16, 18, 22, 13, 30, 5, 28, 7, 47, 39, 46, 64, 34],
        'name': 'Jeremiah',
        'abbrs': ['jerem', 'jer', 'je']
    },
    {
        'testament': 'OT',
        'verse_counts': [22, 22, 66, 22, 22],
        'name': 'Lamentations',
        'abbrs': ['lamen', 'lam', 'la']
    },
    {
        'testament': 'OT',
        'verse_counts': [28, 10, 27, 17, 17, 14, 27, 18, 11, 22, 25, 28, 23, 23, 8, 63, 24, 32, 14, 49, 32, 31, 49, 27, 17, 21, 36, 26, 21, 26, 18, 32, 33, 31, 15, 38, 28, 23, 29, 49, 26, 20, 27, 31, 25, 24, 23, 35],
        'name': 'Ezekiel',
        'abbrs': ['ezek', 'eze', 'ezk']
    },
    {
        'testament': 'OT',
        'verse_counts': [21, 49, 30, 37, 31, 28, 28, 27, 27, 21, 45, 13],
        'name': 'Daniel',
        'abbrs': ['dan', 'da', 'dn']
    },
    {
        'testament': 'OT',
        'verse_counts': [11, 23, 5, 19, 15, 11, 16, 14, 17, 15, 12, 14, 16, 9],
        'name': 'Hosea',
        'abbrs': ['hos', 'ho']
    },
    {
        'testament': 'OT',
        'verse_counts': [20, 32, 21],
        'name': 'Joel',
        'abbrs': ['jl', 'joe']
    },
    {
        'testament': 'OT',
        'verse_counts': [15, 16, 15, 13, 27, 14, 17, 14, 15],
        'name': 'Amos',
        'abbrs': ['am', 'amo']
    },
    {
        'testament': 'OT',
        'verse_counts': [21],
        'name': 'Obadiah',
        'abbrs': ['obad', 'ob', 'oba']
    },
    {
        'testament': 'OT',
        'verse_counts': [17, 10, 10, 11],
        'name': 'Jonah',
        'abbrs': ['jon', 'jnh']
    },
    {
        'testament': 'OT',
        'verse_counts': [16, 13, 12, 13, 15, 16, 20],
        'name': 'Micah',
        'abbrs': ['mi', 'mic']
    },
    {
        'testament': 'OT',
        'verse_counts': [15, 13, 19],
        'name': 'Nahum',
        'abbrs': ['nah', 'na']
    },
    {
        'testament': 'OT',
        'verse_counts': [17, 20, 19],
        'name': 'Habakkuk',
        'abbrs': ['hab', 'hb']
    },
    {
        'testament': 'OT',
        'verse_counts': [18, 15, 20],
        'name': 'Zephaniah',
        'abbrs': ['zeph', 'zep']
    },
    {
        'testament': 'OT',
        'verse_counts': [15, 23],
        'name': 'Haggai',
        'abbrs': ['hag', 'hg']
    },
    {
        'testament': 'OT',
        'verse_counts': [21, 13, 10, 14, 11, 15, 14, 23, 17, 12, 17, 14, 9, 21],
        'name': 'Zechariah',
        'abbrs': ['zech', 'zec']
    },
    {
        'testament': 'OT',
        'verse_counts': [14, 17, 18, 6],
        'name': 'Malachi',
        'abbrs': ['mal', 'ml']
    },
    {
        'testament': 'NT',
        'verse_counts': [25, 23, 17, 25, 48, 34, 29, 34, 38, 42, 30, 50, 58, 36, 39, 28, 27, 35, 30, 34, 46, 46, 39, 51, 46, 75, 66, 20],
        'name': 'Matthew',
        'abbrs': ['mat', 'matt', 'mt']
    },
    {
        'testament': 'NT',
        'verse_counts': [45, 28, 35, 41, 43, 56, 37, 38, 50, 52, 33, 44, 37, 72, 47, 20],
        'name': 'Mark',
        'abbrs': ['mar', 'mk']},
    {
        'testament': 'NT',
        'verse_counts': [80, 52, 38, 44, 39, 49, 50, 56, 62, 42, 54, 59, 35, 35, 32, 31, 37, 43, 48, 47, 38, 71, 56, 53],
        'name': 'Luke',
        'abbrs': ['lu', 'luk', 'lk']
    },
    {
        'testament': 'NT',
        'verse_counts': [51, 25, 36, 54, 47, 71, 53, 59, 41, 42, 57, 50, 38, 31, 27, 33, 26, 40, 42, 31, 25],
        'name': 'John',
        'abbrs': ['jo', 'joh', 'jn']
    },
    {
        'testament': 'NT',
        'verse_counts': [26, 47, 26, 37, 42, 15, 60, 40, 43, 48, 30, 25, 52, 28, 41, 40, 34, 28, 41, 38, 40, 30, 35, 27, 27, 32, 44, 31],
        'name': 'Acts',
        'abbrs': ['ac', 'act']},
    {
        'testament': 'NT',
        'verse_counts': [32, 29, 31, 25, 21, 23, 25, 39, 33, 21, 36, 21, 14, 23, 33, 27],
        'name': 'Romans',
        'abbrs': ['rom', 'ro', 'rm']
    },
    {
        'testament': 'NT',
        'verse_counts': [31, 16, 23, 21, 13, 20, 40, 13, 27, 33, 34, 31, 13, 40, 58, 24],
        'name': '1 Corinthians',
        'abbrs': ['1corinthians', '1 cor', '1cor', '1 co', '1co', '1c']
    },
    {
        'testament': 'NT',
        'verse_counts': [24, 17, 18, 18, 21, 18, 16, 24, 15, 18, 33, 21, 14],
        'name': '2 Corinthians',
        'abbrs': ['2corinthians', '2 cor', '2cor', '2 co', '2co', '2c']
    },
    {
        'testament': 'NT',
        'verse_counts': [24, 21, 29, 31, 26, 18],
        'name': 'Galatians',
        'abbrs': ['gal', 'ga']
    },
    {
        'testament': 'NT',
        'verse_counts': [23, 22, 21, 32, 33, 24],
        'name': 'Ephesians',
        'abbrs': ['eph', 'ep']
    },
    {
        'testament': 'NT',
        'verse_counts': [30, 30, 21, 23],
        'name': 'Philippians',
        'abbrs': ['phil', 'php', 'phi']
    },
    {
        'testament': 'NT',
        'verse_counts': [29, 23, 25, 18],
        'name': 'Colossians',
        'abbrs': ['col', 'co']
    },
    {
        'testament': 'NT',
        'verse_counts': [10, 20, 13, 18, 28],
        'name': '1 Thessalonians',
        'abbrs': ['1thessalonians', '1 thess', '1thess', '1 thes', '1thes', '1th', '1 th']
    },
    {
        'testament': 'NT',
        'verse_counts': [12, 17, 18],
        'name': '2 Thessalonians',
        'abbrs': ['2thessalonians', '2 thess', '2thess', '2 thes', '2thes', '2th', '2 th']
    },
    {
        'testament': 'NT',
        'verse_counts': [20, 15, 16, 16, 25, 21],
        'name': '1 Timothy',
        'abbrs': ['1tim', '1tm', '1 tm', '1timothy', '1ti', '1 tim', '1 ti']
    },
    {
        'testament': 'NT',
        'verse_counts': [18, 26, 17, 22],
        'name': '2 Timothy',
        'abbrs': ['2tim', '2tm', '2 tm', '2timothy', '2ti', '2 tim', '2 ti']
    },
    {
        'testament': 'NT',
        'verse_counts': [16, 15, 15],
        'name': 'Titus',
        'abbrs': ['ti', 'tit']
    },
    {
        'testament': 'NT',
        'verse_counts': [25],
        'name': 'Philemon',
        'abbrs': ['philem', 'phm']
    },
    {
        'testament': 'NT',
        'verse_counts': [14, 18, 19, 16, 14, 20, 28, 13, 28, 39, 40, 29, 25],
        'name': 'Hebrews',
        'abbrs': ['heb', 'he']
    },
    {
        'testament': 'NT',
        'verse_counts': [27, 26, 18, 17, 20],
        'name': 'James',
        'abbrs': ['jam', 'ja', 'jas']
    },
    {
        'testament': 'NT',
        'verse_counts': [25, 25, 22, 19, 14],
        'name': '1 Peter',
        'abbrs': ['1pet', '1p', '1pe', '1 pe', '1pt', '1pe', '1 pet', '1 pt', '1 pe']
    },
    {
        'testament': 'NT',
        'verse_counts': [21, 22, 18],
        'name': '2 Peter',
        'abbrs': ['2pet', '2p', '2pe', '2 pe', '2pt', '2pe', '2 pet', '2 pt', '2 pe']
    },
    {
        'testament': 'NT',
        'verse_counts': [10, 29, 24, 21, 21],
        'name': '1 John',
        'abbrs': ['1john', '1j', '1jo', '1 jo', '1jn', '1 jn']
    },
    {
        'testament': 'NT',
        'verse_counts': [13],
        'name': '2 John',
        'abbrs': ['2john', '2j', '2jo', '2 jo', '2jn', '2 jn']
    },
    {
        'testament': 'NT',
        'verse_counts': [15],
        'name': '3 John',
        'abbrs': ['3john', '3j', '3jo', '3 jo', '3jn', '3 jn']
    },
    {
        'testament': 'NT',
        'verse_counts': [25],
        'name': 'Jude',
        'abbrs': ['ju', 'jud']
    },
    {
        'testament': 'NT',
        'verse_counts': [20, 29, 22, 11, 14, 17, 17, 13, 21, 11, 19, 17, 18, 20, 8, 21, 18, 24, 21, 15, 27, 21],
        'name': 'Revelation',
        'abbrs': ['rev', 're', 'rv', 'revel']
    }
]

roman_numerals = [
    # 10
    'i', 'ii', 'iii', 'iv', 'v', 'vi', 'vii', 'viii', 'ix', 'x',
    # 20
    'xi', 'xii', 'xiii', 'xiv', 'xv', 'xvi', 'xvii', 'xviii', 'xix', 'xx',
    # 30
    'xxi', 'xxii', 'xxiii', 'xxiv', 'xxv', 'xxvi', 'xxvii', 'xxviii', 'xxix', 'xxx',
    # 40
    'xxxi', 'xxxii', 'xxxiii', 'xxxiv', 'xxxv', 'xxxvi', 'xxxvii', 'xxxviii', 'xxxix', 'xl',
    # 50
    'xli', 'xlii', 'xliii', 'xliv', 'xlv', 'xlvi', 'xlvii', 'xlviii', 'xlix', 'l',
    # 60
    'li', 'lii', 'liii', 'liv', 'lv', 'lvi', 'lvii', 'lviii', 'lix', 'lx',
    # 70
    'lxi', 'lxii', 'lxiii', 'lxiv', 'lxv', 'lxvi', 'lxvii', 'lxviii', 'lxix', 'lxx',
    # 80
    'lxxi', 'lxxii', 'lxxiii', 'lxxiv', 'lxxv', 'lxxvi', 'lxxvii', 'lxxviii', 'lxxix', 'lxxx',
    # 90
    'lxxxi', 'lxxxii', 'lxxxiii', 'lxxxiv', 'lxxxv', 'lxxxvi', 'lxxxvii', 'lxxxviii', 'lxxxix', 'xc',
    # 100
    'xci', 'xcii', 'xciii', 'xciv', 'xcv', 'xcvi', 'xcvii', 'xcviii', 'xcix', 'c',
    # 110
    'ci', 'cii', 'ciii', 'civ', 'cv', 'cvi', 'cvii', 'cviii', 'cix', 'cx',
    # 120
    'cxi', 'cxii', 'cxiii', 'cxiv', 'cxv', 'cxvi', 'cxvii', 'cxviii', 'cxix', 'cxx',
    # 130
    'cxxi', 'cxxii', 'cxxiii', 'cxxiv', 'cxxv', 'cxxvi', 'cxxvii', 'cxxviii', 'cxxix', 'cxxx',
    # 140
    'cxxxi', 'cxxxii', 'cxxxiii', 'cxxxiv', 'cxxxv', 'cxxxvi', 'cxxxvii', 'cxxxviii', 'cxxxix', 'cxl',
    # 150
    'cxli', 'cxlii', 'cxliii', 'cxliv', 'cxlv', 'cxlvi', 'cxlvii', 'cxlviii', 'cxlix', 'cl',
    # 160
    'cli', 'clii', 'cliii', 'cliv', 'clv', 'clvi', 'clvii', 'clviii', 'clix', 'clx',
    # 170
    'clxi', 'clxii', 'clxiii', 'clxiv', 'clxv', 'clxvi', 'clxvii', 'clxviii', 'clxix', 'clxx',
    # 180
    'clxxi', 'clxxii', 'clxxiii', 'clxxiv', 'clxxv', 'clxxvi', 'clxxvii', 'clxxviii', 'clxxix', 'clxxx',
    # 190
    'clxxxi', 'clxxxii', 'clxxxiii', 'clxxxiv', 'clxxxv', 'clxxxvi', 'clxxxvii', 'clxxxviii', 'clxxxix', 'cxc',
    # 200
    'cxci', 'cxcii', 'cxciii', 'cxciv', 'cxcv', 'cxcvi', 'cxcvii', 'cxcviii', 'cxcix', 'cc'
]

def get_verse_count(book: str, chapter: int) -> int:
    """Get the number of verses in a given chapter of a book."""
    for b in bible_structure:
        if b['name'] == book:
            if 1 <= chapter <= len(b['verse_counts']):
                return b['verse_counts'][chapter-1]
    return 0


##################################################
# Load Bibles

def load_bible_to_dict(path: str) -> Dict[str, List[List[str]]]:
    """Load bible verses from a file into a nested dictionary structure.

    Args:
        path: Path to the bible text file

    Returns:
        Dict with structure:
        {
            'Genesis': [
                ['In the beginning...', 'And the earth...'],  # chapter 1
                ['Thus the heavens...', 'And on the...'],     # chapter 2
            ]
        }
    """
    bible_dict = {}
    current_book = None
    current_chapter = None

    try:
        with open(path, 'r', encoding='utf-8') as f:
            for line in f:
                line = line.strip()
                if not line:
                    continue

                # Parse the reference and verse
                match = re.match(r'([\w\s]+)\s+(\d+):(\d+)\s+([A-Z]+)\s+(.+)', line)
                if not match:
                    continue

                book, chapter, verse, translation, text = match.groups()
                chapter = int(chapter)
                verse = int(verse)

                # Initialize new book if needed
                if book not in bible_dict:
                    bible_dict[book] = []

                # Add chapters until we reach the current one
                while len(bible_dict[book]) < chapter:
                    bible_dict[book].append([])

                # Add verses until we reach the current one
                while len(bible_dict[book][chapter-1]) < verse:
                    bible_dict[book][chapter-1].append('')

                # Add the verse text
                bible_dict[book][chapter-1][verse-1] = text

    except FileNotFoundError:
        print(f"Could not find Bible file at: {path}")
        return {}

    return bible_dict


# Load all bible translations to memory
bibles = {}
for translation, path in paths.items():
    bibles[translation] = load_bible_to_dict(path)



##################################################
# Parsers

# Optional whitespace
ws = regex(r'\s*')

# Required whitespace
required_ws = regex(r'\s+')

# Standard separators
colon = ws >> string(':') << ws
dash = ws >> string_from('-', '–') << ws
semicolon = ws >> string(';') << ws
comma = ws >> string(',') << ws
dot = string('.').optional()
ws_dot = ws >> string('.') << ws

@dataclass
class BookRef:
    """Represents a standardized book reference.

    >>> BookRef("Genesis")
    BookRef('Genesis')
    """
    name: str
    def __repr__(self):
        return f"BookRef('{self.name}')"


def build_book_parser(allow_book_periods=True) -> Parser:
    """Build a parser for Bible book names and abbreviations.

    Uses the bible_structure data to create parsers for all valid book names
    and abbreviations. Matching is case-insensitive.

    Returns:
        Parser that produces a BookRef object with standardized name

    Examples:
    >>> book_parser = build_book_parser()

    # Full names - case variations
    >>> book_parser.parse("Genesis")
    BookRef('Genesis')
    >>> book_parser.parse("GENESIS")
    BookRef('Genesis')
    >>> book_parser.parse("genesis")
    BookRef('Genesis')
    >>> book_parser.parse("GeNeSiS")
    BookRef('Genesis')

    # Error cases
    >>> book_parser.parse("NotABook")
    Traceback (most recent call last):
        ...
    parsy.ParseError: expected 'book name' at 0:0
    >>> book_parser.parse("First Kings")
    Traceback (most recent call last):
        ...
    parsy.ParseError: expected 'book name' at 0:0
    """

    # build sorted list of all names and abbreviations
    forms = []
    for book in bible_structure:
        std_name = book['name']
        # Full name doesn't get period
        forms.append((std_name, std_name, False))
        # Abbreviations can have optional period
        forms.extend((abbr, std_name, True) for abbr in book['abbrs'])

    # Sort by length (descending) then alphabetically to ensure longer matches take precedence
    book_forms = sorted(forms, key=lambda x: (-len(x[0]), x[0].lower()))

    # turn them into parsers
    book_parsers = []
    for form, std_name, allow_period in book_forms:
        # Create case-insensitive parser for the book name/abbreviation
        name_parser = string(form, transform=str.lower).result(std_name)
        if allow_period and allow_book_periods:
            # For abbreviations, allow optional period
            parser = (name_parser << dot)
        else:
            # For full names, no period
            parser = name_parser
        book_parsers.append(parser)

    # Combine all parsers with |
    return (alt(*book_parsers)
           .desc("book name")
           .map(BookRef))

book_parser = build_book_parser()
book_parser_no_dot = build_book_parser(allow_book_periods=False)

# @@@@@@@@@@@@@@@@@@@@
# Test all books
for book in bible_structure:
    std_name = book['name']
    # Test standard name
    result = book_parser.parse(std_name)
    assert result == BookRef(std_name), f"Failed to parse {std_name}"
    # Test lowercase
    result = book_parser.parse(std_name.lower())
    assert result == BookRef(std_name), f"Failed to parse {std_name.lower()}"
    # Test uppercase
    result = book_parser.parse(std_name.upper())
    assert result == BookRef(std_name), f"Failed to parse {std_name.upper()}"
    # Test all abbreviations
    for abbr in book['abbrs']:
        result = book_parser.parse(abbr)
        assert result == BookRef(std_name), f"Failed to parse {abbr}"
        # Test lowercase
        result = book_parser.parse(abbr.lower())
        assert result == BookRef(std_name), f"Failed to parse {abbr.lower()}"
        # Test uppercase
        result = book_parser.parse(abbr.upper())
        assert result == BookRef(std_name), f"Failed to parse {abbr.upper()}"
        # Test with period
        result = book_parser.parse(abbr + '.')
        assert result == BookRef(std_name), f"Failed to parse {abbr}."

# @@@@@@@@@@@@@@@@@@@@


##################################################

####################
# Verses

@dataclass
class VerseRef:
    """Represents a verse number reference.

    >>> VerseRef(1)
    VerseRef(1)
    """
    number: int
    def __repr__(self):
        return f"VerseRef({self.number})"

def build_verse_parser() -> Parser:
    """Build a parser for Bible verse numbers.

    Handles Arabic numbers only (Roman numerals not used for verses).
    Numbers must be positive.

    Returns:
        Parser that produces a VerseRef object

    Examples:
    >>> verse_parser = build_verse_parser()

    # Basic numbers
    >>> verse_parser.parse("1")
    VerseRef(1)
    >>> verse_parser.parse("176")  # Longest verse (Ps 119:176)
    VerseRef(176)

    # Error cases
    >>> verse_parser.parse("0")  # No verse 0
    Traceback (most recent call last):
        ...
    parsy.ParseError: expected 'verse number' at 0:0
    >>> verse_parser.parse("1a")
    Traceback (most recent call last):
        ...
    parsy.ParseError: expected 'EOF' at 0:1
    """
    return (regex(r'[1-9][0-9]*')
            .map(int)
            .map(VerseRef)
            .desc("verse number"))

verse_parser = build_verse_parser()

@dataclass
class VerseRange:
    """Represents a range of verses.

    >>> VerseRange(VerseRef(1), VerseRef(3))
    VerseRange(VerseRef(1), VerseRef(3))
    """
    start: VerseRef
    end: VerseRef
    def __repr__(self):
        return f"VerseRange({self.start}, {self.end})"


def build_verse_range_parser() -> Parser:
    """Build a parser for verse ranges like 1-3 or 1–3.

    Examples:
    >>> verse_range_parser = build_verse_range_parser()
    >>> verse_range_parser.parse("1-3")
    VerseRange(VerseRef(1), VerseRef(3))
    >>> verse_range_parser.parse("1–3")  # en-dash
    VerseRange(VerseRef(1), VerseRef(3))
    """
    return seq(
        start=verse_parser,
        _dash=dash,
        end=verse_parser
    ).combine_dict(VerseRange)

verse_range_parser = build_verse_range_parser()


####################
# Chapter

@dataclass
class ChapterRef:
    """Represents a chapter reference that may be parsed from either Arabic or Roman numerals.

    >>> ChapterRef(1)
    ChapterRef(1)
    """
    number: int
    def __repr__(self):
        return f"ChapterRef({self.number})"

def build_chapter_parser(allow_dot=True) -> Parser:
    """Build a parser for Bible chapter numbers.

    Handles both Arabic numbers and Roman numerals. Roman numerals are matched
    by length (longest first) then alphabetically to ensure correct parsing.

    Returns:
        Parser that produces a ChapterRef object

    Examples:
    >>> chapter_parser = build_chapter_parser()

    # Arabic numbers
    >>> chapter_parser.parse("1")
    ChapterRef(1)
    >>> chapter_parser.parse("119")
    ChapterRef(119)

    # Roman numerals - case variations
    >>> chapter_parser.parse("i")
    ChapterRef(1)
    >>> chapter_parser.parse("I")
    ChapterRef(1)
    >>> chapter_parser.parse("iv")
    ChapterRef(4)
    >>> chapter_parser.parse("xl")
    ChapterRef(40)

    # Longer roman numerals
    >>> chapter_parser.parse("xxxviii")  # 38
    ChapterRef(38)
    >>> chapter_parser.parse("LXXXVIII")  # 88
    ChapterRef(88)
    >>> chapter_parser.parse("CXIX")  # 119
    ChapterRef(119)

    """

    # Build sorted list of roman numerals with their values
    roman_forms: List[Tuple[str, int]] = [
        (numeral, idx + 1) for idx, numeral in enumerate(roman_numerals)
    ]
    # Sort by length (descending) and then alphabetically
    roman_forms.sort(key=lambda x: (-len(x[0]), x[0]))

    # Create individual parsers for each roman numeral
    roman_parsers = []
    for form, value in roman_forms:
        # Create case-insensitive parser
        if allow_dot:
            parser = string(form, transform=str.lower).result(value) << dot
        else:
            parser = string(form, transform=str.lower).result(value)
        roman_parsers.append(parser)

    # Combine roman numeral parsers with reduce
    roman = (alt(*roman_parsers)
            .desc("roman numeral chapter"))

    # Arabic numbers - must be 1 or greater
    arabic = (regex(r'[1-9][0-9]*')
             .map(int)
             .desc("arabic chapter number"))

    # Combine parsers and wrap result
    return (roman | arabic).map(ChapterRef).desc("chapter number")



chapter_parser = build_chapter_parser()
chapter_parser_no_dot = build_chapter_parser(allow_dot=False)

# @@@@@@@@@@@@@@@@@@@@

# Test each roman numeral in the list
for idx, numeral in enumerate(roman_numerals):
    expected = idx + 1  # Roman numerals are 1-based

    # Test lowercase
    result = chapter_parser.parse(numeral)
    assert result == ChapterRef(expected), f"Failed to parse lowercase '{numeral}': expected {expected}, got {result}"

    # Test uppercase
    result = chapter_parser.parse(numeral.upper())
    assert result == ChapterRef(expected), f"Failed to parse uppercase '{numeral.upper()}': expected {expected}, got {result}"

    # Test mixed case (alternate upper/lower)
    mixed = ''.join(c.upper() if i % 2 == 0 else c.lower()
                   for i, c in enumerate(numeral))
    result = chapter_parser.parse(mixed)
    assert result == ChapterRef(expected), f"Failed to parse mixed case '{mixed}': expected {expected}, got {result}"
# @@@@@@@@@@@@@@@@@@@@


@dataclass
class CrossChapterRange:
    """Represents a range that spans chapters.

    >>> CrossChapterRange(ChapterRef(1), VerseRef(31), ChapterRef(2), VerseRef(3))
    CrossChapterRange(ChapterRef(1), VerseRef(31), ChapterRef(2), VerseRef(3))
    """
    start_chapter: ChapterRef
    start_verse: VerseRef
    end_chapter: ChapterRef
    end_verse: VerseRef
    def __repr__(self):
        return f"CrossChapterRange({self.start_chapter}, {self.start_verse}, {self.end_chapter}, {self.end_verse})"

def build_cross_chapter_range_parser(chapter_parser: Parser, verse_parser: Parser) -> Parser:
    """Build a parser for ranges that cross chapter boundaries.

    Examples:
    >>> chapter_parser = build_chapter_parser()
    >>> verse_parser = build_verse_parser()
    >>> range_parser = build_cross_chapter_range_parser(chapter_parser, verse_parser)
    >>> range_parser.parse("1:31-2:3")
    CrossChapterRange(ChapterRef(1), VerseRef(31), ChapterRef(2), VerseRef(3))
    """
    return seq(
        start_chapter=chapter_parser << colon,
        start_verse=verse_parser << dash,
        end_chapter=chapter_parser << colon,
        end_verse=verse_parser
    ).combine_dict(CrossChapterRange)

cross_chapter_range = build_cross_chapter_range_parser(chapter_parser, verse_parser)

@dataclass
class ComplexChapter:
    """ """
    chapter: ChapterRef
    verse_ref: List[Union[VerseRef, VerseRange]]
    # verse_ref: Union[VerseRef, List[VerseRef], VerseRange, List[VerseRange]]
    def __repr__(self):
        return f"ComplexChapter({self.chapter}, {self.verse_ref})"

ComplexVerses = Union[ComplexChapter, CrossChapterRange]

####################
# Whole References

@dataclass
class SingleReference:
    """A single verse reference with book, chapter, and verse."""
    book: BookRef
    chapter: ChapterRef
    verse: VerseRef
    def __repr__(self):
        return f"SingleReference({self.book}, {self.chapter}, {self.verse})"


@dataclass
class RangeReference:
    """A verse range reference with book, chapter, and verse range. """
    book: BookRef
    chapter: ChapterRef
    verse_range: VerseRange
    def __repr__(self):
        return f"RangeReference({self.book}, {self.chapter}, {self.verse_range})"


@dataclass
class CrossChapterReference:
    """A cross-chapter range reference. """
    book: BookRef
    range: CrossChapterRange
    def __repr__(self):
        return f"CrossChapterReference({self.book}, {self.range})"


@dataclass
class ComplexReference:
    """A reference containing multiple verses or ranges possibly across different chapters."""
    book: BookRef
    verse_refs: List[ComplexVerses]
    def __repr__(self):
        return f"ComplexReference({self.book}, {self.verse_refs})"


def build_complex_single_chapter_parser() -> Parser:
    """
    Ex: Gen 1: 1, 2-3

    >>> parser = build_complex_single_chapter_parser()
    >>> parser.parse("Gen 1:1,2")
    ComplexReference(BookRef('Genesis'), [ComplexChapter(ChapterRef(1), [VerseRef(1), VerseRef(2)])])
    >>> parser.parse("Gen 1:1-2,3-4")
    ComplexReference(BookRef('Genesis'), [ComplexChapter(ChapterRef(1), [VerseRange(VerseRef(1), VerseRef(2)), VerseRange(VerseRef(3), VerseRef(4))])])
    >>> parser.parse("Gen 1:1,2-3")
    ComplexReference(BookRef('Genesis'), [ComplexChapter(ChapterRef(1), [VerseRef(1), VerseRange(VerseRef(2), VerseRef(3))])])
    """
    verses = seq(
        chapter = chapter_parser << colon,
        verse_ref = (verse_range_parser | verse_parser).sep_by(comma << ws, min=2)
    ).combine_dict(ComplexChapter).map(lambda x: [x])  # wrap in list
    return seq(
        book=book_parser << required_ws,
        verse_refs=verses
    ).combine_dict(ComplexReference)


def build_complex_multi_chapter_parser() -> Parser:
    """
    Ex: Gen 1:1-2, 2:2-3

    >>> parser = build_complex_multi_chapter_parser()
    >>> parser.parse("Gen 1:1-2, 2:4-5")
    ComplexReference(BookRef('Genesis'), [ComplexChapter(ChapterRef(1), [VerseRange(VerseRef(1), VerseRef(2))]), ComplexChapter(ChapterRef(2), [VerseRange(VerseRef(4), VerseRef(5))])])
    >>> parser.parse('Gen 1:2, 2:3-4, 3:5-4:1')
    ComplexReference(BookRef('Genesis'), [ComplexChapter(ChapterRef(1), [VerseRef(2)]), ComplexChapter(ChapterRef(2), [VerseRange(VerseRef(3), VerseRef(4))]), CrossChapterRange(ChapterRef(3), VerseRef(5), ChapterRef(4), VerseRef(1))])
    """
    single_chapter = seq(
        chapter = chapter_parser << colon,
        verse_ref = (verse_range_parser | verse_parser).map(lambda x: [x])
    ).combine_dict(ComplexChapter)

    p = (cross_chapter_range | single_chapter).sep_by(comma << ws, min=2)

    return seq(
        book=book_parser << required_ws,
        verse_refs=p
    ).combine_dict(ComplexReference)


def build_complex_reference_parser() -> Parser:
    """Build a parser for complex verse references with multiple verses or ranges across chapters.

    Templates:
    - book chapter:1, 2, 3-4                 # single chapter
    - book chapter:1, chapter:2-3, chapter:4 # multi chapter
    - book 1:30-2:2, 1:1                     # multi chapter with cross chapter range

    Examples:
    - Gen 1:1,3,5
    - Gen 1:31-2:3, 2:35
    - Ps. 119:1-3, 120:5-7, 121:4-122:2

    Examples:
    >>> parser = build_complex_reference_parser()
    >>> parser.parse("Ps. 119:1-2, 120:5-6, 121:4-122:2")
    ComplexReference(BookRef('Psalms'), [ComplexChapter(ChapterRef(119), [VerseRange(VerseRef(1), VerseRef(2))]), ComplexChapter(ChapterRef(120), [VerseRange(VerseRef(5), VerseRef(6))]), CrossChapterRange(ChapterRef(121), VerseRef(4), ChapterRef(122), VerseRef(2))])
    """
    return (
        build_complex_multi_chapter_parser() |
        build_complex_single_chapter_parser()
    )


##################################################

@dataclass
class ChapterOnlyReference:
    """A reference to a whole chapter without specific verses."""
    book: BookRef
    chapter: ChapterRef
    def __repr__(self):
        return f"ChapterOnlyReference({self.book}, {self.chapter})"

def build_chapter_only_parser() -> Parser:
    """Build a parser for whole chapter references.

    Examples:
    >>> parser = build_chapter_only_parser()
    >>> parser.parse("Genesis 1")
    ChapterOnlyReference(BookRef('Genesis'), ChapterRef(1))
    >>> parser.parse("Gen. 1")
    ChapterOnlyReference(BookRef('Genesis'), ChapterRef(1))
    >>> parser.parse("Gen i")
    ChapterOnlyReference(BookRef('Genesis'), ChapterRef(1))
    """
    return (
        seq(book_parser << required_ws, chapter_parser).combine(ChapterOnlyReference) |
        seq(book_parser_no_dot << ws_dot, chapter_parser_no_dot).combine(ChapterOnlyReference)
    )


##################################################


def build_reference_parser() -> Parser:
    """Build a parser for complete Bible references.

    Examples:
    >>> parser = build_reference_parser()

    # Single verse
    >>> parser.parse("Genesis 1:1")
    [SingleReference(BookRef('Genesis'), ChapterRef(1), VerseRef(1))]

    # Verse range
    >>> parser.parse("Genesis 1:1-3")
    [RangeReference(BookRef('Genesis'), ChapterRef(1), VerseRange(VerseRef(1), VerseRef(3)))]

    # Cross chapter range
    >>> parser.parse("Genesis 1:31-2:3")
    [CrossChapterReference(BookRef('Genesis'), CrossChapterRange(ChapterRef(1), VerseRef(31), ChapterRef(2), VerseRef(3)))]

    # Book abbreviation
    >>> parser.parse("Gen 1:1")
    [SingleReference(BookRef('Genesis'), ChapterRef(1), VerseRef(1))]

    # Roman numeral chapter
    >>> parser.parse("Genesis ii:1")
    [SingleReference(BookRef('Genesis'), ChapterRef(2), VerseRef(1))]
    """

    # Single verse reference (eg "Genesis 1:1")
    single_ref = (
        seq(book_parser << required_ws, chapter_parser << colon, verse_parser).combine(SingleReference) | # Gen 1: 1
        seq(book_parser_no_dot << ws_dot, chapter_parser_no_dot << ws_dot, verse_parser).combine(SingleReference) | # Gen.1.1
        seq(book_parser_no_dot << ws, chapter_parser_no_dot << ws_dot, verse_parser).combine(SingleReference)  # Gen i. 1
    )

    # Verse range in same chapter (eg "Genesis 1:1-3")
    range_ref = (
        seq(book_parser << required_ws, chapter_parser << colon, verse_range_parser).combine(RangeReference) | # Gen 1:1-3
        seq(book_parser_no_dot << ws_dot, chapter_parser_no_dot << ws_dot, verse_range_parser).combine(RangeReference) # Gen. 1. 1-3
    )

    # Cross-chapter range (eg "Genesis 1:31-2:3")
    cross_chapter_ref = seq(
        book=book_parser << required_ws,
        range=cross_chapter_range,
    ).combine_dict(CrossChapterReference)

    # Complex (eg "Gen 1:3-4, 2:5-6")
    complex_ref = build_complex_reference_parser()

    # Combine all parsers and allow multiple references separated by semicolons
    # Order matters - try more specific patterns first
    return (complex_ref |
            cross_chapter_ref |
            range_ref |
            single_ref |
            build_chapter_only_parser()
            ).sep_by(semicolon, min=1)


# Reuse existing components from the base code
book_parser = build_book_parser()
chapter_parser = build_chapter_parser()
verse_parser = build_verse_parser()


##################################################
#


####################
# Pipe Syntax Parser

def build_pipe_parser() -> Parser:
    """Build a parser for the pipe-delimited format.

    Examples:
    >>> build_pipe_parser().parse("|Matt|5|6|0|0")
    SingleReference(BookRef('Matthew'), ChapterRef(5), VerseRef(6))
    >>> build_pipe_parser().parse("|John|10|11|10|13")
    RangeReference(BookRef('John'), ChapterRef(10), VerseRange(VerseRef(11), VerseRef(13)))
    """
    pipe = string("|")
    number = regex(r'[0-9]+').map(int)

    @generate
    def pipe_reference():
        # Parse components
        yield pipe
        book = yield book_parser
        yield pipe
        chapter1 = yield number
        yield pipe
        verse1 = yield number
        yield pipe
        chapter2 = yield number
        yield pipe
        verse2 = yield number

        # Convert numbers to proper reference types
        ch1 = ChapterRef(chapter1)
        v1 = VerseRef(verse1)

        # Single verse reference
        if chapter2 == 0 and verse2 == 0:
            return SingleReference(book, ch1, v1)

        # Range reference
        ch2 = ChapterRef(chapter2)
        v2 = VerseRef(verse2)

        # Same chapter range
        if chapter1 == chapter2:
            return RangeReference(book, ch1, VerseRange(v1, v2))

        # Cross chapter range
        return CrossChapterReference(
            book,
            CrossChapterRange(ch1, v1, ch2, v2)
        )

    return pipe_reference


####################
# OSIS Parser

def build_osis_parser() -> Parser:
    """Build a parser for OSIS format references.

    Examples:
    >>> build_osis_parser().parse("Bible:Matt.5.6")
    [SingleReference(BookRef('Matthew'), ChapterRef(5), VerseRef(6))]
    >>> build_osis_parser().parse("Matt.5.6")
    [SingleReference(BookRef('Matthew'), ChapterRef(5), VerseRef(6))]
    >>> build_osis_parser().parse("Bible:John.10.11-John.10.13")
    [RangeReference(BookRef('John'), ChapterRef(10), VerseRange(VerseRef(11), VerseRef(13)))]

    # whole chapter
    >>> build_osis_parser().parse("Bible:Matt.5")
    [ChapterOnlyReference(BookRef('Matthew'), ChapterRef(5))]
    >>> build_osis_parser().parse("Matt.5")
    [ChapterOnlyReference(BookRef('Matthew'), ChapterRef(5))]
    """
    bible_prefix = string("Bible:").optional()
    dot = string(".") << ws

    # Chapter only reference (e.g., "Matt.5")
    chapter_only_ref = seq(
        _bible_prefix=bible_prefix,
        book=book_parser_no_dot,
        _d1=dot,
        chapter=chapter_parser
    ).combine_dict(ChapterOnlyReference)

    # Single reference (e.g., "Matt.5.6")
    single_ref = seq(
        _bible_prefix=bible_prefix,
        book=book_parser_no_dot,
        _d1=dot,
        chapter=chapter_parser,
        _d2=dot,
        verse=verse_parser
    ).combine_dict(SingleReference)

    # Verse range in same chapter (e.g., "Gen.1.1-Gen.1.3")
    @generate
    def range_ref():
        yield bible_prefix
        book1 = yield book_parser << ws << dot
        ch1 = yield chapter_parser << ws << dot
        v1 = yield verse_parser
        yield dash
        book2 = yield book_parser << ws << dot
        ch2 = yield chapter_parser << ws << dot
        v2 = yield verse_parser
        if book1 != book2:
            fail("OSIS format cannot handle cross-book references")
        return RangeReference(
            book1,
            ch1,
            VerseRange(v1, v2)
        )

    return (range_ref | single_ref
            | chapter_only_ref
            ).sep_by(semicolon, min=1)


####################


@dataclass
class Verse:
    book: str
    chapter: int
    verse: int
    def __repr__(self):
        """Custom representation for doctests."""
        return f"Verse('{self.book}', {self.chapter}, {self.verse})"

def parse_verses(reference: str) -> List[Verse]:
    """Parse a scripture reference into individual verses.

    This is the main entry point for parsing Bible references.

    >>> parse_verses('Genesis 1:1')
    [Verse('Genesis', 1, 1)]
    >>> parse_verses('Gen 1:1-3')
    [Verse('Genesis', 1, 1), Verse('Genesis', 1, 2), Verse('Genesis', 1, 3)]
    >>> parse_verses('Gen 1:31-2:3')
    [Verse('Genesis', 1, 31), Verse('Genesis', 2, 1), Verse('Genesis', 2, 2), Verse('Genesis', 2, 3)]
    >>> parse_verses('Gen 1:1; Ex 2:3')
    [Verse('Genesis', 1, 1), Verse('Exodus', 2, 3)]

    # Pipes
    >>> parse_verses("|Matt|5|6|0|0")
    [Verse('Matthew', 5, 6)]
    >>> parse_verses("|John|10|11|10|13")
    [Verse('John', 10, 11), Verse('John', 10, 12), Verse('John', 10, 13)]

    # OSIS
    >>> parse_verses("Bible:Matt.5.6")
    [Verse('Matthew', 5, 6)]
    >>> parse_verses("Bible:John.10.11-John.10.13")
    [Verse('John', 10, 11), Verse('John', 10, 12), Verse('John', 10, 13)]
    """
    try:
        p = (
            build_reference_parser() |
            build_pipe_parser() |
            build_osis_parser()
        )
        refs = p.parse(reference)
        return convert_to_verses(refs)
    except:
        return []


##################################################
# Fetching

def convert_cross_chapter_range_to_verses(x: CrossChapterRange, book):
    result = []

    # Add verses from first chapter
    max_verse = get_verse_count(book, x.start_chapter.number)
    for v in range(x.start_verse.number, max_verse + 1):
        result.append(Verse(book, x.start_chapter.number, v))

    # Add verses from intervening chapters
    for ch in range(x.start_chapter.number + 1, x.end_chapter.number):
        max_verse = get_verse_count(book, ch)
        for v in range(1, max_verse + 1):
            result.append(Verse(book, ch, v))

    # Add verses from last chapter
    for v in range(1, x.end_verse.number + 1):
        result.append(Verse(book, x.end_chapter.number, v))
    return result


def convert_cross_chapter_reference_to_verses(ref: CrossChapterReference) -> List[Verse]:
    return convert_cross_chapter_range_to_verses(ref.range, ref.book.name)

def f(book, chapter, verse_or_range):
    # VerseRef
    if isinstance(verse_or_range, VerseRef):
        return [Verse(book, chapter.number, verse_or_range.number)]
    # VerseRange
    elif isinstance(verse_or_range, VerseRange):
        result = []
        start = verse_or_range.start.number
        end = verse_or_range.end.number
        for v in range(start, end + 1):
            result.append(Verse(book, chapter.number, v))
        return result


def convert_complex_chapter_to_verses(cc: ComplexChapter, book):
    assert isinstance(cc.verse_ref, list), f'ComplexChapter.verse_ref must be list, but found: {cc}'
    return list(reduce(lambda x, y: x + y,
                         map(lambda v: f(book, cc.chapter, v), cc.verse_ref)))


def convert_complex_verse_to_verses(x: ComplexVerses, book):
    if isinstance(x, ComplexChapter):
        return convert_complex_chapter_to_verses(x, book)
    elif isinstance(x, CrossChapterRange):
        return convert_cross_chapter_range_to_verses(x, book)


def convert_complex_ref_to_verses(ref: ComplexReference) -> List[Verse]:
    return list(reduce(lambda x, y: x + y,
                       map(lambda x: convert_complex_verse_to_verses(x, ref.book.name), ref.verse_refs)))


def convert_chapter_only_reference_to_verses(ref: ChapterOnlyReference) -> List[Verse]:
    """Convert a chapter reference to a list of all verses in that chapter.

    Examples:
    >>> ref = ChapterOnlyReference(BookRef('Genesis'), ChapterRef(1))
    >>> verses = convert_chapter_only_reference_to_verses(ref)
    >>> len(verses)  # Genesis 1 has 31 verses
    31
    >>> verses[0]
    Verse('Genesis', 1, 1)
    >>> verses[-1]
    Verse('Genesis', 1, 31)
    """
    result = []
    verse_count = get_verse_count(ref.book.name, ref.chapter.number)
    for verse_num in range(1, verse_count + 1):
        result.append(Verse(ref.book.name, ref.chapter.number, verse_num))
    return result

def convert_to_verses(refs) -> List[Verse]:
    """Convert parsed references into a list of Verse objects.

    This handles all the different reference types and converts them into
    a flat list of individual verses. Invalid chapter or verse numbers are
    filtered out at the end.

    Examples:
    >>> parser = build_reference_parser()
    >>> convert_to_verses(parser.parse("Gen 1:1-3"))
    [Verse('Genesis', 1, 1), Verse('Genesis', 1, 2), Verse('Genesis', 1, 3)]
    >>> convert_to_verses(parser.parse("Gen 1:31-2:3"))
    [Verse('Genesis', 1, 31), Verse('Genesis', 2, 1), Verse('Genesis', 2, 2), Verse('Genesis', 2, 3)]
    >>> convert_to_verses(parser.parse("Gen 51:1"))  # chapter too high
    []
    >>> convert_to_verses(parser.parse("Gen 1:40"))  # verse too high
    []
    >>> convert_to_verses(parser.parse("Gen 1:31-2:3, 2:4"))
    [Verse('Genesis', 1, 31), Verse('Genesis', 2, 1), Verse('Genesis', 2, 2), Verse('Genesis', 2, 3), Verse('Genesis', 2, 4)]
    >>> convert_to_verses(parser.parse("Gen 1:1, 2:4"))
    [Verse('Genesis', 1, 1), Verse('Genesis', 2, 4)]
    """
    result = []

    # Handle single reference or list
    refs = [refs] if not isinstance(refs, list) else refs

    for ref in refs:
        if isinstance(ref, SingleReference):
            result.append(Verse(ref.book.name, ref.chapter.number, ref.verse.number))

        elif isinstance(ref, RangeReference):
            for v in range(ref.verse_range.start.number, ref.verse_range.end.number + 1):
                result.append(Verse(ref.book.name, ref.chapter.number, v))

        elif isinstance(ref, CrossChapterReference):
            result += convert_cross_chapter_reference_to_verses(ref)

        elif isinstance(ref, ComplexReference):
            result += convert_complex_ref_to_verses(ref)

        elif isinstance(ref, ChapterOnlyReference):
            result += convert_chapter_only_reference_to_verses(ref)

    # Filter out invalid verses at the end
    def is_valid_reference(verse: Verse) -> bool:
        """Check if a verse reference is valid."""
        for b in bible_structure:
            if b['name'] == verse.book:
                if 1 <= verse.chapter <= len(b['verse_counts']):
                    return 1 <= verse.verse <= b['verse_counts'][verse.chapter-1]
        return False

    return [verse for verse in result if is_valid_reference(verse)]


def fetch_verses(verses: List[Verse], translation: str, with_reference: bool = False) -> List[str]:
    """Retrieve the text for a list of verses from the specified translation.

    Args:
        verses: List of Verse objects to retrieve
        translation: Bible translation to use (e.g., 'KJV', 'ASV')
        with_reference: Whether to include the verse reference in the output

    Returns:
        List of verse texts, optionally with references
    """
    if translation not in bibles:
        return []

    bible = bibles[translation]
    results = []

    for verse in verses:
        try:
            text = bible[verse.book][verse.chapter-1][verse.verse-1]
            if with_reference:
                results.append(f"{verse.book} {verse.chapter}:{verse.verse} {translation} {text}")
            else:
                results.append(text)
        except (KeyError, IndexError):
            # Skip verses that don't exist in this translation
            continue

    return results

def fetch(ref_string:str, translation, with_reference: bool = True) -> List[str]:
    assert translation in {'CSB', 'KJV', 'ASV'}
    vs = parse_verses(ref_string)
    xs = fetch_verses(vs, translation, with_reference)
    return xs


##################################################
# sandbox

if False:

    # vs = parse_verses('Genesis 1:1-31')
    vs = parse_verses('1 Cor. ii. 14; Gen 1:2; Amos 1:9')
    # vs = parse_verses('|gen|1|2|2|4')
    xs = fetch_verses(vs, "CSB", with_reference=True)
    print('\n'.join(xs))


##################################################

def parse_verses_test(reference: str) -> List[Verse]:
    """Parse scripture references into individual verses.

    TODO? Book only

    TODO? Chapter only

    TODO? Chapter range

    Basic formats:
    >>> parse_verses('Genesis 1:1')
    [Verse('Genesis', 1, 1)]
    >>> parse_verses('Gen 1:1')
    [Verse('Genesis', 1, 1)]
    >>> parse_verses('Gen. 1:1')
    [Verse('Genesis', 1, 1)]

    Single Chapter
    >>> parse_verses('Genesis 1')[0]
    Verse('Genesis', 1, 1)
    >>> parse_verses('Genesis 1')[-1]
    Verse('Genesis', 1, 31)

    Verse ranges:
    >>> parse_verses('Genesis 1:1-3')
    [Verse('Genesis', 1, 1), Verse('Genesis', 1, 2), Verse('Genesis', 1, 3)]
    >>> parse_verses('Gen 1:31-2:1')  # Cross-chapter
    [Verse('Genesis', 1, 31), Verse('Genesis', 2, 1)]
    >>> parse_verses('Exodus 39:32-40:2')  # Cross-chapter with more verses
    [Verse('Exodus', 39, 32), Verse('Exodus', 39, 33), Verse('Exodus', 39, 34), Verse('Exodus', 39, 35), Verse('Exodus', 39, 36), Verse('Exodus', 39, 37), Verse('Exodus', 39, 38), Verse('Exodus', 39, 39), Verse('Exodus', 39, 40), Verse('Exodus', 39, 41), Verse('Exodus', 39, 42), Verse('Exodus', 39, 43), Verse('Exodus', 40, 1), Verse('Exodus', 40, 2)]

    Roman numerals:
    >>> parse_verses('1 Cor. ii. 14')
    [Verse('1 Corinthians', 2, 14)]
    >>> parse_verses('Psalm CXLIX. 3')  # Testing larger Roman numerals
    [Verse('Psalms', 149, 3)]
    >>> parse_verses('Matt. iv. 1-3')  # Roman numerals with range
    [Verse('Matthew', 4, 1), Verse('Matthew', 4, 2), Verse('Matthew', 4, 3)]

    Multiple references:
    >>> parse_verses('Gen 1:1; Ex 2:3')
    [Verse('Genesis', 1, 1), Verse('Exodus', 2, 3)]
    >>> parse_verses('Gen 1:1, 3, 5')  # Same chapter, different verses
    [Verse('Genesis', 1, 1), Verse('Genesis', 1, 3), Verse('Genesis', 1, 5)]
    >>> parse_verses('Gen 1:1-3; Ex 2:3-5')  # Multiple ranges
    [Verse('Genesis', 1, 1), Verse('Genesis', 1, 2), Verse('Genesis', 1, 3), Verse('Exodus', 2, 3), Verse('Exodus', 2, 4), Verse('Exodus', 2, 5)]

    OSIS format:
    >>> parse_verses('Bible:Gen.1.1')
    [Verse('Genesis', 1, 1)]
    >>> parse_verses('Gen.1.1')
    [Verse('Genesis', 1, 1)]
    >>> parse_verses('1Cor.2.14')
    [Verse('1 Corinthians', 2, 14)]
    >>> parse_verses("Bible:John.10.11-John.10.13")
    [Verse('John', 10, 11), Verse('John', 10, 12), Verse('John', 10, 13)]

    Book name variations:
    >>> parse_verses('1 Kings 1:1')
    [Verse('1 Kings', 1, 1)]
    >>> parse_verses('1Kgs 1:1')
    [Verse('1 Kings', 1, 1)]
    >>> parse_verses('1 Kg 1:1')
    [Verse('1 Kings', 1, 1)]
    >>> parse_verses('First Kings 1:1')  # This should fail - we don't support spelled out numbers
    []

    Special cases and edge cases:
    >>> parse_verses('Rev 22:21')  # Last verse of the Bible
    [Verse('Revelation', 22, 21)]
    >>> parse_verses('Psa 119:176')  # Longest chapter
    [Verse('Psalms', 119, 176)]
    >>> parse_verses('Ps. 119:1-3,5-7')  # Complex range with gaps
    [Verse('Psalms', 119, 1), Verse('Psalms', 119, 2), Verse('Psalms', 119, 3), Verse('Psalms', 119, 5), Verse('Psalms', 119, 6), Verse('Psalms', 119, 7)]
    >>> parse_verses('Est 9:1–3')  # Em dash instead of hyphen
    [Verse('Esther', 9, 1), Verse('Esther', 9, 2), Verse('Esther', 9, 3)]

    Error cases:
    >>> parse_verses('Invalid 1:1')
    []
    >>> parse_verses('Gen 50:27')  # Verse doesn't exist
    []
    >>> parse_verses('Gen 51:1')  # Chapter doesn't exist
    []
    >>> parse_verses('')  # Empty string
    []
    >>> parse_verses('Genesis 1:1:1')  # Invalid format
    []
    >>> parse_verses('Gen 1:a')  # Non-numeric verse
    []
    """

    pass




# @@@@@@@@@@@@@@@@@@@@
#

if False:
    import doctest
    doctest.testmod()
    print('Parser doctests passed')

# @@@@@@@@@@@@@@@@@@@@