app.py

import json
import logging
import datetime
import time
import requests
import pytz
import unittest

import gradio as gr
from utils import process_json_files, flatten_text_with_line_breaks, calculate_tanach_statistics, build_word_index

import logging
from deep_translator import GoogleTranslator
from deep_translator.exceptions import NotValidLength, RequestError

# 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)

    # Highlight the word *before* joining with <br>
    if highlight_word and 0 <= verse_id - 1 < len(flattened_chapter):
        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, highlight_word=True):
    """Translates a Hebrew verse to English, splitting into chunks if necessary."""
    try:
        translator = GoogleTranslator(source='iw', target='en')
        max_length = 2000  # Slightly below the limit to be safe
        translated_text = ""

        # Split the verse into chunks smaller than the max length
        chunks = [hebrew_verse[i:i + max_length] for i in range(0, len(hebrew_verse), max_length)]

        for chunk_index, chunk in enumerate(chunks):
            # Translate the current chunk
            translated_chunk = translator.translate(chunk)

            # If it's not the first chunk, find the last line break and start from there
            if chunk_index > 0:
                last_line_break = translated_chunk.rfind('<br>', 0, 100) # Find last <br> in first 100 chars
                if last_line_break != -1:
                    translated_text += translated_chunk[last_line_break + 4:] # Add from after <br>
                else:
                    translated_text += translated_chunk
            else:
                translated_text += translated_chunk

        return translated_text

    except RequestError as e:
        logging.warning(f"Translation failed: Request Error - {e}")
        return "Translation unavailable: Request Error"


# --- Gradio Interface ---

def update_tanach_display(client_time_str, timezone):
    """Updates the Gradio interface with client time, verse info, and translations."""
    try:
        # Get timezone offset using pytz
        tz = pytz.timezone(timezone)
        offset = tz.utcoffset(datetime.datetime.now()).total_seconds() / 3600  # Offset in hours

        # Adjust client time based on the timezone
        client_time_obj = datetime.datetime.strptime(client_time_str, "%H:%M:%S")
        client_time_obj = client_time_obj.replace(tzinfo=datetime.timezone(datetime.timedelta(hours=offset)))
        client_time_str = client_time_obj.strftime("%H:%M:%S")
    except Exception as e:
        logging.error(f"Error adjusting client time based on timezone: {e}")
        return "Error: Invalid Timezone", "", ""

    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>')), highlight_word=False)

    return verse_info, hebrew_verse, english_verse


# --- Gradio Interface ---

with gr.Blocks(css="""
 .container {
 display: flex;
 flex-direction: column;
 align-items: center;
 font-family: 'Times New Roman', serif;
 }
 /* Add this highlight class styling */
 .highlight {
 background-color: #FFFF00; /* Yellow highlight */
 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():
        timezone_input = gr.Dropdown(
          choices=[tz for tz in pytz.common_timezones],
          label="Select Your Timezone",
          value="UTC"  # Set a default timezone
        )

    with gr.Row():
        advance_button = gr.Button("Advance to Current Time")

    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")

    # Update the display with verse information and translations when the button is clicked
    advance_button.click(
        fn=lambda tz: update_tanach_display(datetime.datetime.now(pytz.timezone(tz)).strftime("%H:%M:%S"), tz),
        inputs=[timezone_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)