import urllib.request
from urllib.error import URLError, HTTPError
import json
import asyncio
from azure.eventhub import EventData
from azure.eventhub.aio import EventHubProducerClient
import time
from datetime import datetime

ticker_price_url = "https://api.binance.com/api/v3/ticker/price"
server_time_url = "https://api.binance.com/api/v3/time"

EVENT_HUB_NAME = "es_XXX"
EVENT_HUB_CONNECTION_STR = "Endpoint=sb://XXX.servicebus.windows.net/;SharedAccessKeyName=key_XXX;SharedAccessKey=XXX;EntityPath=es_XXX"

SEND_INTERVAL_SECONDS = 1

def fetch_api_data(url):
    try:
        with urllib.request.urlopen(url, timeout=10) as response:
            if response.status == 200:
                return json.loads(response.read().decode('utf-8'))
            else:
                print(f"Error: Received status code {response.status} from {url}")
                return None
    except (HTTPError, URLError) as e:
        print(f"Error fetching data from {url}: {e}")
        return None
    except Exception as e:
        print(f"An unexpected error occurred while fetching data from {url}: {e}")
        return None

async def process_and_send_data(producer):
    server_time_data = fetch_api_data(server_time_url)
    ticker_price_data = fetch_api_data(ticker_price_url)

    if not server_time_data or 'serverTime' not in server_time_data:
        print("Error: No se pudo obtener la hora del servidor de Binance.")
        return False
    if not ticker_price_data or not isinstance(ticker_price_data, list):
        print("Error: No se pudieron obtener los datos de precios o el formato es incorrecto.")
        return False

    server_time = server_time_data['serverTime']

    events_to_send = []
    for ticker in ticker_price_data:
        if 'symbol' in ticker and 'price' in ticker:
            restructured_event = {
                "serverTime": server_time,
                "tickerInfo": {
                    "symbol": ticker['symbol'],
                    "price": ticker['price']
                }
            }
            events_to_send.append(restructured_event)

    if not events_to_send:
        print("No valid events were restructured to be sent in this cycle.")
        return False

    try:
        event_data_batch = await producer.create_batch()
        event_count_in_batch = 0

        for event_payload in events_to_send:
            event_body_str = json.dumps(event_payload)
            event_data = EventData(event_body_str)
            try:
                event_data_batch.add(event_data)
                event_count_in_batch += 1
            except ValueError:
                if event_count_in_batch > 0:
                    await producer.send_batch(event_data_batch)
                else:
                     print(f"Warning: Single event is too large to fit in a batch: {len(event_body_str)} bytes.")
                     continue

                event_data_batch = await producer.create_batch()
                event_data_batch.add(event_data)
                event_count_in_batch = 1

        if event_count_in_batch > 0:
            await producer.send_batch(event_data_batch)

        print(f"Successfully sent {len(events_to_send)} events to Event Hub '{EVENT_HUB_NAME}'.")
        return True

    except Exception as e:
        print(f"An error occurred during Event Hub send: {e}")
        return False


async def main_loop():
    producer = EventHubProducerClient.from_connection_string(
        conn_str=EVENT_HUB_CONNECTION_STR,
        eventhub_name=EVENT_HUB_NAME
    )

    while True:
        start_time = time.time()
        print(f"--- [{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] Starting data fetch and send cycle ---")

        try:
            success = await process_and_send_data(producer)
            if success:
                print(f"--- Cycle finished successfully ---")
            else:
                print(f"--- Cycle finished with errors (check logs above) ---")

        except Exception as e:
            print(f"--- FATAL ERROR in cycle: {e} ---")

        end_time = time.time()
        elapsed_time = end_time - start_time
        wait_time = max(0, SEND_INTERVAL_SECONDS - elapsed_time)

        print(f"--- Cycle duration: {elapsed_time:.2f} seconds. Waiting for {wait_time:.2f} seconds before next cycle ---")
        await asyncio.sleep(wait_time)

if __name__ == "__main__":
    if EVENT_HUB_CONNECTION_STR == "TU_CADENA_DE_CONEXION_EVENT_HUB" or EVENT_HUB_NAME == "TU_NOMBRE_DE_EVENT_HUB":
        print("ERROR: Por favor, actualiza las variables EVENT_HUB_CONNECTION_STR y EVENT_HUB_NAME con tus valores reales.")
    else:
        try:
            print(f"Starting continuous data sending every {SEND_INTERVAL_SECONDS} seconds...")
            print(f"Target Event Hub: {EVENT_HUB_NAME}")
            print("Press Ctrl+C to stop.")
            asyncio.run(main_loop())
        except KeyboardInterrupt:
            print("\nExecution stopped by user (Ctrl+C).")
        except Exception as e:
            print(f"\nAn unexpected error stopped the execution: {e}")
            exit(1)