class MT5TradingBot:
    def __init__(self, config):
        self.config = config
        self.symbol = config['symbol']
        
        self.lot_size = config['lot_size']
        self.sl_points = config['sl_points']
        self.tp_points = config['tp_points']
        self.risk_per_trade = config['risk_per_trade']
        self.trade_session_start = config['trade_session_start']
        self.trade_session_end = config['trade_session_end']
        self.log_file = config['log_file']
        self.initialize_mt5()

    def initialize_mt5(self):
        """Initialize the MT5 platform and login."""
        if not mt5.initialize():
            raise RuntimeError(f"MT5 initialization failed: {mt5.last_error()}")
        if not mt5.login(
            self.config['account_login'],
            self.config['account_password'],
            self.config['account_server']
        ):
            raise RuntimeError(f"MT5 login failed: {mt5.last_error()}")
        print("Connected to MetaTrader 5")

    def fetch_data(self, num_candles=500):
        """Fetch historical market data."""
        rates = mt5.copy_rates_from_pos(self.symbol, self.timeframe, 0, num_candles)
        if rates is None:
            raise RuntimeError(f"Failed to fetch data for {self.symbol}: {mt5.last_error()}")
        df = pd.DataFrame(rates)
        df['time'] = pd.to_datetime(df['time'], unit='s')
        return df

    def calculate_indicators(self, df):
        """Calculate technical indicators."""
        df['MA20'] = df['close'].rolling(window=20).mean()
        df['RSI'] = 100 - (100 / (1 + df['close'].pct_change().rolling(window=14).mean()))
        return df

    def find_support_resistance(self, df, period=20):
        """Identify support and resistance levels."""
        df['Support'] = df['low'].rolling(window=period).min()
        df['Resistance'] = df['high'].rolling(window=period).max()
        return df

    def calculate_lot_size(self, account_balance):
        """Calculate lot size based on risk management rules."""
        risk_amount = account_balance * (self.risk_per_trade / 100)
        lot_size = risk_amount / (self.sl_points * 10)
        return max(0.01, round(lot_size, 2))

    def place_trade(self, action, lot_size):
        """Execute a buy or sell trade."""
        price = mt5.symbol_info_tick(self.symbol).ask if action == 'buy' else mt5.symbol_info_tick(self.symbol).bid
        order_type = mt5.ORDER_BUY if action == 'buy' else mt5.ORDER_SELL
        deviation = 10  # Price deviation in points

        request = {
            "action": mt5.TRADE_ACTION_DEAL,
            "symbol": self.symbol,
            "volume": lot_size,
            "type": order_type,
            "price": price,
            "sl": price - self.sl_points if action == 'buy' else price + self.sl_points,
            "tp": price + self.tp_points if action == 'buy' else price - self.tp_points,
            "deviation": deviation,
            "magic": 123456,
            "comment": "TradingBot",
            "type_time": mt5.ORDER_TIME_GTC,
            "type_filling": mt5.ORDER_FILLING_IOC,
        }
        result = mt5.order_send(request)
        if result.retcode != mt5.TRADE_RETCODE_DONE:
            self.log(f"Trade failed: {result}")
        else:
            self.log(f"Trade placed: {result}")
        return result

    def log(self, message):
        """Log messages to a file and console."""
        with open(self.log_file, "a") as f:
            f.write(f"{datetime.now()} - {message}\n")
        print(message)

    def trading_logic(self):
        """Core trading logic."""
        # Fetch account balance
        account_info = mt5.account_info()
        if account_info is None:
            raise RuntimeError("Failed to fetch account info")
        account_balance = account_info.balance

        # Fetch and analyze data
        data = self.fetch_data()
        data = self.calculate_indicators(data)
        data = self.find_support_resistance(data)

        # Get the last row
        last_row = data.iloc[-1]
        lot_size = self.calculate_lot_size(account_balance)

        # Trading logic
        if last_row['close'] > last_row['Resistance']:
            self.log(f"Condition met: BUY at {last_row['close']}")
            self.place_trade('buy', lot_size)
        elif last_row['close'] < last_row['Support']:
            self.log(f"Condition met: SELL at {last_row['close']}")
            self.place_trade('sell', lot_size)

    def run(self):
        """Main loop for running the bot."""
        try:
            while True:
                current_time = datetime.now().strftime("%H:%M")
                if self.trade_session_start <= current_time <= self.trade_session_end:
                    self.trading_logic()
                else:
                    self.log(f"Outside trading session: {current_time}")
                time.sleep(60)  # Run every minute
        except Exception as e:
            self.log(f"Error: {e}")
        finally:
            mt5.shutdown()
            self.log("Bot stopped")


if __name__ == "__main__":
    CONFIG = {
        "account_login": 253779,
        "account_password": "5bed9j!J",
        "account_server": "DooTechnology-Demo",
        "symbol": "EURUSD",
               "lot_size": 0.1,
        "sl_points": 100,
        "tp_points": 200,
        "risk_per_trade": 1.0,
        "trade_session_start": "08:00",
        "trade_session_end": "20:00",
        "log_file": "trading_bot_log.txt",
    }