app.py

import json
import datetime
import logging

import gradio as gr
from deep_translator import GoogleTranslator, exceptions

from utils import process_json_files, flatten_text_with_line_breaks, calculate_tanach_statistics, build_word_index
import unittest

# Set up logging
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

# Load Tanach text
TANACH_DATA = process_json_files(1, 39)
WORD_INDEX = build_word_index(TANACH_DATA)

# --- Utility Functions ---

def get_current_word_data(client_time_str):
    """Gets data about the current word based on the client's time."""
    try:
        client_time = datetime.datetime.strptime(client_time_str, "%H:%M:%S")
        total_seconds = int(client_time.strftime("%H")) * 3600 + \
                        int(client_time.strftime("%M")) * 60 + \
                        int(client_time.strftime("%S"))

        # Find the closest key in WORD_INDEX
        word_position = min(WORD_INDEX.keys(), key=lambda k: abs(k - total_seconds))

        return WORD_INDEX[word_position], word_position
    except Exception as e:
        logging.error(f"Error processing client time: {e}")
        return None, None


def get_formatted_verse(book_id, chapter_id, verse_id, highlight_word=True):
    """Returns a formatted verse with optional word highlighting."""
    chapter_text = TANACH_DATA[book_id]["text"][chapter_id]
    flattened_chapter = flatten_text_with_line_breaks(chapter_text)

    if highlight_word:
        flattened_chapter[verse_id - 1] = \
          f"<span class='highlight'>{flattened_chapter[verse_id - 1]}</span>"

    return '<br>'.join(flattened_chapter)

def translate_verse(hebrew_verse, verse_id, highlight_word=True):
    """Translates a Hebrew verse to English and highlights the given word."""
    try:
        translator = GoogleTranslator(source='iw', target='en')
        translated_text = translator.translate(hebrew_verse).split('\n')

        if highlight_word:
            translated_text[verse_id - 1] = \
                f"<span class='highlight'>{translated_text[verse_id - 1]}</span>"

        return '<br>'.join(translated_text)
    except exceptions.TranslationError as e:
        logging.warning(f"Translation failed: {e}")
        return "Translation unavailable"

# --- Gradio Interface ---

def update_tanach_display(client_time_str):
    """Updates the Gradio interface with client time, verse info, and translations."""

    word_data, word_position = get_current_word_data(client_time_str)

    if word_data is None:
        logging.error(f"Word position {word_position} not found in index.")
        return "Error: Word not found", "", ""

    book_id = word_data["book_id"]
    chapter_id = word_data["chapter_id"]
    verse_id = word_data["verse_id"]

    logging.debug(f"Book ID: {book_id}, Chapter ID: {chapter_id}, Verse ID: {verse_id}")

    # Format verse information
    verse_info = f"""
    **{TANACH_DATA[book_id]['title']}**
    Chapter {chapter_id + 1}, Verse {verse_id}
    """

    # Get and format Hebrew and English verses
    hebrew_verse = get_formatted_verse(book_id, chapter_id, verse_id)
    english_verse = translate_verse('\n'.join(hebrew_verse.split('<br>')), verse_id)

    return verse_info, hebrew_verse, english_verse

with gr.Blocks(css="""
    .container {
    display: flex;
    flex-direction: column;
    align-items: center;
    font-family: 'Times New Roman', serif;
    }
    .highlight {
    background-color: #FFFF00;
    padding: 2px 5px;
    border-radius: 5px;
    }
    #verse-info {
    margin-bottom: 20px;
    text-align: center;
    }
    #verses {
    display: flex;
    flex-direction: row;
    justify-content: center;
    align-items: flex-start;
    gap: 50px;
    }
    #hebrew-verse {
    font-size: 18px;
    line-height: 1.5;
    margin-bottom: 20px;
    text-align: right;
    direction: rtl;
    }
    #english-verse {
    font-size: 18px;
    line-height: 1.5;
    margin-bottom: 20px;
    }
""") as iface:

    with gr.Row():
        client_time_input = gr.Textbox(label="Enter your current time (HH:MM:SS)")

    with gr.Row():
        verse_info_output = gr.Markdown(label="Verse Information", elem_id="verse-info")

    # Place Hebrew and English verses within a flex container
    with gr.Row(elem_id="verses"):
        hebrew_verse_output = gr.HTML(label="Hebrew Verse", elem_id="hebrew-verse")
        english_verse_output = gr.HTML(label="English Translation", elem_id="english-verse")

    client_time_input.submit(
        fn=update_tanach_display,
        inputs=[client_time_input],
        outputs=[verse_info_output, hebrew_verse_output, english_verse_output]
    )

class TestWordIndex(unittest.TestCase):
    def test_word_index_boundaries(self):
        # Test for 0:00:00
        word_data_start, _ = get_current_word_data("00:00:00")
        self.assertEqual(word_data_start["book_id"], 1)
        self.assertEqual(word_data_start["chapter_id"], 0)
        self.assertEqual(word_data_start["verse_id"], 1)

        # Test for 23:59:59
        word_data_end, _ = get_current_word_data("23:59:59")
        self.assertEqual(word_data_end["book_id"], 39)
        self.assertEqual(word_data_end["chapter_id"], 35)
        self.assertEqual(word_data_end["verse_id"], 23)

if __name__ == '__main__':
    # Run tests first
    suite = unittest.TestLoader().loadTestsFromTestCase(TestWordIndex)
    unittest.TextTestRunner().run(suite)

    iface.launch(share=True)