import requests
import pyttsx3
import time
import logging

"""
Bitcoin Price TTS

This script continuously fetches the current Bitcoin price from the Binance public API and announces it
using text-to-speech with a feminine voice. The RateLimiter class controls the request rate to adhere
to any rate limits imposed by the API.

To run this script, be sure to install the required modules:

    1. requests: Used for making HTTP requests.
       Install with: pip install requests

    2. pyttsx3: Text-to-speech library for Python.
       Install with: pip install pyttsx3

Author: J2897 with help from ChatGPT.
"""

sleep_time = 30   # Adjust the sleep time as needed
segmented = True  # Only say the price in $10 segments (less specific, but quieter during low volatility).

# Set up logging configuration to exclude INFO messages
logging.basicConfig(level=logging.WARNING)

class RateLimiter:
    def __init__(self, rate_limit):
        """
        Initializes the RateLimiter with a specified rate limit.
        :param rate_limit: The time interval (in seconds) between consecutive requests.
        """
        self.rate_limit = rate_limit
        self.last_request_time = 0
    def wait(self):
        """
        Enforces rate limiting by pausing the execution if the time since the last request
        is less than the specified rate limit.
        """
        current_time = time.time()
        time_since_last_request = current_time - self.last_request_time
        if time_since_last_request < self.rate_limit:
            time.sleep(self.rate_limit - time_since_last_request)
        self.last_request_time = time.time()

def get_bitcoin_price(rate_limiter):
    """
    Fetches the current Bitcoin price from the Binance public API.
    :param rate_limiter: An instance of the RateLimiter class to control the request rate.
    :return: The current Bitcoin price or None if an error occurs.
    """
    symbol = "BTCUSDT"
    binance_api_url = f"https://api.binance.com/api/v3/ticker/price?symbol={symbol}"
    try:
        # Enforce rate limiting
        rate_limiter.wait()
        response = requests.get(binance_api_url)
        response.raise_for_status()  # Raise an HTTPError for bad responses
        data = response.json()
        # Check if the response contains the required data
        if 'symbol' in data and 'price' in data:
            return float(data['price'])
        else:
            logging.ERROR("Unexpected data structure in the Binance ticker response.")
            return None
    except requests.exceptions.RequestException as err:
        logging.ERROR(f"Request failed: {err}")
        return None

def speak_price(price, voice_index=0):
    """
    Announces the Bitcoin price using text-to-speech.
    :param price: The Bitcoin price to be announced.
    :param voice_index: Index of the voice (default is 1, often a female voice).
    """
    engine = pyttsx3.init()
    voices = engine.getProperty('voices')
    if 0 <= voice_index < len(voices):
        engine.setProperty('voice', voices[voice_index].id)
    else:
        logging.WARNING("Invalid voice index. Using the default voice.")
    price_str = f"{int(price)}"
    engine.say(price_str)
    engine.runAndWait()

def main():
    """
    Main function to continuously fetch and announce the Bitcoin price.
    """
    rate_limiter = RateLimiter(rate_limit=1)  # Set a rate limit of 1 second for Binance
    last_price = get_bitcoin_price(rate_limiter)  # Update last_price for the first iteration
    while True:
        current_price = get_bitcoin_price(rate_limiter)
        if current_price is not None:
            current_price_seg = int(current_price / 10)
            last_price_seg = int(last_price / 10)
            print(f"The current Bitcoin price is ${current_price:.2f}")
            if segmented:
                if current_price_seg != last_price_seg:
                    speak_price(current_price_seg * 10, voice_index=0)
            else:
                speak_price(current_price, voice_index=1)
            last_price = current_price  # Update last_price for the next iteration
        time.sleep(sleep_time)

if __name__ == "__main__":
    main()