import MetaTrader5 as mt5
import pandas as pd
import pytz
import time as sleep_timer
from datetime import datetime, timedelta, time
import logging
import json
import requests
import sqlite3
import threading

# ==============================================================================
# == CONFIGURATION & LOGGING
# ==============================================================================
def load_config(filename='config.json'):
    try:
        with open(filename, 'r') as f: return json.load(f)
    except FileNotFoundError:
        logging.critical(f"CRITICAL: Config file '{filename}' not found.")
        quit()
    except json.JSONDecodeError:
        logging.critical(f"CRITICAL: Config file '{filename}' is not valid JSON.")
        quit()

def setup_logging():
    if logging.getLogger().hasHandlers(): return
    class ESTFormatter(logging.Formatter):
        def formatTime(self, record, datefmt=None):
            dt = datetime.fromtimestamp(record.created, tz=pytz.timezone('America/New_York'))
            if datefmt: return dt.strftime(datefmt)
            return dt.isoformat()
    logger = logging.getLogger()
    logger.setLevel(logging.INFO)
    formatter = ESTFormatter('%(asctime)s - %(levelname)s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
    console_handler = logging.StreamHandler()
    console_handler.setFormatter(formatter)
    file_handler = logging.FileHandler('trading_bot.log', encoding='utf-8')
    file_handler.setFormatter(formatter)
    logger.addHandler(console_handler)
    logger.addHandler(file_handler)

# ==============================================================================
# == STATE MANAGER CLASS (SQLite VERSION)
# ==============================================================================
class StateManager:
    def __init__(self, db_file='bot_state.db'):
        self.db_file = db_file
        self.conn = sqlite3.connect(self.db_file, detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES, check_same_thread=False)
        self._create_tables()

    def _create_tables(self):
        cursor = self.conn.cursor()
        cursor.execute("CREATE TABLE IF NOT EXISTS traded_setups (id INTEGER PRIMARY KEY AUTOINCREMENT, setup_id TEXT UNIQUE NOT NULL)")
        cursor.execute("CREATE TABLE IF NOT EXISTS pending_orders (ticket INTEGER PRIMARY KEY, symbol TEXT NOT NULL, expiry_time TEXT NOT NULL)")
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS trades (
                ticket INTEGER PRIMARY KEY, symbol TEXT NOT NULL, type TEXT NOT NULL,
                volume REAL NOT NULL, open_time TIMESTAMP NOT NULL, open_price REAL NOT NULL,
                sl REAL NOT NULL, tp REAL NOT NULL, close_time TIMESTAMP, close_price REAL,
                profit REAL, partials_taken INTEGER DEFAULT 0
            )''')
        cursor.execute("CREATE TABLE IF NOT EXISTS bot_settings (key TEXT PRIMARY KEY, value TEXT)")
        self.conn.commit()

    def get_setting(self, key):
        cursor = self.conn.cursor()
        cursor.execute("SELECT value FROM bot_settings WHERE key = ?", (key,))
        row = cursor.fetchone()
        return row[0] if row else None

    def set_setting(self, key, value):
        cursor = self.conn.cursor()
        cursor.execute("INSERT OR REPLACE INTO bot_settings (key, value) VALUES (?, ?)", (key, value))
        self.conn.commit()

    def get_performance_report(self):
        try:
            df = pd.read_sql_query("SELECT * FROM trades WHERE close_time IS NOT NULL", self.conn)
            if df.empty: return None
            total_trades, wins, losses = len(df), len(df[df['profit'] > 0.01]), len(df[df['profit'] < -0.01])
            breakevens = total_trades - wins - losses
            win_rate = (wins / (wins + losses) * 100) if (wins + losses) > 0 else 0
            total_profit, gross_profit, gross_loss = df['profit'].sum(), df[df['profit'] > 0]['profit'].sum(), abs(df[df['profit'] < 0]['profit'].sum())
            profit_factor = gross_profit / gross_loss if gross_loss > 0 else float('inf')
            return {"total_trades": total_trades, "wins": wins, "losses": losses, "breakevens": breakevens, "win_rate": f"{win_rate:.2f}%", "net_profit": f"${total_profit:,.2f}", "profit_factor": f"{profit_factor:.2f}"}
        except Exception as e:
            logging.error(f"Error generating performance report: {e}")
            return None
    
    def get_open_trade_tickets(self):
        cursor = self.conn.cursor()
        cursor.execute("SELECT ticket FROM trades WHERE close_time IS NULL")
        return [row[0] for row in cursor.fetchall()]

    def log_new_trade(self, pos):
        cursor = self.conn.cursor()
        trade_type = "BUY" if pos.type == mt5.ORDER_TYPE_BUY else "SELL"
        cursor.execute("INSERT OR IGNORE INTO trades (ticket, symbol, type, volume, open_time, open_price, sl, tp) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
                       (pos.ticket, pos.symbol, trade_type, pos.volume, datetime.fromtimestamp(pos.time, tz=pytz.utc), pos.price_open, pos.sl, pos.tp))
        self.conn.commit()

    def update_trade_partials_taken(self, ticket):
        cursor = self.conn.cursor()
        cursor.execute("UPDATE trades SET partials_taken = 1 WHERE ticket = ?", (ticket,))
        self.conn.commit()
    
    def update_closed_trade(self, ticket, close_time, close_price, profit):
        cursor = self.conn.cursor()
        cursor.execute("UPDATE trades SET close_time = ?, close_price = ?, profit = ? WHERE ticket = ?",
                       (close_time, close_price, profit, ticket))
        self.conn.commit()

    def get_trade_info(self, ticket):
        cursor = self.conn.cursor()
        cursor.execute("SELECT partials_taken FROM trades WHERE ticket = ?", (ticket,))
        row = cursor.fetchone()
        if row: return {'partials_taken': row[0]}
        return None

    def get_traded_setups(self):
        cursor = self.conn.cursor()
        cursor.execute("SELECT setup_id FROM traded_setups")
        return [row[0] for row in cursor.fetchall()]

    def add_traded_setup(self, setup_id):
        cursor = self.conn.cursor()
        cursor.execute("INSERT OR IGNORE INTO traded_setups (setup_id) VALUES (?)", (setup_id,))
        cursor.execute("DELETE FROM traded_setups WHERE id NOT IN (SELECT id FROM traded_setups ORDER BY id DESC LIMIT 10)")
        self.conn.commit()

    def get_pending_orders(self):
        cursor = self.conn.cursor()
        cursor.execute("SELECT ticket, symbol, expiry_time FROM pending_orders")
        orders = {}
        ny_tz = pytz.timezone('America/New_York')
        for row in cursor.fetchall():
            try:
                expiry_dt_naive = datetime.fromisoformat(row[2])
                orders[str(row[0])] = {"symbol": row[1], "expiry_time": ny_tz.localize(expiry_dt_naive)}
            except (ValueError, TypeError):
                logging.error(f"Could not parse expiry time '{row[2]}' for ticket {row[0]}")
        return orders

    def add_pending_order(self, ticket, symbol, expiry_time):
        cursor = self.conn.cursor()
        cursor.execute("INSERT OR IGNORE INTO pending_orders (ticket, symbol, expiry_time) VALUES (?, ?, ?)",
                       (ticket, symbol, expiry_time.strftime('%Y-%m-%dT%H:%M:%S')))
        self.conn.commit()
        
    def remove_pending_order(self, ticket):
        cursor = self.conn.cursor()
        cursor.execute("DELETE FROM pending_orders WHERE ticket = ?", (int(ticket),))
        self.conn.commit()

    def close_connection(self):
        self.conn.close()
        logging.info("\nDatabase connection closed.")

# ==============================================================================
# == STRATEGY CLASS
# ==============================================================================
class BreakerStrategy:
    def __init__(self, config):
        self.config = config

    def _find_swing_points(self, df):
        df = df.copy()
        df['is_swing_high'] = (df['High'] > df['High'].shift(1)) & (df['High'] > df['High'].shift(-1)) & (df['High'] > df['High'].shift(-2))
        df['is_swing_low'] = (df['Low'] < df['Low'].shift(1)) & (df['Low'] < df['Low'].shift(-1)) & (df['Low'] < df['Low'].shift(-2))
        return df

    def find_htf_zones(self, h1_df):
        h1_df_recent = h1_df.tail(20)
        zones = []
        df_swing = self._find_swing_points(h1_df_recent.copy())
        
        for i in range(4, len(df_swing) - 1):
            c1, c2, c3, v_candle = df_swing.iloc[i-4], df_swing.iloc[i-3], df_swing.iloc[i-2], df_swing.iloc[i-1]
            ob_candle = None
            if c2['Close']>c2['Open'] and c3['Close']<c3['Open']: ob_candle=c3
            elif c2['Close']<c2['Open'] and c3['Close']<c3['Open'] and c2['is_swing_high']: ob_candle=c3
            if ob_candle is not None and v_candle['Close']>ob_candle['Open']:
                zones.append({'type': 'Bullish OB', 'time': v_candle.name, 'low': ob_candle['Low'], 'high': ob_candle['High']})
            ob_candle=None
            if c2['Close']<c2['Open'] and c3['Close']>c3['Open']: ob_candle=c3
            elif c2['Close']>c2['Open'] and c3['Close']>c3['Open'] and c2['is_swing_low']: ob_candle=c3
            if ob_candle is not None and v_candle['Close']<ob_candle['Open']:
                zones.append({'type': 'Bearish OB', 'time': v_candle.name, 'low': ob_candle['Low'], 'high': ob_candle['High']})

        for i in range(2, len(h1_df_recent) - 1):
            c1, _, c3 = h1_df_recent.iloc[i-2], h1_df_recent.iloc[i-1], h1_df_recent.iloc[i]
            if c3['Low']>c1['High']:
                zones.append({'type': 'Bullish FVG', 'time': c3.name, 'low': c1['High'], 'high': c3['Low']})
            if c3['High']<c1['Low']:
                zones.append({'type': 'Bearish FVG', 'time': c3.name, 'low': c3['High'], 'high': c1['Low']})
        return zones

    def _find_breaker_setup(self, df_slice):
        df_with_swings = self._find_swing_points(df_slice)
        swing_highs = df_with_swings[df_with_swings['is_swing_high']]
        swing_lows = df_with_swings[df_with_swings['is_swing_low']]
        
        for i in range(len(swing_highs)): # Bearish
            pointA = swing_highs.iloc[i]
            potential_Bs = swing_lows[swing_lows.index > pointA.name]
            if not potential_Bs.empty:
                pointB = potential_Bs.iloc[0]
                breaker_range = df_with_swings.loc[pointA.name:pointB.name]
                down_candles = breaker_range[breaker_range['Close'] < breaker_range['Open']]
                if down_candles.empty: continue
                breaker_candle = down_candles.loc[down_candles['Low'].idxmin()]
                sweep_candidates = df_slice[(df_slice.index > pointB.name) & (df_slice['High'] > pointA.High)]
                if not sweep_candidates.empty:
                    pointC = sweep_candidates.iloc[0]
                    if not df_with_swings.loc[pointB.name:pointC.name].iloc[1:-1]['is_swing_high'].any():
                        confirmation_window = df_slice[df_slice.index > pointC.name].iloc[:2]
                        if not confirmation_window.empty and confirmation_window.iloc[0]['Close'] < breaker_candle.Low:
                            pointD = confirmation_window.iloc[0]
                            if not breaker_candle.is_swing_high:
                                return {'type': 'Bearish', 'breaker_candle': breaker_candle, 'pointA': pointA, 'pointB': pointB, 'pointC': pointC, 'pointD': pointD}
        for i in range(len(swing_lows)): # Bullish
            pointA = swing_lows.iloc[i]
            potential_Bs = swing_highs[swing_highs.index > pointA.name]
            if not potential_Bs.empty:
                pointB = potential_Bs.iloc[0]
                breaker_range = df_with_swings.loc[pointA.name:pointB.name]
                up_candles = breaker_range[breaker_range['Close'] > breaker_range['Open']]
                if up_candles.empty: continue
                breaker_candle = up_candles.loc[up_candles['High'].idxmax()]
                sweep_candidates = df_slice[(df_slice.index > pointB.name) & (df_slice['Low'] < pointA.Low)]
                if not sweep_candidates.empty:
                    pointC = sweep_candidates.iloc[0]
                    if not df_with_swings.loc[pointB.name:pointC.name].iloc[1:-1]['is_swing_low'].any():
                        confirmation_window = df_slice[df_slice.index > pointC.name].iloc[:2]
                        if not confirmation_window.empty and confirmation_window.iloc[0]['Close'] > breaker_candle.High:
                            pointD = confirmation_window.iloc[0]
                            if not breaker_candle.is_swing_low:
                                return {'type': 'Bullish', 'breaker_candle': breaker_candle, 'pointA': pointA, 'pointB': pointB, 'pointC': pointC, 'pointD': pointD}
        return None

    def find_setups(self, all_tf_data):
        search_end_time = all_tf_data[1].index[-1]
        search_start_time = search_end_time - timedelta(minutes=120)
        for tf in [5, 1]:
            df = all_tf_data.get(tf)
            if df is None: continue
            analysis_slice = df.loc[search_start_time:search_end_time]
            if analysis_slice.empty or len(analysis_slice) < 5: continue
            breaker_setup = self._find_breaker_setup(analysis_slice)
            if breaker_setup:
                pointD_time = breaker_setup['pointD'].name
                if pointD_time >= df.index[-3]:
                    return breaker_setup, tf
        return None, None

# ==============================================================================
# == MT5 HANDLER CLASS
# ==============================================================================
class MT5Handler:
    def __init__(self, config):
        self.config = config
        self.magic_number = self.config.get('magic_number')

    def connect(self):
        if not mt5.initialize():
            logging.critical(f"initialize() failed, error code = {mt5.last_error()}")
            return False
        logging.info("✅ MT5 Bot Connected!")
        return True

    def disconnect(self):
        mt5.shutdown()
        logging.info("\n🔌 Bot stopped and disconnected.")

    def check_connection(self):
        if not mt5.terminal_info():
            logging.warning("\nMT5 connection lost. Attempting to reconnect...")
            mt5.shutdown()
            sleep_timer.sleep(10)
            if self.connect():
                logging.info("\nSuccessfully reconnected to MT5.")
                return True
            else:
                logging.error("\nFailed to reconnect to MT5. Will retry next cycle.")
                return False
        return True

    def get_all_timeframe_data(self, symbol):
        all_tf_data = {}
        timeframe_map = {1: mt5.TIMEFRAME_M1, 2: mt5.TIMEFRAME_M2, 3: mt5.TIMEFRAME_M3, 5: mt5.TIMEFRAME_M5, 60: mt5.TIMEFRAME_H1}
        for tf_int, tf_mt5 in timeframe_map.items():
            num_candles = 500 if tf_int == 60 else 300
            df = self._get_candles(symbol, tf_mt5, num_candles)
            if df is None or df.empty:
                logging.warning(f"Could not fetch M{tf_int} data for {symbol}.")
                return None
            all_tf_data[tf_int] = df
        return all_tf_data

    def _get_candles(self, symbol, timeframe, num_candles):
        rates = mt5.copy_rates_from_pos(symbol, timeframe, 0, num_candles)
        if rates is None: return None
        df = pd.DataFrame(rates)
        df['time'] = pd.to_datetime(df['time'], unit='s')
        df.set_index('time', inplace=True)
        df.index = df.index.tz_localize('Europe/Athens').tz_convert('America/New_York')
        df.rename(columns={'open': 'Open', 'high': 'High', 'low': 'Low', 'close': 'Close'}, inplace=True)
        return df

    def place_pending_order(self, symbol, order_type, volume, entry_price, sl_price, tp_price):
        symbol_info = mt5.symbol_info(symbol)
        if symbol_info is None:
            logging.error(f"Failed to get symbol info for {symbol}.")
            return None
        point = symbol_info.point
        stops_level = symbol_info.trade_stops_level
        min_distance = stops_level * point
        if abs(entry_price - sl_price) < min_distance or abs(entry_price - tp_price) < min_distance:
            logging.warning(f"\nSL/TP for {symbol} is too close to entry price (Broker minimum: {min_distance}). Trade skipped.")
            return None
        request = {
            "action": mt5.TRADE_ACTION_PENDING, "symbol": symbol, "volume": volume,
            "type": order_type, "price": entry_price, "sl": sl_price, "tp": tp_price,
            "magic": self.magic_number, "comment": "BreakerBot v3.2",
            "type_time": mt5.ORDER_TIME_GTC, "type_filling": mt5.ORDER_FILLING_FOK,
        }
        result = mt5.order_send(request)
        if result.retcode != mt5.TRADE_RETCODE_DONE:
            logging.warning(f"\nPending order failed for {symbol}: {result.comment}")
        else:
            logging.info(f"\n✅ Pending order placed for {symbol}! Order #{result.order}")
        return result

    def place_partial_close_order(self, position, volume_to_close):
        if position.type == mt5.ORDER_TYPE_BUY:
            order_type, price = mt5.ORDER_TYPE_SELL, mt5.symbol_info_tick(position.symbol).bid
        else:
            order_type, price = mt5.ORDER_TYPE_BUY, mt5.symbol_info_tick(position.symbol).ask
        request = {
            "action": mt5.TRADE_ACTION_DEAL, "position": position.ticket, "symbol": position.symbol,
            "volume": volume_to_close, "type": order_type, "price": price,
            "magic": self.magic_number, "comment": "Partial Take Profit"
        }
        result = mt5.order_send(request)
        if result and result.retcode == mt5.TRADE_RETCODE_DONE:
            logging.info(f"\n✅ Successfully closed {volume_to_close} lots of position #{position.ticket}.")
            return True
        else:
            logging.error(f"\n❌ Failed to close partial volume for position #{position.ticket}: {result.comment if result else 'No result'}")
            return False

    def modify_position_sl(self, ticket, new_sl):
        request = {"action": mt5.TRADE_ACTION_SLTP, "position": ticket, "sl": new_sl}
        result = mt5.order_send(request)
        if result and result.retcode == mt5.TRADE_RETCODE_DONE:
            logging.info(f"\n✅ Successfully moved SL for position #{ticket}.")
            return True
        else:
            logging.error(f"\n❌ Failed to modify SL for position #{ticket}: {result.comment if result else 'No result'}")
            return False

    def manage_open_trades(self, state_manager):
        positions = mt5.positions_get(magic=self.magic_number)
        if not positions: return
        for pos in positions:
            trade_info = state_manager.get_trade_info(pos.ticket)
            if trade_info and trade_info['partials_taken'] == 1:
                continue
            initial_risk = abs(pos.price_open - pos.sl)
            if initial_risk == 0: continue
            if pos.type == mt5.ORDER_TYPE_BUY:
                breakeven_trigger_price = pos.price_open + (initial_risk * 2)
                if mt5.symbol_info_tick(pos.symbol).bid >= breakeven_trigger_price:
                    self.handle_partial_tp_and_be(pos, state_manager)
            elif pos.type == mt5.ORDER_TYPE_SELL:
                breakeven_trigger_price = pos.price_open - (initial_risk * 2)
                if mt5.symbol_info_tick(pos.symbol).ask <= breakeven_trigger_price:
                    self.handle_partial_tp_and_be(pos, state_manager)

    def handle_partial_tp_and_be(self, position, state_manager):
        logging.info(f"\nPosition #{position.ticket} reached 2R. Taking partials and moving to BE.")
        symbol_info = mt5.symbol_info(position.symbol)
        partial_volume = round(position.volume * 0.3, 2)
        if partial_volume < symbol_info.volume_min: partial_volume = symbol_info.volume_min
        partial_volume = round(partial_volume / symbol_info.volume_step) * symbol_info.volume_step
        
        if partial_volume >= position.volume:
            logging.warning("\nPartial volume is >= position volume. Moving to BE only.")
            if self.modify_position_sl(position.ticket, position.price_open):
                state_manager.update_trade_partials_taken(position.ticket)
                message = f"📈 *Stop Loss Moved to Breakeven*\nSymbol: `{position.symbol}`\nPosition: `#{position.ticket}`"
                send_telegram_alert(message, self.config)
        else:
            if self.place_partial_close_order(position, partial_volume):
                self.modify_position_sl(position.ticket, position.price_open)
                state_manager.update_trade_partials_taken(position.ticket)
                message = f"💰 *Partial Profit Taken & BE*\nSymbol: `{position.symbol}`\nClosed: `{partial_volume}` lots\nPosition: `#{position.ticket}`"
                send_telegram_alert(message, self.config)
    
    def manage_pending_orders(self, state_manager):
        pending_orders = state_manager.get_pending_orders()
        if not pending_orders: return
        now_ny = datetime.now(pytz.timezone('America/New_York'))
        for ticket, order_data in list(pending_orders.items()):
            if now_ny > order_data['expiry_time']:
                logging.info(f"\nPending order #{ticket} for {order_data['symbol']} has expired. Attempting to cancel.")
                request = {"action": mt5.TRADE_ACTION_REMOVE, "order": int(ticket)}
                result = mt5.order_send(request)
                if result.retcode == mt5.TRADE_RETCODE_DONE:
                    logging.info(f"\n✅ Successfully cancelled expired order #{ticket}.")
                    state_manager.remove_pending_order(ticket)
                else:
                    if not mt5.orders_get(ticket=int(ticket)):
                        logging.info(f"\nOrder #{ticket} no longer exists. Removing from tracking.")
                        state_manager.remove_pending_order(ticket)
                    else:
                        logging.error(f"\nFailed to cancel expired order #{ticket}. Reason: {result.comment}")

# ==============================================================================
# == HELPER FUNCTIONS
# ==============================================================================
def send_telegram_alert(message, config):
    bot_token = config.get('telegram_bot_token')
    chat_id = config.get('telegram_chat_id')
    if not bot_token or not chat_id or 'YOUR_BOT_TOKEN' in bot_token: return
    url = f"https://api.telegram.org/bot{bot_token}/sendMessage"
    payload = {'chat_id': chat_id, 'text': message, 'parse_mode': 'Markdown'}
    try:
        response = requests.post(url, json=payload, timeout=10)
        if response.status_code != 200:
            logging.error(f"Failed to send Telegram alert: {response.text}")
    except Exception as e:
        logging.error(f"Exception while sending Telegram alert: {e}")

def format_breaker_details(breaker_setup):
    bc, pointA, pointB, pointC, pointD = breaker_setup['breaker_candle'], breaker_setup['pointA'], breaker_setup['pointB'], breaker_setup['pointC'], breaker_setup['pointD']
    a_marker, b_marker = ("-", "+") if breaker_setup['type'] == 'Bullish' else ("+", "-")
    c_marker = "+" if pointC['Close'] > pointC['Open'] else "-"
    details = (
        f"*Breaker Time:* `{bc.name.strftime('%H:%M:%S')}`\n"
        f"*Breaker Candle:* `[O:{bc['Open']:.5f} H:{bc['High']:.5f} L:{bc['Low']:.5f} C:{bc['Close']:.5f}]`\n"
        f"*Point A{a_marker}:* `{pointA.name.strftime('%H:%M:%S')}`\n"
        f"*Point B{b_marker}:* `{pointB.name.strftime('%H:%M:%S')}`\n"
        f"*Point C (Sweep){c_marker}:* `{pointC.name.strftime('%H:%M:%S')}`\n"
        f"*Point D (Confirmation):* `{pointD.name.strftime('%H:%M:%S')}`\n"
        f"*Confirmation Candle:* `[O:{pointD['Open']:.5f} H:{pointD['High']:.5f} L:{pointD['Low']:.5f} C:{pointD['Close']:.5f}]`"
    )
    return details

def calculate_dynamic_lot_size(symbol, risk_percent, sl_price, entry_price):
    try:
        account_info = mt5.account_info()
        if account_info is None: return None
        balance = account_info.balance
        risk_amount_account_currency = balance * risk_percent
        sl_distance_price = abs(entry_price - sl_price)
        if sl_distance_price == 0: return None
        symbol_info = mt5.symbol_info(symbol)
        if symbol_info is None: return None
        quote_currency = symbol_info.currency_profit
        account_currency = account_info.currency
        conversion_rate = 1.0
        if quote_currency != account_currency:
            pair_forward, pair_backward = f"{quote_currency}{account_currency}", f"{account_currency}{quote_currency}"
            tick_forward = mt5.symbol_info_tick(pair_forward)
            if tick_forward and tick_forward.ask != 0:
                conversion_rate = tick_forward.ask
            else:
                tick_backward = mt5.symbol_info_tick(pair_backward)
                if tick_backward and tick_backward.bid != 0:
                    conversion_rate = 1 / tick_backward.bid
                else:
                    logging.warning(f"\nCannot find conversion rate for {quote_currency} to {account_currency}.")
                    return None
        loss_in_quote_currency_per_lot = sl_distance_price * symbol_info.trade_contract_size
        loss_in_account_currency_per_lot = loss_in_quote_currency_per_lot * conversion_rate
        if loss_in_account_currency_per_lot == 0: return None
        lot_size = risk_amount_account_currency / loss_in_account_currency_per_lot
        volume_step, min_volume, max_volume = symbol_info.volume_step, symbol_info.volume_min, symbol_info.volume_max
        lot_size = max(min_volume, min(max_volume, lot_size))
        lot_size = round(lot_size / volume_step) * volume_step
        return round(lot_size, 2)
    except Exception as e:
        logging.error(f"\nError in lot size calculation: {e}", exc_info=True)
        return None

def is_in_trading_session(config):
    ny_tz = pytz.timezone('America/New_York')
    now_ny = datetime.now(ny_tz)
    current_time = now_ny.time()
    if now_ny.weekday() >= 5: return False
    sessions = config.get('trading_sessions', [])
    for session in sessions:
        try:
            start = time.fromisoformat(session['start'])
            end = time.fromisoformat(session['end'])
            if start <= current_time <= end:
                return True
        except (ValueError, KeyError):
            logging.warning(f"\nInvalid session format in config.json: {session}")
            continue
    return False
    
def check_and_log_new_trades(state_manager, magic_number):
    open_positions = mt5.positions_get(magic=magic_number)
    if not open_positions: return
    logged_open_tickets = state_manager.get_open_trade_tickets()
    for pos in open_positions:
        if pos.ticket not in logged_open_tickets:
            logging.info(f"\nNew trade detected: Position #{pos.ticket}. Logging to database.")
            state_manager.log_new_trade(pos)

def check_for_closed_trades(state_manager, config):
    logged_open_tickets = state_manager.get_open_trade_tickets()
    if not logged_open_tickets: return
    magic_number = config.get('magic_number')
    open_positions = mt5.positions_get(magic=magic_number)
    open_position_tickets = {pos.ticket for pos in open_positions} if open_positions else set()
    
    for ticket in logged_open_tickets:
        if ticket not in open_position_tickets:
            logging.info(f"\nClosed trade detected: Position #{ticket}. Fetching history...")
            from_date = datetime.now(pytz.utc) - timedelta(days=3)
            deals = mt5.history_deals_get(from_date, datetime.now(pytz.utc))
            if deals is None: continue

            profit = 0; close_time = None; close_price = None; symbol = ""
            for deal in deals:
                if deal.position_id == ticket:
                    symbol = deal.symbol
                    if deal.entry == 1:
                        profit += deal.profit
                        close_time = datetime.fromtimestamp(deal.time, tz=pytz.utc)
                        close_price = deal.price
            
            if close_time:
                state_manager.update_closed_trade(ticket, close_time, close_price, profit)
                outcome = "Win" if profit > 0.01 else "Loss" if profit < -0.01 else "Breakeven"
                message = (f"{'🏆' if outcome == 'Win' else '❌'} *Trade Closed ({outcome})*\n"
                           f"Symbol: `{symbol}`\n"
                           f"Ticket: `#{ticket}`\n"
                           f"Profit: `${profit:.2f}`")
                send_telegram_alert(message, config)

# ==============================================================================
# == MAIN BOT LOGIC
# ==============================================================================
def run_bot(config, state_manager):
    logging.info("🚀 Breaker Bot v3.2 is running...")
    
    mt5_handler = MT5Handler(config)
    strategy = BreakerStrategy(config)
    symbols_to_trade = config['symbols_to_trade']
    risk_percent = config['risk_percent']
    fixed_rr = config['fixed_rr']

    active_htf_zones = {symbol: [] for symbol in symbols_to_trade}
    last_h1_scan_times = {}
    loop_count = 0
    spinner_chars = ['|', '/', '-', '\\']

    while True:
        try:
            now_ny = datetime.now(pytz.timezone('America/New_York'))
            
            if not mt5_handler.check_connection():
                sleep_timer.sleep(30)
                continue
            
            check_and_log_new_trades(state_manager, config.get('magic_number'))
            check_for_closed_trades(state_manager, config)
            mt5_handler.manage_pending_orders(state_manager)
            mt5_handler.manage_open_trades(state_manager)
            
            if not is_in_trading_session(config):
                status_message = f"[{now_ny.strftime('%H:%M:%S')} EST] Outside of trading sessions. Pausing... {spinner_chars[loop_count % len(spinner_chars)]}"
                print(status_message, end='\r')
                loop_count += 1
                sleep_timer.sleep(900)
                continue

            for symbol in symbols_to_trade:
                all_tf_data = mt5_handler.get_all_timeframe_data(symbol)
                if not all_tf_data: continue

                h1_df = all_tf_data.get(60)
                last_scan_time = last_h1_scan_times.get(symbol)

                if h1_df is not None and (last_scan_time is None or now_ny.hour != last_scan_time.hour):
                    print() 
                    logging.info(f"Scanning for new H1 zones on {symbol}...")
                    active_htf_zones[symbol] = strategy.find_htf_zones(h1_df)
                    last_h1_scan_times[symbol] = now_ny

                h1_filter_passed = False
                aligned_zone = None
                if not active_htf_zones.get(symbol):
                    h1_filter_passed = True
                else:
                    fifteen_mins_ago = now_ny - timedelta(minutes=15)
                    last_15m_data = all_tf_data[1].loc[fifteen_mins_ago:]
                    if not last_15m_data.empty:
                        for zone in active_htf_zones[symbol]:
                            if (last_15m_data['Low'].min() <= zone['high'] and last_15m_data['High'].max() >= zone['low']):
                                h1_filter_passed = True
                                aligned_zone = zone
                                break
                
                if not h1_filter_passed:
                    continue

                breaker_setup, tf_found = strategy.find_setups(all_tf_data)
                
                if breaker_setup:
                    if aligned_zone and \
                       (('Bullish' in breaker_setup['type'] and 'Bearish' in aligned_zone['type']) or \
                        ('Bearish' in breaker_setup['type'] and 'Bullish' in aligned_zone['type'])):
                        continue
                        
                    setup_id_str = str((symbol, str(breaker_setup['pointD'].name)))
                    if setup_id_str in state_manager.get_traded_setups():
                        continue

                    print()
                    details_log = format_breaker_details(breaker_setup)
                    bc, C = breaker_setup['breaker_candle'], breaker_setup['pointC']
                    
                    if breaker_setup['type'] == 'Bullish':
                        pending_entry_price, order_type = bc['Low'], mt5.ORDER_TYPE_BUY_LIMIT
                    else:
                        pending_entry_price, order_type = bc['High'], mt5.ORDER_TYPE_SELL_LIMIT

                    tick = mt5.symbol_info_tick(symbol)
                    if tick is None: continue
                    if order_type == mt5.ORDER_TYPE_BUY_LIMIT and pending_entry_price >= tick.ask:
                        continue
                    if order_type == mt5.ORDER_TYPE_SELL_LIMIT and pending_entry_price <= tick.bid:
                        continue

                    strategy_sl_price = C['High'] if breaker_setup['type'] == 'Bearish' else C['Low']
                    volume = calculate_dynamic_lot_size(symbol, risk_percent, strategy_sl_price, pending_entry_price)
                    if volume is None or volume == 0:
                        continue
                    
                    symbol_info = mt5.symbol_info(symbol)
                    spread_in_price = symbol_info.ask - symbol_info.bid
                    sl_tp_buffer = spread_in_price * 1.5
                    
                    if breaker_setup['type'] == 'Bearish':
                        final_sl_price = strategy_sl_price + sl_tp_buffer
                        risk_distance = final_sl_price - pending_entry_price 
                        final_tp_price = pending_entry_price - (risk_distance * fixed_rr)
                    else:
                        final_sl_price = strategy_sl_price - sl_tp_buffer
                        risk_distance = pending_entry_price - final_sl_price
                        final_tp_price = pending_entry_price + (risk_distance * fixed_rr)
                    
                    digits = symbol_info.digits
                    final_sl_price, final_tp_price = round(final_sl_price, digits), round(final_tp_price, digits)
                    
                    price_details = (f"*Pending Entry:* `{pending_entry_price:.{digits}f}`\n"
                                     f"*Stop Loss:* `{final_sl_price:.{digits}f}`\n"
                                     f"*Take Profit:* `{final_tp_price:.{digits}f}`\n"
                                     f"*Volume:* `{volume:.2f}`")
                    
                    message = f"*✅ VALID {breaker_setup['type']} Setup Found on {symbol} (M{tf_found})*\n{details_log}\n\n{price_details}"
                    logging.info(message.replace('*', '').replace('`', ''))
                    send_telegram_alert(message, config)
                    
                    result = mt5_handler.place_pending_order(symbol, order_type, volume, pending_entry_price, final_sl_price, final_tp_price)
                    if result and result.retcode == mt5.TRADE_RETCODE_DONE:
                        state_manager.add_traded_setup(setup_id_str)
                        order_ticket = result.order
                        expiry_time = datetime.now(pytz.timezone('America/New_York')) + timedelta(minutes=(tf_found * 3))
                        state_manager.add_pending_order(order_ticket, symbol, expiry_time)
                        logging.info(f"Order #{order_ticket} will expire at {expiry_time.strftime('%H:%M:%S')}")
            
            status_message = f"[{now_ny.strftime('%H:%M:%S')} EST] Bot is running... Last check complete. {spinner_chars[loop_count % len(spinner_chars)]}"
            print(status_message, end='\r')
            loop_count += 1
            sleep_timer.sleep(60)
        except Exception as e:
            logging.error("\n A critical error occurred in the main loop:", exc_info=True)
            sleep_timer.sleep(60)

# ==============================================================================
# == SCRIPT EXECUTION
# ==============================================================================
if __name__ == "__main__":
    setup_logging()
    
    config = load_config()
    state_manager = StateManager()
    
    mt5_handler = MT5Handler(config)

    if not mt5_handler.connect():
        quit()
    
    try:
        run_bot(config, state_manager)
    except KeyboardInterrupt:
        print("\nBot stopped by user.")
    finally:
        state_manager.close_connection()
        mt5_handler.disconnect()