# Install necessary libraries
!pip install python-telegram-bot==20.3 --quiet
!pip install pandas numpy matplotlib seaborn --quiet
!pip install python-dotenv --quiet

import os

# Securely store your API key and bot token
# In Colab, add them to the secrets manager under the "🔑" in the left panel.
# Give them the names `TELEGRAM_BOT_TOKEN` and `TELEGRAM_CHAT_ID`.
# These will be accessed via os.environ.get().

# Standard Library Imports
import logging
import time
import random
from collections import deque
import os

# Third-party Library Imports
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes
from dotenv import load_dotenv

def create_logger(name: str, level: int = logging.INFO) -> logging.Logger:
    """
    Initializes and returns a logger instance.

    Parameters
    ----------
    name : str
        The name of the logger.
    level : int, optional
        The logging level (e.g., logging.INFO, logging.DEBUG), defaults to logging.INFO.

    Returns
    -------
    logging.Logger
        An initialized logger instance.
    """
    logger = logging.getLogger(name)
    logger.setLevel(level)
    if not logger.handlers:
        handler = logging.StreamHandler()
        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
        handler.setFormatter(formatter)
        logger.addHandler(handler)
    return logger

logger = create_logger("TelegramAlerts")
logger.info("Logger initialized.")

def create_telegram_bot(bot_token: str) -> Application:
    """
    Initializes and configures the Telegram bot application.

    Parameters
    ----------
    bot_token : str
        The authentication token for the Telegram bot.

    Returns
    -------
    Application
        An initialized Telegram bot application instance.
    """
    logger.info("Attempting to create Telegram bot application.")
    try:
        application = Application.builder().token(bot_token).build()
        logger.info("Telegram bot application created successfully.")
        return application
    except Exception as e:
        logger.error(f"Failed to create Telegram bot application: {e}")
        raise

async def send_telegram_message(app: Application, chat_id: str, message: str, retries: int = 3, initial_delay: float = 1.0) -> bool:
    """
    Sends a text message to a specified Telegram chat ID with retry logic.

    Parameters
    ----------
    app : Application
        The initialized Telegram bot application.
    chat_id : str
        The ID of the Telegram chat to send the message to.
    message : str
        The text message to be sent.
    retries : int, optional
        The number of retries in case of failure, defaults to 3.
    initial_delay : float, optional
        The initial delay in seconds for exponential backoff, defaults to 1.0.

    Returns
    -------
    bool
        True if the message was sent successfully, False otherwise.
    """
    logger.info(f"Attempting to send message to chat_id {chat_id} with {retries} retries.")
    for i in range(retries):
        try:
            await app.bot.send_message(chat_id=chat_id, text=message)
            logger.info(f"Message successfully sent to chat_id {chat_id}.")
            return True
        except Exception as e:
            delay = initial_delay * (2 ** i) + random.uniform(0, 1) # Exponential backoff with jitter
            logger.warning(f"Attempt {i+1}/{retries} failed to send message to chat_id {chat_id}: {e}. Retrying in {delay:.2f} seconds...")
            if i < retries - 1:
                time.sleep(delay)
    logger.error(f"Failed to send message to chat_id {chat_id} after {retries} attempts.")
    return False

def create_market_data_state(num_data_points: int = 100, initial_price: float = 100.0, volatility: float = 0.001) -> dict:
    """
    Initializes the state for simulating market data.

    Parameters
    ----------
    num_data_points : int, optional
        The maximum number of historical data points to keep, defaults to 100.
    initial_price : float, optional
        The starting price for the simulation, defaults to 100.0.
    volatility : float, optional
        The volatility factor for price movements, defaults to 0.001.

    Returns
    -------
    dict
        A dictionary representing the initial market data state.
    """
    logger.info("Creating initial market data state.")
    state = {
        "prices": deque(maxlen=num_data_points),
        "initial_price": initial_price,
        "current_price": initial_price,
        "volatility": volatility,
        "num_data_points": num_data_points
    }
    logger.debug(f"Market data state initialized: {state}")
    return state

def simulate_price_movement(state: dict) -> dict:
    """
    Simulates a single step of price movement.

    Parameters
    ----------
    state : dict
        The current market data state dictionary.

    Returns
    -------
    dict
        The updated market data state dictionary with the new price.
    """
    current_price = state["current_price"]
    volatility = state["volatility"]

    # Simulate a random walk for the price
    price_change = current_price * volatility * np.random.normal()
    new_price = max(0.01, current_price + price_change) # Ensure price doesn't go below a minimal value

    state["prices"].append(new_price)
    state["current_price"] = new_price

    logger.debug(f"Simulated price movement: Old price {current_price:.2f}, New price {new_price:.2f}")
    return state

def create_alert_state(upper_threshold: float = 105.0, lower_threshold: float = 95.0, window_size: int = 5) -> dict:
    """
    Initializes the state for managing trade alert configurations.

    Parameters
    ----------
    upper_threshold : float, optional
        The price level above which an alert should be triggered, defaults to 105.0.
    lower_threshold : float, optional
        The price level below which an alert should be triggered, defaults to 95.0.
    window_size : int, optional
        The number of recent data points to consider for alert conditions, defaults to 5.

    Returns
    -------
    dict
        A dictionary representing the initial alert state.
    """
    logger.info("Creating initial alert state.")
    state = {
        "upper_threshold": upper_threshold,
        "lower_threshold": lower_threshold,
        "window_size": window_size,
        "last_alert_price": None,
        "last_alert_time": None
    }
    logger.debug(f"Alert state initialized: {state}")
    return state

def check_price_alert(market_data_state: dict, alert_state: dict, cooldown_minutes: int = 5) -> tuple[bool, str]:
    """
    Checks if the current price crosses alert thresholds and if an alert should be sent.

    Parameters
    ----------
    market_data_state : dict
        The current market data state dictionary.
    alert_state : dict
        The current alert configuration state dictionary.
    cooldown_minutes : int, optional
        Minimum minutes between alerts for the same threshold, defaults to 5.

    Returns
    -------
    tuple[bool, str]
        A tuple where the first element indicates if an alert should be sent (True/False)
        and the second element is the alert message (empty string if no alert).
    """
    current_price = market_data_state["current_price"]
    upper_threshold = alert_state["upper_threshold"]
    lower_threshold = alert_state["lower_threshold"]
    last_alert_time = alert_state["last_alert_time"]
    alert_message = ""
    send_alert = False

    current_time = time.time()
    # Check cooldown period
    if last_alert_time and (current_time - last_alert_time) < cooldown_minutes * 60:
        logger.debug(f"In cooldown period. Next alert possible in {int(cooldown_minutes * 60 - (current_time - last_alert_time))} seconds.")
        return False, ""

    if current_price >= upper_threshold:
        alert_message = f"🚨 Price Alert: Price of {current_price:.2f} is at or above upper threshold of {upper_threshold:.2f}!"
        send_alert = True
        logger.info(alert_message)
    elif current_price <= lower_threshold:
        alert_message = f"📉 Price Alert: Price of {current_price:.2f} is at or below lower threshold of {lower_threshold:.2f}!"
        send_alert = True
        logger.info(alert_message)
    else:
        logger.debug(f"Price {current_price:.2f} is within thresholds ({lower_threshold:.2f}-{upper_threshold:.2f}). No alert.")

    if send_alert:
        alert_state["last_alert_price"] = current_price
        alert_state["last_alert_time"] = current_time

    return send_alert, alert_message

async def monitor_market_for_alerts(telegram_app: Application, chat_id: str, market_data_state: dict, alert_state: dict, iterations: int = 50, sleep_time: float = 0.5) -> dict:
    """
    Monitors simulated market data, checks for alerts, and sends Telegram notifications.

    Parameters
    ----------
    telegram_app : Application
        The initialized Telegram bot application.
    chat_id : str
        The Telegram chat ID to send alerts to.
    market_data_state : dict
        The current market data state dictionary.
    alert_state : dict
        The current alert configuration state dictionary.
    iterations : int, optional
        The number of simulation steps to run, defaults to 50.
    sleep_time : float, optional
        The time in seconds to pause between iterations, defaults to 0.5.

    Returns
    -------
    dict
        The final market data state after monitoring.
    """
    logger.info(f"Starting market monitoring for {iterations} iterations...")
    for i in range(iterations):
        market_data_state = simulate_price_movement(market_data_state)
        current_price = market_data_state["current_price"]
        logger.debug(f"Iteration {i+1}: Current Price = {current_price:.2f}")

        send_alert, alert_message = check_price_alert(market_data_state, alert_state)

        if send_alert:
            logger.info(f"Sending Telegram alert: {alert_message}")
            await send_telegram_message(telegram_app, chat_id, alert_message)

        time.sleep(sleep_time + random.uniform(0, 0.1)) # Add small jitter

    logger.info("Market monitoring finished.")
    return market_data_state

# Load environment variables from .env file (if running locally)
load_dotenv()

# --- Configuration --- #
# IMPORTANT: Replace with your actual Bot Token and Chat ID from Colab Secrets
# Go to the '🔑' icon on the left panel, click 'Add new secret'.
# Key: TELEGRAM_BOT_TOKEN, Value: Your Bot Token
# Key: TELEGRAM_CHAT_ID, Value: Your Chat ID
TELEGRAM_BOT_TOKEN = os.environ.get("TELEGRAM_BOT_TOKEN", "YOUR_TELEGRAM_BOT_TOKEN")
TELEGRAM_CHAT_ID = os.environ.get("TELEGRAM_CHAT_ID", "YOUR_TELEGRAM_CHAT_ID") # Your user ID or group chat ID

# Simulation parameters
SIMULATION_ITERATIONS = 100
SIMULATION_SLEEP_TIME = 0.1
INITIAL_PRICE = 100.0
VOLATILITY = 0.005
UPPER_THRESHOLD = 105.0
LOWER_THRESHOLD = 95.0
ALERT_COOLDOWN_MINUTES = 2 # Cooldown for alerts

# --- Initialize States ---
logger.info("Initializing application states...")

# Initialize Telegram Bot Application
try:
    # Use a dummy token if the actual one is not set for local testing without sending messages
    if TELEGRAM_BOT_TOKEN == "YOUR_TELEGRAM_BOT_TOKEN" or TELEGRAM_CHAT_ID == "YOUR_TELEGRAM_CHAT_ID":
        logger.warning("Telegram BOT_TOKEN or CHAT_ID not set in environment variables/Colab Secrets. Telegram messages will not be sent.")
        # Create a mock application if no token is provided to allow the simulation to run
        class MockBot:
            async def send_message(self, chat_id, text):
                logger.info(f"[MOCK TELEGRAM] Sending message to {chat_id}: {text}")
        class MockApplication:
            def __init__(self):
                self.bot = MockBot()
        telegram_app = MockApplication()
    else:
        telegram_app = create_telegram_bot(TELEGRAM_BOT_TOKEN)
    logger.info("Telegram application initialized (or mocked).")
except Exception as e:
    logger.error(f"Error initializing Telegram application: {e}")
    telegram_app = None # Ensure telegram_app is None if initialization fails

# Initialize Market Data State
market_data_state = create_market_data_state(initial_price=INITIAL_PRICE, volatility=VOLATILITY)

# Initialize Alert State
alert_state = create_alert_state(upper_threshold=UPPER_THRESHOLD, lower_threshold=LOWER_THRESHOLD)

logger.info("All states initialized.")

# Ensure telegram_app is not None before attempting to run the monitoring
if telegram_app:
    # Run the monitoring simulation
    final_market_data_state = await monitor_market_for_alerts(
        telegram_app=telegram_app,
        chat_id=TELEGRAM_CHAT_ID,
        market_data_state=market_data_state,
        alert_state=alert_state,
        iterations=SIMULATION_ITERATIONS,
        sleep_time=SIMULATION_SLEEP_TIME
    )
    logger.info("Simulation and monitoring completed.")
else:
    logger.error("Telegram application not initialized. Cannot run monitoring simulation.")
    final_market_data_state = market_data_state # Return the current state even if app is None

prices = list(final_market_data_state["prices"])
iterations_ran = len(prices)

if iterations_ran > 0:
    plt.figure(figsize=(12, 6))
    plt.plot(prices, label='Simulated Price', color='blue')
    plt.axhline(y=alert_state["upper_threshold"], color='red', linestyle='--', label=f'Upper Threshold ({alert_state["upper_threshold"]:.2f})')
    plt.axhline(y=alert_state["lower_threshold"], color='green', linestyle='--', label=f'Lower Threshold ({alert_state["lower_threshold"]:.2f})')

    plt.title('Simulated Price Movement with Alert Thresholds')
    plt.xlabel('Time Steps')
    plt.ylabel('Price')
    plt.legend()
    plt.grid(True)
    plt.show()
else:
    logger.warning("No price data to plot. Simulation might not have run.")